前言：
今天我们学习STM32CubeMX串口的操作，以及HAL库串口的配置，我们会详细的讲解各个模块的使用和具体功能，并且基于HAL库实现Printf函数功能重定向，UART中断接收，本系列教程将HAL库与STM32CubeMX结合在一起讲解，使您可以更快速的学会各个模块的使用

( |; `* M9 ?/ _* x' r3 i! c
' X/ z- O: j: t4 m) ?: L所用工具：

1 z0 z, t0 Z" ]4 S7 s. |0 Q  ~1、芯片： STM32F407ZET6

2、STM32CubeMx软件

3、IDE： MDK-Keil软件

4、STM32F1xx/STM32F4xxHAL库

& E: k, r) ]( n0 x1 q2 w+ ]5 t5、串口： 使用USART1 PA9,PA10

知识概括：
. A0 r: y7 o% r0 J! S6 V
通过本篇博客您将学到：

STM32CubeMX创建串口例程
4 s/ J  z% `* H! F  i
HAL库UATR函数库

重定义printf函数
8 g$ r$ r6 J2 x& O2 D
( `: x$ P+ f# k8 O- yHAL库，UART中断接收
; D  j% ~/ F4 L& R2 A# V; q8 H
HAL库UATR接收与发送例程


工程创建
! @0 r% }! A7 @  D
- i% V4 ]7 u( z( y2 M4 k$ L1设置RCC
5 A& S9 F) x7 z& |% q# p+ c
设置高速外部时钟HSE 选择外部时钟源

7 @9 n( ]3 r( Q4 |6 l" {

8 @6 g; ~# t. ^" P( e3 L2设置串口
# c0 g+ _1 B$ P# [1 O* P! j( }. u
. D- n8 G$ i$ k: b6 o3 B* [6 n* p
- j; h! O; Q$ r6 V( H; I: B, Q
& B7 \) d* M  k4 o. s! U* o1点击USATR1   
2设置MODE为异步通信(Asynchronous)      
3基础参数：波特率为115200 Bits/s。传输数据长度为8 Bit。奇偶检验无，停止位1      接收和发送都使能
4GPIO引脚设置 USART1_RX/USART_TX
1 v. Q8 [2 ]2 R( b/ r( J; s; z1 w5 NVIC Settings 一栏使能接收中断



6 n3 j4 i% p, e! `6 U) z3设置时钟
( R% Z5 t% i( v7 |5 e

! R* H. U, F: f3 J
我的是  外部晶振为8MHz

1选择外部时钟HSE 8MHz   
2PLL锁相环倍频72倍
3 T% q0 h" ~2 @( @: \# C( Z3 ~; `+ @3系统时钟来源选择为PLL
4设置APB1分频器为 /2
3 t2 w- v- [# s; u" Z$ f4 a9 v
32的时钟树框图 如果不懂的话请看《【STM32】系统时钟RCC详解(超详细，超全面)》
1 Q! O5 @5 r; ]2 x* ?
, n! l2 T* h! P. r; L2 }4项目文件设置
6 C6 m* ?/ E! ]
* m3 M1 G- H" i8 Z1 R5 E

1 设置项目名称
2 设置存储路径
, K5 P6 X) n. V- V/ P% ]+ i% m# M3 选择所用IDE

1 y5 Z; J  M4 u  y; ^  ^
" |" ?) D* l( o, m: B) f
5创建工程文件

- }$ f) d7 _; p  n然后点击GENERATE CODE  创建工程
& J) O. {' G. J- b
4 B( h" T4 p; C0 b$ b1 M( Y+ F
- @: R9 d. u7 U配置下载工具
1 o( U0 F5 ]& {, j9 P  e新建的工程所有配置都是默认的  我们需要自行选择下载模式，勾选上下载后复位运行
& @) g4 Q0 V# t8 h
" G. J' M1 M- u! j% M

7 R) ?5 K; w, m, X
2 ?) h% S0 u% e8 l" {5 aHAL库UART函数库介绍
" u9 B* s& m2 C8 S# [0 f2 {
  UART结构体定义
7 _8 A2 H" d/ \/ J- a2 S$ M0 i& V

1. UART_HandleTypeDef huart1;

复制代码

UART的名称定义，这个结构体中存放了UART所有用到的功能，后面的别名就是我们所用的uart串口的别名，默认为huart1
& ]: {, x9 p/ s4 a/ h
* c! A9 |" E9 `) _可以自行修改
5 [0 A1 A8 U: b6 v4 B% m* i


. d3 N' s8 Y) T/ F- K, `1、串口发送/接收函数

) k! D. Z2 {% Q6 ^9 A: N0 HHAL_UART_Transmit();串口发送数据，使用超时管理机制
7 V" s/ y: @, v) B, L$ s9 w8 hHAL_UART_Receive();串口接收数据，使用超时管理机制
+ d. w7 Y$ G2 Y' B7 A$ J0 B: RHAL_UART_Transmit_IT();串口中断模式发送  
2 e  h0 H* X% O( S6 eHAL_UART_Receive_IT();串口中断模式接收
5 l; G2 u( a% U8 L3 t) g, i* f7 JHAL_UART_Transmit_DMA();串口DMA模式发送
% c: @* |" x9 V3 P9 FHAL_UART_Transmit_DMA();串口DMA模式接收
这几个函数的参数基本都是一样的，我们挑两个讲解一下

串口发送数据：

1 C: D( r6 T. D; Z6 g4 y! k

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

复制代码

4 {) q5 D1 p3 x功能：串口发送指定长度的数据。如果超时没发送完成，则不再发送，返回超时标志（HAL_TIMEOUT）。

2 D8 i: I9 t( S2 V% K' v参数：

UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1  
*pData      需要发送的数据
+ M& w) R2 \8 t% ISize    发送的字节数
Timeout   最大发送时间，发送数据超过该时间退出发送   

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

复制代码

中断接收数据：
. M+ g0 V- X: H: h0 p5 c

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

复制代码

功能：串口中断接收，以中断方式接收指定长度数据。
2 n4 A3 B$ H, L大致过程是，设置数据存放位置，接收数据长度，然后使能串口接收中断。接收到数据时，会触发串口中断。
再然后，串口中断函数处理，直到接收到指定长度数据，而后关闭中断，进入中断接收回调函数，不再触发接收中断。(只触发一次中断)
- L* {8 f8 r" h  N# c& ?
! @3 O2 D& ^- e1 ]6 H参数：
0 ]2 p/ N3 v7 K. @0 f
9 j2 }  Z5 k  i, V: C& bUART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1  
3 w& N3 ?8 L  H* |*pData      接收到的数据存放地址
Size    接收的字节数

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

复制代码

5 g9 _2 p+ G4 [% i& U. x2、串口中断函数
; j6 j6 {7 J% G8 n) X. [" V
8 M2 U, g) M3 s& n: `1 E* x  X" z9 SHAL_UART_IRQHandler(UART_HandleTypeDef *huart);  //串口中断处理函数
HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);  //串口发送中断回调函数
4 j, l" A! m" K( q3 iHAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);  //串口发送一半中断回调函数（用的较少）
HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);  //串口接收中断回调函数
HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);//串口接收一半回调函数（用的较少）
( T# e/ \% V& \% }  jHAL_UART_ErrorCallback();串口接收错误函数
. e, Q; O* H7 X6 c  x6 ]$ j6 U
! h. {0 ]2 Z( H) V  m9 Q  m. Z* C. s串口接收中断回调函数：

1. HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);  

复制代码

5 P( F0 W! |1 C( c% M" B" f功能：HAL库的中断进行完之后，并不会直接退出，而是会进入中断回调函数中，用户可以在其中设置代码，
4 a4 d$ e# g4 [( k: P2 l$ C! S
/ G8 F6 @6 d5 h- _" H8 p) y* r          串口中断接收完成之后，会进入该函数，该函数为空函数，用户需自行修改，
( Y' ?- s; b, g! W; n
参数：
6 U9 \5 h& H4 J  @. v! [0 v
UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1  

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

复制代码

; I0 t& o7 b+ H( [$ Z9 a
串口中断处理函数

6 t4 t, i/ N8 ]0 h4 R7 F- H" I

1. HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  

复制代码

. w# [' ]1 g$ A% B; ~: g功能：对接收到的数据进行判断和处理  判断是发送中断还是接收中断，然后进行数据的发送和接收，在中断服务函数中使用

如果接收数据，则会进行接收中断处理函数
: R" ?, S9 A# Q7 q+ d8 R) Q1 G0 r
1 t; e- @4 u+ a* Z% `* X8 K

1. /* UART in mode Receiver ---------------------------------------------------*/
   
2.   if((tmp_flag != RESET) && (tmp_it_source != RESET))
   # P8 I# A( ~; Q" I) t+ I
3.   {
   
4.     UART_Receive_IT(huart);
   
5.   }

复制代码

( L1 x$ ?3 X; F0 c) a; Z8 |* M3 i; F$ z$ t如果发送数据，则会进行发送中断处理函数
3 ]0 Q- A% O. \, `% w+ r

1.   /* UART in mode Transmitter ------------------------------------------------*/
   % Q+ r+ L( c. ?4 n8 Y
2.   if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
   
3.   {
   4 Q; |+ i: q9 y+ C. F' T6 O
4.     UART_Transmit_IT(huart);
   
5.     return;
   ) f+ v* S* [2 F4 o' r
6.   }

复制代码

+ d% p$ m3 A  k* n$ x$ ~& _3 M  A, J3串口查询函数

  HAL_UART_GetState();  判断UART的接收是否结束，或者发送数据是否忙碌

. E$ P8 `4 X9 X$ D  举例：     

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

复制代码

8 j! z+ `, G4 h/ bUSART接收与发送
, ^! @6 |" A4 w- A# b7 u重新定义printf函数
在 stm32f4xx_hal.c中包含#include <stdio.h>

1. #include "stm32f4xx_hal.h"
   
2. #include <stdio.h>
   
3. extern UART_HandleTypeDef huart1;   //声明串口

复制代码

在 stm32f4xx_hal.c 中重写fget和fput函数

1. /**
   9 c4 h9 T3 @3 [7 w4 E! @) ?
2.   * 函数功能: 重定向c库函数printf到DEBUG_USARTx
   7 t4 n9 W- D* t" o0 K+ P" N
3.   * 输入参数: 无
   - W! O8 J8 n- }4 p9 n, _
4.   * 返 回 值: 无
   
5.   * 说    明：无
   7 K, @; }: R% j; g
6.   */
   
7. int fputc(int ch, FILE *f)
   8 J2 V, U+ t3 C) W2 Y) s1 m
8. {
   
9.   HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
   9 W. B1 G8 P+ S2 z
10.   return ch;
    
11. }
    # N% O, t2 ?! W- u
12. 
    ( G6 W7 `3 q3 O( g5 {
13. /**
    
14.   * 函数功能: 重定向c库函数getchar,scanf到DEBUG_USARTx
    , v8 q$ Y6 ^- R
15.   * 输入参数: 无
    
16.   * 返 回 值: 无
    / e/ ~! B  S4 }1 o# B
17.   * 说    明：无
    
18.   */
    + S, M; G+ s2 w  S# A% H8 y
19. int fgetc(FILE *f)
    7 \: q9 c) n- U; H. m# }/ I
20. {
    ( g' [8 j/ Z, o0 O# r
21.   uint8_t ch = 0;
    % X# b/ [5 E  ^; t1 V( m; X& a
22.   HAL_UART_Receive(&huart1, &ch, 1, 0xffff);
    # G: {, ~& g4 Z; P4 E8 D8 ?6 b
23.   return ch;
    
24. }

复制代码

* y4 K; e3 L. R3 a在main.c中添加

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

复制代码

1. 
   
2.   while (1)
   
3.   {
   
4.     /* USER CODE END WHILE */
   
5.                         printf("Z小旋测试\n");
   
6.                         HAL_Delay(1000);
   . K! _; `( v2 N' v1 v* n: x
7.     /* USER CODE BEGIN 3 */
   - ~, a# }' U! W: j" `2 h- }, M
8.   }

复制代码

  T4 [4 [* r1 q, y- v7 Y之后便可以使用Printf函数和Scanf，getchar函数

. V# P$ P* m6 h) t; u  f
1 V; |5 m9 e9 B8 i5 M( s6 I  l. |
% B. S3 {* v" T9 [  F: N" OUART接收中断
5 U4 [# U7 F6 g$ U  t因为中断接收函数只能触发一次接收中断，所以我们需要在中断回调函数中再调用一次中断接收函数

4 ^% S- y, a$ J, N: ]具体流程：
" L/ V3 X" E; U1 K  r: L1、初始化串口
/ X9 n& m" w! a( i/ O8 d
2、在main中第一次调用接收中断函数

3、进入接收中断，接收完数据  进入中断回调函数
) `, ?/ G% V" J
4、修改HAL_UART_RxCpltCallback中断回调函数，处理接收的数据，
' x" b  |/ c5 Y& j5 Z7 ~+ U
5  回调函数中要调用一次HAL_UART_Receive_IT函数，使得程序可以重新触发接收中断

4 I- h2 b0 W2 p' y函数流程图：
# i9 f0 o8 ?9 Q/ `7 F
6 U4 p; `7 I; o0 W/ r& GHAL_UART_Receive_IT(中断接收函数)    ->  USART2_IRQHandler(void)(中断服务函数)    ->    HAL_UART_IRQHandler(UART_HandleTypeDef *huart)(中断处理函数)    ->   
$ Z$ M6 V( ?! V- rUART_Receive_IT(UART_HandleTypeDef *huart) (接收函数)   ->   
+ i5 J1 P; h% VHAL_UART_RxCpltCallback(huart);(中断回调函数)
) \# n; \7 G5 [& q1 p
HAL_UART_RxCpltCallback函数就是用户要重写在main.c里的回调函数。
) q7 l* e0 c7 W/ U4 \- V
代码实现：
' g- {; F' [* b. p
) ^$ g( W# d+ a( ~, A3 z* ]    并在main.c中添加下列定义：

1. #include <string.h>
   0 C  B7 C) m% Q% W8 }. H1 U; Q
2. 
   
3. #define RXBUFFERSIZE  256     //最大接收字节数
   ) r- r* K! e5 B) w  Z- i
4. char RxBuffer[RXBUFFERSIZE];   //接收数据
   # x6 Y. E: f9 U% @2 |3 a1 B
5. uint8_t aRxBuffer;                        //接收中断缓冲
   * o7 E$ k/ X. \( Z! L  v
6. uint8_t Uart1_Rx_Cnt = 0;                //接收缓冲计数

复制代码

0 |/ R/ b8 \: Y; c0 U# |( J在main()主函数中，调用一次接收中断函数

+ m+ e" x0 _8 F3 X5 p

1. /* USER CODE BEGIN 2 */
   
2.         HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);
   
3. /* USER CODE END 2 */

复制代码

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

1. /* USER CODE BEGIN 4 */
   " Y: Q/ T5 g5 h* s
2. 
     |  A; c4 g4 |* L
3. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   - T8 L  C/ L# P3 b7 [$ d7 H
4. {
   . h" `4 c  ?6 v+ S/ d
5.   /* Prevent unused argument(s) compilation warning */
   
6.   UNUSED(huart);
   2 g1 H( n2 o9 B! Z3 Z
7.   /* NOTE: This function Should not be modified, when the callback is needed,
   9 G! [* V- M! C% m5 @
8.            the HAL_UART_TxCpltCallback could be implemented in the user file
   
9.    */
   
10. 
    
11.         if(Uart1_Rx_Cnt >= 255)  //溢出判断
    7 W6 _$ \8 R! V4 \7 i5 I& O
12.         {
    * F, f8 ^, i) F' y, a
13.                 Uart1_Rx_Cnt = 0;
    ' G% e; R, O/ w1 h1 @: M
14.                 memset(RxBuffer,0x00,sizeof(RxBuffer));
    
15.                 HAL_UART_Transmit(&huart1, (uint8_t *)"数据溢出", 10,0xFFFF);         
    ) R- U* l8 A4 ?
16. 
    ) K2 N' H- _* w8 p# X/ \: x- f
17.         }
    - p  h0 @$ ^! G, y) z
18.         else
    
19.         {
    
20.                 RxBuffer[Uart1_Rx_Cnt++] = aRxBuffer;   //接收数据转存
    * P7 m) l- |7 N
21.         
    0 g% f8 V$ s  K6 z) w/ U: q
22.                 if((RxBuffer[Uart1_Rx_Cnt-1] == 0x0A)&&(RxBuffer[Uart1_Rx_Cnt-2] == 0x0D)) //判断结束位
    
23.                 {
    $ G% \+ k# [; i- i: w# H- `
24.                         HAL_UART_Transmit(&huart1, (uint8_t *)&RxBuffer, Uart1_Rx_Cnt,0xFFFF); //将收到的信息发送出去
    ) Q9 _' ?2 B0 |7 E, S9 e, f1 O
25.             while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
    
26.                         Uart1_Rx_Cnt = 0;
      v  t6 i+ Q, I. o9 ^- t
27.                         memset(RxBuffer,0x00,sizeof(RxBuffer)); //清空数组
    , L0 w$ W/ j% I2 o+ l1 r
28.                 }
    2 Y0 T  K. C3 v' ^" R
29.         }
    
30.         
    7 ~( g3 y' d5 J  s) [
31.         HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);   //再开启接收中断
    8 m, P# s* s8 o8 w
32. }
    5 i' p1 q* i3 r( Q+ B4 S
33. /* USER CODE END 4 */

复制代码

# \, M  ^$ y4 y7 n; z发送数据被正常返回


6 P( g. \, o8 S, x( o2 X


9 c4 ~7 b! a" c3 k9 }. ~% p# ]2 e4 D