代码环境
开发工具：STM32CUBEIDE
芯片：STM32L031K6T6
端口： UART2
基本配置
* w" L/ q. S+ h9 m' Z6 h$ A3 j
% |2 G+ u, m5 S) M

8 s5 `: i2 W' @2 B8 k* [
7 A7 T1 {2 U2 V+ N( j

1 W5 R1 b& M& j4 M$ w! M  ]7 o

8 B5 C/ ]% |: Q
7 [0 f. Q* X0 b, V8 A6 y其中，PA9 (RX)的输入上拉，在System Core的GPIO里配置。
% l4 L/ v  G7 U" ], o/ Y
6 Z) \* z/ v4 J" v

TX（发送）设计
! O5 m/ Y( J6 h5 FTX部分增加bsp_usart.c和bsp_usart.h文件，以支持printf重载。
6 J1 Q, m0 I/ {- A
bsp_usart.h内容
+ O4 r% b+ l0 A; C' E; o  A

1. #ifndef __BSP_USART_H
   1 z. u2 U" H4 }/ d, ]
2. #define __BSP_USART_H
   & I; I3 `; I' \
3. 
   
4. #include "stm32l0xx_hal.h"
   
5. #include "stdio.h"                           
   
6. 
   
7. int fputc(int ch, FILE *f);
   . \+ q# H$ F# w1 W* u
8. 
   + s" v6 u2 w, H* t' c* f
9. #endif

复制代码

bsp_usart.c内容

1. #include <bsp_usart.h>
   1 }: _7 p  Y7 A: \) S. y  m
2. 
   % B* M! w9 ]7 Q$ L9 h1 {
3. extern UART_HandleTypeDef huart2;
   
4. 
   
5. /* USER CODE BEGIN 1 */
   8 p, t9 l; ?; w/ g( ~- ], p( b2 d, T* A
6. #ifdef __GNUC__
   0 `4 @8 ]& F1 L$ R- k
7. /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
   7 C2 w; e' c3 p3 d3 B4 Y5 L
8. set to 'Yes') calls __io_putchar() */
   , [* T, T6 W7 Y6 ?' L
9. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   ) i  u8 E/ X8 J, X
10. #else
    & S; l( c3 g- K* L
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
      B/ G4 w/ u; @: k: o4 s
12. #endif /* __GNUC__ */
    9 f/ x. N0 u% k
13. /**
    
14. * @brief  Retargets the C library printf function to the USART.
    
15. * @param  None
    
16. * @retval None
    - b$ J* V1 T1 n. E/ B& b$ L/ v" |
17. */
    
18. PUTCHAR_PROTOTYPE {
    1 w9 R9 a8 T; k2 r- X2 p
19.         /* Place your implementation of fputc here */
      ^. {" l/ v# C
20.         /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */
    
21.         HAL_UART_Transmit(&huart2, (uint8_t*) &ch, 1, 0xFFFF);
    
22.         return ch;
    
23. }
    8 O3 f$ j0 b0 V  `( d! |$ {7 V
24. /* USER CODE END 1 */
    

复制代码

, k" ^4 n5 C* @在main.c文件里引入头文件
2 g+ I3 i% H8 T% |7 u

1. #include <stdbool.h>
   " }% x; W( F4 I2 u! P0 L. k1 t
2. #include <string.h>
   
3. #include <stdio.h>
   8 F" ~* V: \# H: T
4. #include "bsp_usart.h"

复制代码

0 S) F8 w/ t2 C然后，就可以使用printf(“uart2 output data = %d \r\n”, data)；了。

+ I$ O) N9 L! t: M! KRX（接收）设计
* T: [% M7 D5 D5 Y常规的串口接收设计，都需要设计当前接收字节后的超时识别，如果出现超时，认为接收结束。即使是固定字节长度的传输，也需要为异常情况下设计超时识别作为传输结束。
5 Z9 c' ]. |! x  `! p( vSTM32 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. 通过轮询接收后续字节。
% H- u- o+ p' t  |! j* J
' O( I3 T- H) R+ \# J" Y3 }main()函数前初始化相关代码，部分代码由STM32CUBEIDE自动生成：
- N0 d0 Y' S, R' }7 y8 q8 J4 K

1. /* Private macro -------------------------------------------------------------*/
   ; Z+ h3 r5 `2 `7 V* n: T& J& w
2. /* USER CODE BEGIN PM */
   9 E: n$ u& n' _( Q3 ]: z; G( ^! e
3. #define UART2_RX_STOP 0
   ; ?5 t# E* G* E. @: X2 X
4. #define UART2_RX_START 1
   ! d3 @) U8 {$ I( J* ]3 ~
5. /* USER CODE END PM */
   0 P% g, r% _% R8 ~" K: T
6. /* Private variables ---------------------------------------------------------*/
   $ ]+ O. {1 n8 X$ E. w" s$ X
7. UART_HandleTypeDef huart2;
   # ~2 M/ G* q/ N, T
8. /* USER CODE BEGIN PV */
   . B' B  h  Z( h2 m
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.
    ( A. \) K: g" Q
11. uint8_t uart2_rx_flag = UART2_RX_STOP;
    - ?! u* ~: W. _& u$ h
12. HAL_StatusTypeDef uart2_status_rx;
    ; A) K" }% K. _$ |3 l
13. /* Private function prototypes -----------------------------------------------*/
    1 J4 E, ?5 _/ U9 L$ x5 [9 l
14. void SystemClock_Config(void);
    
15. static void MX_USART2_UART_Init(void);

复制代码

! t, y% e! _5 dmain()函数相关代码，部分代码由STM32CUBEIDE自动生成：

7 I' D8 J" X, f2 U6 S- e. d1 h

1. int main(void)
   
2. {
   6 j( ?5 B5 A, q$ W# W; z9 i0 V5 g
3.   /* USER CODE BEGIN 1 */
   ! h% t/ i2 o6 j/ G% S
4.   /* USER CODE END 1 */
   
5.   /* MCU Configuration--------------------------------------------------------*/
   
6.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
7.   HAL_Init();
   & ]9 j- k9 ?6 i7 P3 {3 F
8.   /* USER CODE BEGIN Init */
   2 x; [, l4 }  v2 E" K( g" s, \) K1 ^
9.   /* USER CODE END Init */
   
10.   /* Configure the system clock */
    0 y9 T1 G* S9 u0 Y; e/ H6 O' r' L
11.   SystemClock_Config();
    
12.   /* USER CODE BEGIN SysInit */
    
13.   /* USER CODE END SysInit */
    
14.   /* Initialize all configured peripherals */
    
15.   MX_USART2_UART_Init();
    : f# l2 F" |9 Q! o: P5 \
16.   /* USER CODE BEGIN 2 */
    + M* ^1 I+ E1 k( q4 z
17.   /* USER CODE END 2 */
    
18.   /* Infinite loop */
    / J* v1 c' i! q! h8 T0 F
19.   /* USER CODE BEGIN WHILE */
    
20.   if (HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1)!=HAL_OK) printf("UART2 IT FAILED! \r\n");
    . Q( l8 [/ e& M
21.   while (1)
    4 M. h! H+ Z) j8 n' W( I' w
22.   {
    
23.     /* USER CODE END WHILE */
    0 J4 R* F' p+ h6 ?
24.     /* USER CODE BEGIN 3 */
    . I2 W* W8 I$ z  j& g
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;
    & L. B! f4 y1 E& g, z- S, c
30.              memset(Uart2_RxBuff, 0, sizeof(Uart2_RxBuff));
    
31.              MX_USART2_UART_Init();
    0 p3 f: S/ R- g/ F$ ^# Y
32.              HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1);
    
33. 
    4 a& o* z  }0 V' }: a6 w
34.      }
    
35.           HAL_Delay(1);   //must for timing
    
36.   }
    
37.   /* USER CODE END 3 */
    
38. }

复制代码

中断响应通过函数HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)的重载实现。

( ]9 f- Z2 M2 F, @. ?& `+ C5 X

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   * s) ?0 o3 D* w  ~
2. {
     b- S; z: |4 _3 K4 T& k
3. 
   
4.         Uart2_RxBuff[0] = aRxBuffer;
   . \; a5 J  w" N4 D
5.         uart2_rx_flag = UART2_RX_START;
   
6. 
   
7.           //printf("uart2 get rx interrupt!\r\n");
   
8.       return;
   
9. }

复制代码

注意事项
! l2 o' o2 F, L& }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), 时序才正常。
) q2 }5 L% a* u; A-End-

8 K" o( z2 o5 c: [: x/ X