前言：
今天我们学习STM32CubeMX串口的操作，以及HAL库串口的配置，我们会详细的讲解各个模块的使用和具体功能，并且基于HAL库实现Printf函数功能重定向，UART中断接收，本系列教程将HAL库与STM32CubeMX结合在一起讲解，使您可以更快速的学会各个模块的使用
# u& r0 u, ]- i. B
; B* V8 ^2 Y& p) P0 J
8 d, I1 S' p7 k2 ~! a* Q) x& j所用工具：

1、芯片： STM32F407ZET6

. @$ b& i' J3 f( ?2、STM32CubeMx软件
" t$ v- |2 G3 f0 C
! K0 @" j& Y, W0 _. {+ d3、IDE： MDK-Keil软件

4、STM32F1xx/STM32F4xxHAL库
' Y; b: H% S( `+ S
+ k% J: y7 n9 I+ W  l) ?( {5、串口： 使用USART1 PA9,PA10
) j/ ~* Z% V7 Y
知识概括：

/ u9 O+ S* D  d5 \通过本篇博客您将学到：

) H/ s3 s0 N- B: r" ySTM32CubeMX创建串口例程
; J8 x) w  K# K# l3 ^% C0 P
5 ]' b  N' `5 b- Y+ y8 g; {& ]HAL库UATR函数库
4 k( ~7 g; B) ]# u, z$ l
+ ]/ r6 F9 \4 Y$ D; C1 ?重定义printf函数

, H5 q9 q3 N; {! hHAL库，UART中断接收
' z. A2 X, P. B, H( r4 I" Q
& q: @8 L1 {' j. ?1 WHAL库UATR接收与发送例程
+ g- `; S; _5 h; H8 ~
4 n0 ~  r; }9 Z7 D3 R% B
7 q$ b1 ~7 X- s, h+ e工程创建
! h* _/ {' F5 U: X( z  I
1设置RCC
8 Q4 k1 E. @+ B. Q: `2 D- ~* E
设置高速外部时钟HSE 选择外部时钟源

( e5 F' h7 G4 o" x/ n
) d4 V7 g' G- Q2 c5 H
2设置串口
3 I; [0 @3 M4 c: ~! S5 H2 T* L0 A
7 P. X3 h' G( f8 h

1点击USATR1   
2设置MODE为异步通信(Asynchronous)      
7 M4 E! `2 H$ y. x3基础参数：波特率为115200 Bits/s。传输数据长度为8 Bit。奇偶检验无，停止位1      接收和发送都使能
4GPIO引脚设置 USART1_RX/USART_TX
' v1 A; {/ s: [5 NVIC Settings 一栏使能接收中断


! D  `2 d7 A; ^% V2 B' x% S
3设置时钟



我的是  外部晶振为8MHz

6 I' t7 }5 q9 O1选择外部时钟HSE 8MHz   
: U* s( o4 T3 U7 V. c1 Z+ l2PLL锁相环倍频72倍
3系统时钟来源选择为PLL
4设置APB1分频器为 /2
9 i$ S4 T/ @! x2 V# v1 I
32的时钟树框图 如果不懂的话请看《【STM32】系统时钟RCC详解(超详细，超全面)》
$ S$ x9 r2 B* h" t' l. l( F6 l
4项目文件设置

7 @9 k- J2 `' G
6 M5 P" \% d+ q6 C
) B- m! P5 t# w2 L- w# C5 Z1 设置项目名称
3 C$ F# C, ?( j3 L! E2 设置存储路径
( {7 l7 e1 b3 r- R; M3 选择所用IDE


6 x4 x* I5 s$ i& N' v6 q: H+ x3 H" D. }
5 N- @5 d5 H' \' B- u# m& w" V1 A5创建工程文件

! ^  K% G, H( b+ E' t然后点击GENERATE CODE  创建工程
2 f+ x& P& \, V7 q

8 T5 f5 C+ {2 {6 \配置下载工具
新建的工程所有配置都是默认的  我们需要自行选择下载模式，勾选上下载后复位运行
; Q! u7 O3 C' n, L. R$ i7 q
7 u$ O% L# s$ ]* w# s
# G% W+ L9 @  t% t

( v6 H, r0 Y6 B3 c9 v  c/ CHAL库UART函数库介绍

* z& I. e5 {' s" m. e3 m  UART结构体定义

$ }6 J# q4 G# j, u7 Z' {1 h

1. UART_HandleTypeDef huart1;

复制代码

UART的名称定义，这个结构体中存放了UART所有用到的功能，后面的别名就是我们所用的uart串口的别名，默认为huart1
. ]' X; \# h0 J8 S
, Z; `# h* P$ P- j' W$ s' w( s可以自行修改

. \7 [+ C  l- Z, ?  v& F

1、串口发送/接收函数

4 |* i7 u$ E+ ]% K5 x! X% P. GHAL_UART_Transmit();串口发送数据，使用超时管理机制
HAL_UART_Receive();串口接收数据，使用超时管理机制
% r$ s' ~( j5 S6 i% EHAL_UART_Transmit_IT();串口中断模式发送  
" L. [4 n" }: n8 U% v* ^HAL_UART_Receive_IT();串口中断模式接收
HAL_UART_Transmit_DMA();串口DMA模式发送
% \$ G' x9 w; t2 q. }1 V  q- oHAL_UART_Transmit_DMA();串口DMA模式接收
- o5 j4 z) E; d+ q' H! n% L这几个函数的参数基本都是一样的，我们挑两个讲解一下

% h; h) s: k' i1 V串口发送数据：
- a% r7 c7 |2 m* m* o) W
2 l4 \& X  `+ n! a# t+ o

1. HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)

复制代码

3 U5 w1 ^' \0 @* q& K/ }9 {& d功能：串口发送指定长度的数据。如果超时没发送完成，则不再发送，返回超时标志（HAL_TIMEOUT）。

% p% O. [( c- h1 B. U参数：

UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1  
, L( h/ x/ e: w$ T' }*pData      需要发送的数据
' t* j' h3 R5 _5 HSize    发送的字节数
3 }9 `& J% t0 A' i& TTimeout   最大发送时间，发送数据超过该时间退出发送   

1. 举例：   HAL_UART_Transmit(&huart1, (uint8_t *)ZZX, 3, 0xffff);   //串口发送三个字节数据，最大传输时间0xffff

复制代码

+ A2 B% y0 q. Q9 N中断接收数据：

) W6 @) x, K. @0 E1 O3 o

1. HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)

复制代码

0 k, k9 _! Q& J4 N4 O功能：串口中断接收，以中断方式接收指定长度数据。
大致过程是，设置数据存放位置，接收数据长度，然后使能串口接收中断。接收到数据时，会触发串口中断。
再然后，串口中断函数处理，直到接收到指定长度数据，而后关闭中断，进入中断接收回调函数，不再触发接收中断。(只触发一次中断)
: z7 P3 n3 r. q0 o+ Z; }
参数：

UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1  
*pData      接收到的数据存放地址
Size    接收的字节数

1. 举例：    HAL_UART_Receive_IT(&huart1,(uint8_t *)&value,1);   //中断接收一个字符，存储到value中

复制代码

2、串口中断函数
- o7 }; N" w' S. B2 e1 g+ q. w
HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  //串口中断处理函数
6 x/ z  L9 b1 m# |3 u" V  [' j8 `HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);  //串口发送中断回调函数
. r* m; \  ^' D: e( L4 dHAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);  //串口发送一半中断回调函数（用的较少）
+ V# f! A( t+ ]  R: i. l% `  jHAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);  //串口接收中断回调函数
; l2 M$ ~9 M' @0 b9 T2 h  X7 FHAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);//串口接收一半回调函数（用的较少）
HAL_UART_ErrorCallback();串口接收错误函数

; h. Z0 o* \/ {1 A  i- S: x- e! x# m串口接收中断回调函数：

# ], m0 L7 `1 s4 L3 \! i) @$ x5 h

1. HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);  

复制代码

功能：HAL库的中断进行完之后，并不会直接退出，而是会进入中断回调函数中，用户可以在其中设置代码，

          串口中断接收完成之后，会进入该函数，该函数为空函数，用户需自行修改，

! ]  Y  O" Y0 e. q参数：

UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1  
8 F0 P3 U. _6 Z9 h( ~

1. 举例：   HAL_UART_RxCpltCallback(&huart1){           //用户设定的代码               }

复制代码

& [1 v7 p' P. y; ~# Z$ N) J4 p+ K
  l3 L1 G  P3 }2 K. O串口中断处理函数
: i/ ^2 i/ m+ r5 `

1. HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  

复制代码

/ g: D  {) ~9 p8 C功能：对接收到的数据进行判断和处理  判断是发送中断还是接收中断，然后进行数据的发送和接收，在中断服务函数中使用
; w: a+ B; b/ w% b1 \0 F6 ~* [
如果接收数据，则会进行接收中断处理函数
  a. D6 d+ Q6 \, b' |3 a2 n+ x
. {/ ]5 |8 i( Y: p0 Q0 \

1. /* UART in mode Receiver ---------------------------------------------------*/
   ' }8 X( S" ^: d4 h4 K7 L
2.   if((tmp_flag != RESET) && (tmp_it_source != RESET))
   & [8 O$ F& s7 U% \5 c; c
3.   {
   , W# W; G4 L$ O) l  D* u8 r( C' c
4.     UART_Receive_IT(huart);
   , v$ ~! w' u( U' [$ e
5.   }

复制代码

  W5 T8 X( |7 t, Q: W如果发送数据，则会进行发送中断处理函数

1.   /* UART in mode Transmitter ------------------------------------------------*/
   ' V- |# t* {7 o  B( i
2.   if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
   * w9 C# \$ v! I6 d9 T
3.   {
   
4.     UART_Transmit_IT(huart);
   2 J8 k  a3 u, u& d; N, x
5.     return;
   
6.   }

复制代码

" K# I: b) a, ?, P( X3串口查询函数

( ^/ A0 c3 q5 S4 e1 k  HAL_UART_GetState();  判断UART的接收是否结束，或者发送数据是否忙碌

  举例：     
. f( w3 o* V6 g+ u6 Z& n0 q4 K

1. while(HAL_UART_GetState(&huart4) == HAL_UART_STATE_BUSY_TX)   //检测UART发送结束

复制代码

/ d7 i: t3 z; r% _3 c# W! GUSART接收与发送
重新定义printf函数
9 j. r0 F' a6 d在 stm32f4xx_hal.c中包含#include <stdio.h>
# K' I6 k- b. G' G& c, m4 G

1. #include "stm32f4xx_hal.h"
   
2. #include <stdio.h>
   " G6 o) P0 [- U% O2 T( X7 z+ L. ^
3. extern UART_HandleTypeDef huart1;   //声明串口

复制代码

" H+ N. [2 [; L% B; H. {% }: m在 stm32f4xx_hal.c 中重写fget和fput函数
2 S9 A9 M7 R. X! V( N& \

1. /**
   
2.   * 函数功能: 重定向c库函数printf到DEBUG_USARTx
   4 M' L: o" u) {, ]3 p2 _
3.   * 输入参数: 无
   : `0 s& W, ~0 I2 t# [
4.   * 返 回 值: 无
   ( j2 Z  G: W8 M) Z% a* _
5.   * 说    明：无
   
6.   */
   
7. int fputc(int ch, FILE *f)
   
8. {
   ; @; T; [5 P$ o6 c
9.   HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
   
10.   return ch;
    " N  D: [: b- {: H2 p8 c+ V' ~
11. }
    
12. 
    
13. /**
    * H% o- P- w1 u1 l
14.   * 函数功能: 重定向c库函数getchar,scanf到DEBUG_USARTx
    
15.   * 输入参数: 无
    1 ^6 v9 H7 Y3 C! I
16.   * 返 回 值: 无
    1 i2 [3 K$ _: \0 q. h9 e
17.   * 说    明：无
    ) a4 U$ q* t! A9 J9 @" Y
18.   */
    
19. int fgetc(FILE *f)
    
20. {
    
21.   uint8_t ch = 0;
    3 Z/ i' [1 Y0 e. }: {/ v) \; V
22.   HAL_UART_Receive(&huart1, &ch, 1, 0xffff);
    ( D" k, i# ^+ L8 E9 ^, D
23.   return ch;
    5 p" d* Q8 {9 L, B
24. }

复制代码

$ V9 {8 E. j6 J; M$ s5 F# _1 }2 t在main.c中添加

1. #define RXBUFFERSIZE  256
   
2. char RxBuffer[RXBUFFERSIZE];
   

复制代码

1. 
   - }" I( G" ?8 @! r
2.   while (1)
   
3.   {
   / d6 _$ N5 w& O. M9 ~
4.     /* USER CODE END WHILE */
   
5.                         printf("Z小旋测试\n");
   
6.                         HAL_Delay(1000);
   
7.     /* USER CODE BEGIN 3 */
   
8.   }

复制代码

之后便可以使用Printf函数和Scanf，getchar函数
8 `% z1 H# I% X8 @! H


UART接收中断
因为中断接收函数只能触发一次接收中断，所以我们需要在中断回调函数中再调用一次中断接收函数
1 E# ?% Q$ {: Q$ \
% M9 \5 A$ ^4 e8 v" z4 _具体流程：
1、初始化串口

2、在main中第一次调用接收中断函数
. P5 q4 R) P) H+ x8 J) B. \
3、进入接收中断，接收完数据  进入中断回调函数

  Z0 J5 f; p) f- }' E3 N8 b+ q4、修改HAL_UART_RxCpltCallback中断回调函数，处理接收的数据，

5  回调函数中要调用一次HAL_UART_Receive_IT函数，使得程序可以重新触发接收中断
% U- c) {( t& \+ q3 T
函数流程图：

% N) ~1 r: m. W5 C$ J9 U% T  HHAL_UART_Receive_IT(中断接收函数)    ->  USART2_IRQHandler(void)(中断服务函数)    ->    HAL_UART_IRQHandler(UART_HandleTypeDef *huart)(中断处理函数)    ->   
UART_Receive_IT(UART_HandleTypeDef *huart) (接收函数)   ->   
HAL_UART_RxCpltCallback(huart);(中断回调函数)
" i4 L9 _7 |: C& M& n0 l+ y
HAL_UART_RxCpltCallback函数就是用户要重写在main.c里的回调函数。
  e$ `/ h: B  h5 d; g
代码实现：
$ e4 E( q) X% B" y# b& ?
: ]7 I" r' ?1 O7 n2 x& \  t/ q    并在main.c中添加下列定义：

1. #include <string.h>
   # q3 i0 S$ P9 n( u0 w; p  R1 P( W
2. 
   # _. J4 d! Z$ q
3. #define RXBUFFERSIZE  256     //最大接收字节数
   
4. char RxBuffer[RXBUFFERSIZE];   //接收数据
   
5. uint8_t aRxBuffer;                        //接收中断缓冲
   $ u) P9 m8 a6 ?% P6 B3 a% D
6. uint8_t Uart1_Rx_Cnt = 0;                //接收缓冲计数

复制代码

6 C) G5 V; R, s( ^8 @在main()主函数中，调用一次接收中断函数

1. /* USER CODE BEGIN 2 */
   ( s+ I- Q1 s" y! L8 K
2.         HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);
   6 X# F% D0 ^2 q3 r
3. /* USER CODE END 2 */

复制代码

在main.c下方添加中断回调函数

  W6 e: V& K2 L- n

1. /* USER CODE BEGIN 4 */
   : m4 E2 m6 J  m1 S1 L
2. 
   
3. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   4 G% k9 N- x. x9 V
4. {
   
5.   /* Prevent unused argument(s) compilation warning */
   3 }' n( x; Z; m1 D% ]: T
6.   UNUSED(huart);
   ' L6 T0 }0 b/ x
7.   /* NOTE: This function Should not be modified, when the callback is needed,
   , u; m. ^  y6 ^0 L' {+ H
8.            the HAL_UART_TxCpltCallback could be implemented in the user file
   ! u1 W1 M8 d% {8 g) }. A/ L/ z  j" c
9.    */
   ) r$ g% f7 d4 |/ o4 H
10. 
    
11.         if(Uart1_Rx_Cnt >= 255)  //溢出判断
    4 o1 O$ m! @; i" s* q; C
12.         {
    
13.                 Uart1_Rx_Cnt = 0;
    ; ?) D, n7 d" d) @$ i) U
14.                 memset(RxBuffer,0x00,sizeof(RxBuffer));
    6 S" \# W/ ]+ a- K; M5 n
15.                 HAL_UART_Transmit(&huart1, (uint8_t *)"数据溢出", 10,0xFFFF);         
    3 |* b5 W' T! N6 p0 c7 p/ }, P: |9 e; s+ S
16. 
    0 C* `& B" \( n' v! Q
17.         }
    4 k- ]# J7 {' D* B2 Q0 b( L  x: k5 p
18.         else
    ) i- l( F- D# G! l6 R, G# _5 d
19.         {
    
20.                 RxBuffer[Uart1_Rx_Cnt++] = aRxBuffer;   //接收数据转存
    2 X- }$ l% }1 l; }
21.         
    
22.                 if((RxBuffer[Uart1_Rx_Cnt-1] == 0x0A)&&(RxBuffer[Uart1_Rx_Cnt-2] == 0x0D)) //判断结束位
    
23.                 {
    
24.                         HAL_UART_Transmit(&huart1, (uint8_t *)&RxBuffer, Uart1_Rx_Cnt,0xFFFF); //将收到的信息发送出去
    
25.             while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
    
26.                         Uart1_Rx_Cnt = 0;
    0 I' G$ u4 k! Q: z- T! M2 m
27.                         memset(RxBuffer,0x00,sizeof(RxBuffer)); //清空数组
    1 D/ m, P' o/ E% z. h- [$ _
28.                 }
    3 Q/ h0 c" W& J: s% }6 ~
29.         }
    
30.         
    . U7 x! O. E0 h3 k6 t) I
31.         HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);   //再开启接收中断
    . z& R) t5 X0 I: X+ l
32. }
    
33. /* USER CODE END 4 */

复制代码

% U! Z6 A$ F4 ]2 J2 t5 i# F发送数据被正常返回




  @5 [3 t/ _9 |0 c
: K# S0 C- H; F) S