代码环境
0 Y( K8 [# t$ s) H8 _开发工具：STM32CUBEIDE
+ @/ y3 e( s- k! ^" R" G, a芯片：STM32L031K6T6
9 t. R3 d( _% b) e. F+ V0 D% l端口： UART2
基本配置

" V7 E1 {) @: ^! E7 ]; {) b# v

( r! _9 `- V' s$ |# i

5 [6 h0 b5 k, o$ f+ v- W# E) x
其中，PA9 (RX)的输入上拉，在System Core的GPIO里配置。
. e2 M+ L9 Q5 J& e( v  a: k

7 W" I$ M( r: n
TX（发送）设计
' g( d; O4 I; KTX部分增加bsp_usart.c和bsp_usart.h文件，以支持printf重载。
9 h4 [; q$ v2 P: O$ t8 R" H
9 c, T) y- `5 l: }: M; {bsp_usart.h内容
$ D, U' i" m" \; q

1. #ifndef __BSP_USART_H
   
2. #define __BSP_USART_H
   ! _1 H5 i6 C6 r2 u1 U. g. n
3. 
   
4. #include "stm32l0xx_hal.h"
   $ I+ q) m2 c) b% v7 e; G
5. #include "stdio.h"                           
     Q" F$ Z* Y2 g4 s* I" r
6. 
   : P  L/ E/ k* G8 b4 ?+ ~0 M
7. int fputc(int ch, FILE *f);
   7 N8 k! z; @3 S9 a+ i) \; f, }# N
8. 
   
9. #endif

复制代码

# |, b; J# U" E( Z  x' ^bsp_usart.c内容

1. #include <bsp_usart.h>
   5 C- r* x( K0 K# w
2. 
   ! w7 n0 K+ d4 M. c, x
3. extern UART_HandleTypeDef huart2;
   
4. 
   
5. /* USER CODE BEGIN 1 */
   7 f- q. x1 Z: N. t/ ~7 D
6. #ifdef __GNUC__
     j% N4 c0 N- B% Z0 j. Q) ~: _9 q: G
7. /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
   
8. set to 'Yes') calls __io_putchar() */
   ' k. B0 z, A# w" K) c/ s
9. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   1 }2 x4 r; {+ N$ |8 O
10. #else
    
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    + Q. H& f" f9 Z0 {- I" t
12. #endif /* __GNUC__ */
    
13. /**
    8 ~0 U8 U- W% O) w# r
14. * @brief  Retargets the C library printf function to the USART.
    
15. * @param  None
    
16. * @retval None
    - O: S  `0 J5 j7 u! Y: ]5 J
17. */
    # Y' k2 @3 E* c, @9 [
18. PUTCHAR_PROTOTYPE {
    - _0 A9 |1 g7 D. h7 D; q
19.         /* Place your implementation of fputc here */
    
20.         /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
    ! Z6 L* a  ^. T4 e
21.         HAL_UART_Transmit(&huart2, (uint8_t*) &ch, 1, 0xFFFF);
    5 v/ O! J/ f8 F" j0 H
22.         return ch;
    
23. }
    & g& x" X+ N0 N& z
24. /* USER CODE END 1 */
    + N4 L& o" E" k0 R/ c

复制代码

: [: n$ e; K9 K2 ^8 r3 W4 F/ q! ]在main.c文件里引入头文件

1. #include <stdbool.h>
   6 a- [1 h& P, L" v/ E
2. #include <string.h>
   2 ?$ ]& e3 _2 {# C, r9 v
3. #include <stdio.h>
   
4. #include "bsp_usart.h"

复制代码

& d" s% j' V  h$ o9 w( {0 j2 s; |然后，就可以使用printf(“uart2 output data = %d \r\n”, data)；了。
% q- [5 H" }7 n5 H' G) b4 b
RX（接收）设计
常规的串口接收设计，都需要设计当前接收字节后的超时识别，如果出现超时，认为接收结束。即使是固定字节长度的传输，也需要为异常情况下设计超时识别作为传输结束。
STM32 HAL库支持轮询超时的方式接收串口数据（HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)），也支持中断的方式接收串口数据（HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)），因此考虑将两种方式结合使用，以简化超时判断的设计。
主要的设计思路是：1.通过中断接收第一个字节；2. 通过轮询接收后续字节。
7 j6 Q, S  B& j- y) k
main()函数前初始化相关代码，部分代码由STM32CUBEIDE自动生成：
9 ]0 k" x! B# U) `/ ?
' u$ X0 X# a* [6 y

1. /* Private macro -------------------------------------------------------------*/
   
2. /* USER CODE BEGIN PM */
   8 ~3 ]* b: o2 D3 o. j& n$ B
3. #define UART2_RX_STOP 0
   
4. #define UART2_RX_START 1
   6 B9 ^- x5 Z' {  L3 Q7 o
5. /* USER CODE END PM */
   
6. /* Private variables ---------------------------------------------------------*/
   
7. UART_HandleTypeDef huart2;
   ) N3 l7 {' h) `3 |6 x2 b! W
8. /* USER CODE BEGIN PV */
   ! y; d2 s6 k% O9 c6 Q$ z3 {' N& f
9. uint8_t aRxBuffer;                        //RX int buffer, 1 byte
   
10. uint8_t Uart2_RxBuff[10] = {0};                //Rx buffer，should be adjusted according to Rx max byte length per communication.
    
11. uint8_t uart2_rx_flag = UART2_RX_STOP;
    2 [* ^: w& i) `
12. HAL_StatusTypeDef uart2_status_rx;
    
13. /* Private function prototypes -----------------------------------------------*/
      W5 [+ C& y8 D2 r. M8 W
14. void SystemClock_Config(void);
    * B7 r7 O- l9 |' M7 o
15. static void MX_USART2_UART_Init(void);

复制代码

main()函数相关代码，部分代码由STM32CUBEIDE自动生成：

& k9 D$ m5 L: D) h/ N# X0 o) G

1. int main(void)
   * ], V4 @. C! f/ G: m" A7 Z
2. {
   
3.   /* USER CODE BEGIN 1 */
   - }7 E3 q: X8 `2 i2 l3 n6 `0 [
4.   /* USER CODE END 1 */
   $ ~5 Z( y" F# [. L
5.   /* MCU Configuration--------------------------------------------------------*/
   7 |3 v* l7 B3 \7 b4 }  b7 _/ K; f; P
6.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
7.   HAL_Init();
   
8.   /* USER CODE BEGIN Init */
   3 T6 A+ P4 A( C, m
9.   /* USER CODE END Init */
   ) K5 q3 ~+ W) s9 x% o' W' x
10.   /* Configure the system clock */
    5 @3 c  ^- h2 v5 `  V  B
11.   SystemClock_Config();
    
12.   /* USER CODE BEGIN SysInit */
    . {" ~: o: `8 Z0 a8 f
13.   /* USER CODE END SysInit */
    3 ^% J2 v9 U( @7 ^& K( B* G
14.   /* Initialize all configured peripherals */
    
15.   MX_USART2_UART_Init();
    
16.   /* USER CODE BEGIN 2 */
    
17.   /* USER CODE END 2 */
    ) r7 d1 b: n' Z8 y
18.   /* Infinite loop */
    3 S3 v2 U) {) M) {  J- ^  _
19.   /* USER CODE BEGIN WHILE */
    ( j; y$ W$ b( d; M. R
20.   if (HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1)!=HAL_OK) printf("UART2 IT FAILED! \r\n");
    
21.   while (1)
    + r* W% Y* b# B6 A) x: \9 E
22.   {
    . T: D; w+ [: S) e2 b& g
23.     /* USER CODE END WHILE */
    
24.     /* USER CODE BEGIN 3 */
    0 M1 Z5 p- {! g9 r- A2 _( o% l& M3 _
25.      if (uart2_rx_flag == UART2_RX_START)
    
26.      {
    # g" w, {* Q7 f4 ~; S0 n4 N
27.              uart2_status_rx = HAL_UART_Receive(&huart2, Uart2_RxBuff+1, 9, 100);
    
28.              printf("uart2 got rx data: %d  %d %d %d %d %d %d %d %d %d\r\n", Uart2_RxBuff[0], Uart2_RxBuff[1], Uart2_RxBuff[2], Uart2_RxBuff[3], Uart2_RxBuff[4], Uart2_RxBuff[5], Uart2_RxBuff[6], Uart2_RxBuff[7], Uart2_RxBuff[8], Uart2_RxBuff[9]);
    
29.              uart2_rx_flag = UART2_RX_STOP;
    
30.              memset(Uart2_RxBuff, 0, sizeof(Uart2_RxBuff));
    8 g& U0 B* }8 F' s' }( I$ `
31.              MX_USART2_UART_Init();
    
32.              HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1);
    
33. 
    % S4 A6 s8 G$ K1 o7 F8 M
34.      }
    6 ^& m, X- N# y$ p( D& ?1 `) \6 |
35.           HAL_Delay(1);   //must for timing
    0 q4 P) \0 J4 i8 L$ v. ?- z1 K
36.   }
    
37.   /* USER CODE END 3 */
    
38. }

复制代码

中断响应通过函数HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)的重载实现。
/ K+ N9 |' t6 o7 s* X! g
" Z1 Q% N' W2 ?0 K7 T4 E4 z

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   ' }( A2 d! I, J7 G
2. {
   ! d) W0 ?; X$ O: ~9 {; g) K
3. 
   ) K! `$ k% O" D, U! U
4.         Uart2_RxBuff[0] = aRxBuffer;
   - t  G% o$ d3 r! w& S9 R
5.         uart2_rx_flag = UART2_RX_START;
   
6. 
   # Y# F$ t6 V6 U4 s# h% M& |
7.           //printf("uart2 get rx interrupt!\r\n");
   7 z$ [8 `+ r7 c1 b& U  |5 P
8.       return;
   ' e0 W9 E: j3 B- s  @3 _2 z1 Y- Q; g
9. }

复制代码

1 n/ d0 i3 t- c6 z注意事项
HAL_UART_Receive（）不能放在HAL_UART_RxCpltCallback（）函数里处理，HAL_UART_Receive（）的Timeout会失效。这是因为SysTick的中断优先级低于了外设UART的中断优先级，在UART的中断处理过程中无法响应SysTick中断。（如果一定要把HAL_UART_Receive（）放在HAL_UART_RxCpltCallback（）函数里，就需要调整SysTick中断的优先级）。
9 B" Z, M/ N# mmain()里的while(1)循环，需要延时HAL_Delay(1), 时序才正常。
-End-

$ T% J4 U, E: X; ]