代码环境
4 f, c" y: {9 a$ p9 h! T' Z& _开发工具：STM32CUBEIDE
芯片：STM32L031K6T6
7 X7 ^6 R6 r/ Q$ V端口： UART2
& J) }. P- l. Y' i* E基本配置

4 u' c6 C! X, V7 @# ?0 y$ w: W1 \
! E0 C# z; y8 ?) v& I+ s

% P) d+ t: y8 x1 a
4 t  U" s5 t# m

: \7 S8 d4 s( b$ A, w
1 h# G8 S/ D$ d4 G* V% [其中，PA9 (RX)的输入上拉，在System Core的GPIO里配置。
+ W" F" \; B" e
5 w4 O4 F* T* u2 i% _1 |" Q! Z5 k1 |

/ S( i# S% h2 T1 A
TX（发送）设计
TX部分增加bsp_usart.c和bsp_usart.h文件，以支持printf重载。
" i+ d0 C1 A9 j' y- m( N
8 D; L0 W) h" ?0 P1 e' e+ o0 Bbsp_usart.h内容

1. #ifndef __BSP_USART_H
   
2. #define __BSP_USART_H
   / l" R7 y/ {2 q& z9 j( ]
3. 
   
4. #include "stm32l0xx_hal.h"
   & _6 p6 V) l6 r" U3 S2 X
5. #include "stdio.h"                           
   
6. 
   
7. int fputc(int ch, FILE *f);
   
8. 
   5 ~( W% {. K3 {1 ?& O
9. #endif

复制代码

bsp_usart.c内容
$ [* j# e) R, w1 i# y0 y

1. #include <bsp_usart.h>
   ) s8 D; k- v) c4 l& M
2. 
   0 y* G" }; @/ n) D5 A8 T2 ?
3. extern UART_HandleTypeDef huart2;
   
4. 
   6 M1 ?8 z$ y) b' u$ w' }  t. U# P1 q
5. /* USER CODE BEGIN 1 */
   4 V8 J) W8 U7 L7 T
6. #ifdef __GNUC__
   6 n: o. _$ J* Q, D5 k2 _: |2 Y% y2 }
7. /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
   
8. set to 'Yes') calls __io_putchar() */
   
9. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   + i0 `7 g8 h3 [! l* F1 b- k
10. #else
    
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    
12. #endif /* __GNUC__ */
    $ V3 ~9 [7 X" q  V0 X" Q( M: e
13. /**
    - m6 c; G2 ~2 }. p0 U
14. * @brief  Retargets the C library printf function to the USART.
    ( W3 b! O4 L- b
15. * @param  None
    
16. * @retval None
    4 B% v  G+ F2 |7 W
17. */
    7 G* y9 g; V% w% `1 {
18. PUTCHAR_PROTOTYPE {
    
19.         /* Place your implementation of fputc here */
    ' {" N8 q* I) r
20.         /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
    6 A8 [! L! m% v7 q
21.         HAL_UART_Transmit(&huart2, (uint8_t*) &ch, 1, 0xFFFF);
    
22.         return ch;
    
23. }
    " c6 s% w0 M2 R# h
24. /* USER CODE END 1 */
    % q, m, Y1 T) `7 Q

复制代码

在main.c文件里引入头文件

1. #include <stdbool.h>
   # C, A5 x/ S) @' G$ i& l  O5 F
2. #include <string.h>
   4 X5 ]4 P9 M- {; N, N5 E3 t3 p
3. #include <stdio.h>
   
4. #include "bsp_usart.h"

复制代码

然后，就可以使用printf(“uart2 output data = %d \r\n”, data)；了。

% A3 K! G0 q3 rRX（接收）设计
9 ]$ ?, `: }* D# g* \. N0 ~常规的串口接收设计，都需要设计当前接收字节后的超时识别，如果出现超时，认为接收结束。即使是固定字节长度的传输，也需要为异常情况下设计超时识别作为传输结束。
7 v! I0 `* F: M: R- S/ cSTM32 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. 通过轮询接收后续字节。

. o7 [1 Q- l8 a& Lmain()函数前初始化相关代码，部分代码由STM32CUBEIDE自动生成：

5 V3 z9 P) \) P

1. /* Private macro -------------------------------------------------------------*/
   
2. /* USER CODE BEGIN PM */
   
3. #define UART2_RX_STOP 0
   2 {1 @1 \, d' P9 U/ x3 Y) v
4. #define UART2_RX_START 1
   
5. /* USER CODE END PM */
   ; J2 q6 Z1 t) f
6. /* Private variables ---------------------------------------------------------*/
   
7. UART_HandleTypeDef huart2;
   
8. /* USER CODE BEGIN PV */
   
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;
    0 I' R- M8 e' {
12. HAL_StatusTypeDef uart2_status_rx;
    
13. /* Private function prototypes -----------------------------------------------*/
    2 @( h* T7 k1 s. R# ?
14. void SystemClock_Config(void);
    
15. static void MX_USART2_UART_Init(void);

复制代码

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

  X$ o/ s& ]+ [9 d

1. int main(void)
   5 |. T+ x: L+ }% L
2. {
   
3.   /* USER CODE BEGIN 1 */
   + T3 R7 G- V  L% H
4.   /* USER CODE END 1 */
     \- Q8 l4 E6 O( g. G/ ~: O
5.   /* MCU Configuration--------------------------------------------------------*/
   
6.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   ) M0 ^$ N# h8 }: T$ K' U$ u
7.   HAL_Init();
   5 F% T1 K% I8 U* w+ j
8.   /* USER CODE BEGIN Init */
   
9.   /* USER CODE END Init */
   
10.   /* Configure the system clock */
    # d9 W6 j0 O) y8 ^: E% O: ]
11.   SystemClock_Config();
    
12.   /* USER CODE BEGIN SysInit */
    
13.   /* USER CODE END SysInit */
    
14.   /* Initialize all configured peripherals */
    
15.   MX_USART2_UART_Init();
    * z7 ^$ {: k  E& o  e5 e/ K$ ^
16.   /* USER CODE BEGIN 2 */
    % r6 l+ Y9 ~! v; I: {
17.   /* USER CODE END 2 */
    1 ?! {) P8 `9 c: H0 |/ u! F
18.   /* Infinite loop */
    2 ]' O, Q5 |! L0 P
19.   /* USER CODE BEGIN WHILE */
    3 T% \  f- s2 H# q) C) u
20.   if (HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1)!=HAL_OK) printf("UART2 IT FAILED! \r\n");
    ' z0 d. `, q! ^1 ~8 e% ], X
21.   while (1)
    6 U, I! J5 d0 Q; t  R
22.   {
    # @9 n) @% v. i$ j0 m
23.     /* USER CODE END WHILE */
    
24.     /* USER CODE BEGIN 3 */
    
25.      if (uart2_rx_flag == UART2_RX_START)
    
26.      {
    
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;
    / c# ^" g% Q& F: n& T2 x! s
30.              memset(Uart2_RxBuff, 0, sizeof(Uart2_RxBuff));
    7 ^0 O, w1 i) Q$ `
31.              MX_USART2_UART_Init();
    
32.              HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1);
    2 E) C8 P. R* @& z% d4 G
33. 
    ( D5 b5 n  }; s) @$ N
34.      }
    
35.           HAL_Delay(1);   //must for timing
      d/ q1 p7 [5 M3 F# u# ~8 G4 i. b
36.   }
    
37.   /* USER CODE END 3 */
    7 ]& X- |. K; R/ p; I" ~& n
38. }

复制代码

$ Y8 p- f+ r- R$ Z9 \9 V中断响应通过函数HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)的重载实现。
- c" r0 S9 d  a. x
7 {: ]' U# r: @4 a8 P6 i

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   ; O& y8 }( I) C4 z; U
2. {
   
3. 
   
4.         Uart2_RxBuff[0] = aRxBuffer;
   
5.         uart2_rx_flag = UART2_RX_START;
   ! s& C1 e' i9 S1 e% q' C+ J
6. 
   
7.           //printf("uart2 get rx interrupt!\r\n");
   
8.       return;
   
9. }

复制代码

! Q7 @+ v& A$ B0 e9 w6 k# e注意事项
HAL_UART_Receive（）不能放在HAL_UART_RxCpltCallback（）函数里处理，HAL_UART_Receive（）的Timeout会失效。这是因为SysTick的中断优先级低于了外设UART的中断优先级，在UART的中断处理过程中无法响应SysTick中断。（如果一定要把HAL_UART_Receive（）放在HAL_UART_RxCpltCallback（）函数里，就需要调整SysTick中断的优先级）。
main()里的while(1)循环，需要延时HAL_Delay(1), 时序才正常。
( Q) L! o* `8 n# J9 b) o  P-End-
9 k" m% w5 ?4 U! ^5 P( r+ H* F6 Y