前言：

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

* w  M- N) j; ~3 ^' I  b! u

所用工具：

1、芯片： STM32F407ZET6

2、STM32CubeMx软件

3、IDE： MDK-Keil软件

4、STM32F1xx/STM32F4xxHAL库

5、串口： 使用USART1 PA9,PA10

知识概括：

通过本篇博客您将学到：

STM32CubeMX创建串口例程

HAL库UATR函数库

重定义printf函数

HAL库，UART中断接收

HAL库UATR接收与发送例程

工程创建

1设置RCC

• 设置高速外部时钟HSE 选择外部时钟源
  9 X- \; S) l) `; a( h

2设置串口

• 1点击USATR1
• 2设置MODE为异步通信(Asynchronous)      
• 3基础参数：波特率为115200 Bits/s。传输数据长度为8 Bit。奇偶检验无，停止位1      接收和发送都使能
• 4GPIO引脚设置 USART1_RX/USART_TX
• 5 NVIC Settings 一栏使能接收中断
  

3设置时钟

我的是  外部晶振为8MHz

• 1选择外部时钟HSE 8MHz
• 2PLL锁相环倍频72倍
• 3系统时钟来源选择为PLL
• 4设置APB1分频器为 /2
  1 h: h3 _! n+ {( o

32的时钟树框图  如果不懂的话请看《【STM32】系统时钟RCC详解(超详细，超全面)》

4项目文件设置

• 1 设置项目名称
• 2 设置存储路径
• 3 选择所用IDE
  

5创建工程文件

然后点击GENERATE CODE  创建工程

配置下载工具

新建的工程所有配置都是默认的  我们需要自行选择下载模式，勾选上下载后复位运行

HAL库UART函数库介绍

  UART结构体定义

UART_HandleTypeDef huart1;
* d6 k( b' x. ?' Y/ O" |9 `. b/ P

UART的名称定义，这个结构体中存放了UART所有用到的功能，后面的别名就是我们所用的uart串口的别名，默认为huart1

可以自行修改

1、串口发送/接收函数

• HAL_UART_Transmit();串口发送数据，使用超时管理机制
• HAL_UART_Receive();串口接收数据，使用超时管理机制
• HAL_UART_Transmit_IT();串口中断模式发送
• HAL_UART_Receive_IT();串口中断模式接收
• HAL_UART_Transmit_DMA();串口DMA模式发送
• HAL_UART_Transmit_DMA();串口DMA模式接收
  ) }+ j) {, x9 K; `

这几个函数的参数基本都是一样的，我们挑两个讲解一下

串口发送数据：

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

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

参数：

• UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1
• *pData      需要发送的数据
• Size    发送的字节数
• Timeout   最大发送时间，发送数据超过该时间退出发送
  

举例： HAL_UART_Transmit(&huart1, (uint8_t *)ZZX, 3, 0xffff); //串口发送三个字节数据，最大传输时间0xffff
# C6 o: Q" G% c, Q2 x

中断接收数据：

HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
4 v/ ?6 e2 j# W/ R

功能：串口中断接收，以中断方式接收指定长度数据。
大致过程是，设置数据存放位置，接收数据长度，然后使能串口接收中断。接收到数据时，会触发串口中断。
再然后，串口中断函数处理，直到接收到指定长度数据，而后关闭中断，进入中断接收回调函数，不再触发接收中断。(只触发一次中断)

参数：

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

举例： HAL_UART_Receive_IT(&huart1,(uint8_t *)&value,1); //中断接收一个字符，存储到value中
/ p. j$ j% g0 x$ b, d; _" T5 U

2、串口中断函数

; t+ Q9 g: e& i) ~

• HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  //串口中断处理函数
• HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);  //串口发送中断回调函数
• HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);  //串口发送一半中断回调函数（用的较少）
• HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);  //串口接收中断回调函数
• HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);//串口接收一半回调函数（用的较少）
• HAL_UART_ErrorCallback();串口接收错误函数
  

串口接收中断回调函数：

HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);  

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

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

参数：

• UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1
  

举例： HAL_UART_RxCpltCallback(&huart1){ //用户设定的代码 }
3 P, J: ~( Y- Y/ P/ U; i! t* [

串口中断处理函数

HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  
) A5 e4 A6 E6 L/ j! J' d; X3 u+ b2 z% r

功能：对接收到的数据进行判断和处理  判断是发送中断还是接收中断，然后进行数据的发送和接收，在中断服务函数中使用

3 f% b3 R) t* c

如果接收数据，则会进行接收中断处理函数

• 
  ( Z/ R+ E4 W7 Z# v8 {) b) w
    L9 X) c( O( Y/* UART in mode Receiver ---------------------------------------------------*/
  
  
• 
  
  if((tmp_flag != RESET) && (tmp_it_source != RESET))
  
  & t- X1 [! Z: F4 n
• 
  , w1 Q. U6 M+ K' [2 R
  ; m( D, e5 h3 v{
  . I: E1 M% g7 u- y0 k6 o
  
• 
  
  ! r. ]8 I! {8 ZUART_Receive_IT(huart);
  
  0 c* c# c' d- ~
• 
  ) f- s; F) M3 O$ T0 h: X
  }
  
  
  : @4 Q, I' r* X

如果发送数据，则会进行发送中断处理函数

• 
  
  2 f& P; ^( ^. n/* UART in mode Transmitter ------------------------------------------------*/
  0 C6 c; x' E% E9 D* S5 {  }
  
• 
  : b: ?* o0 s- [
  4 y3 N) S0 `  o! wif (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  
  
• 
  - N" f& y1 u0 {0 M5 s
  {
  
  
• 
  
  UART_Transmit_IT(huart);
  / |0 Z) a' Q# Q: s9 i0 h
  6 e' J* L1 T5 U
• 
  
  return;
  ' Z7 q, {( G9 z9 q  c5 X5 c% v
  ! W) S4 l. i3 {2 p& `: B) L8 ~. @
• 
  : U4 ^' |, U$ Q% l7 X
  9 `0 @! b  _4 v( G! y% G}
  ) K& j& s7 [, h+ K. V9 G
  
    U8 I% q/ ~- S6 ]5 |

3串口查询函数

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

  举例：     

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

8 X2 }: m% T. q8 y2 i9 GUSART接收与发送
重新定义printf函数

• 在 stm32f4xx_hal.c中包含#include <stdio.h>
  

• 
  / j! ]' @8 |. E$ y0 T7 |
  #include"stm32f4xx_hal.h"
  9 p* ^6 d1 C- g2 P" q/ @
  - X  h. G' ?* b8 n9 P6 U2 V
• 
  
  #include<stdio.h>
  
  . t7 R+ K7 E' h8 S
• 
  : Z  ?  a. O  L
  extern UART_HandleTypeDef huart1; //声明串口
    J( k  p5 ?5 ^
  
  

• 在 stm32f4xx_hal.c 中重写fget和fput函数
• /**
  在main.c中添加
  

• 
  
  9 q! {4 |* z& A! y  P- ] #define RXBUFFERSIZE  256
  
  2 c) C$ e8 Z9 k' v, s  ?
• 
  / b: P* v1 [' _8 ]+ V4 m" q/ l
  ( H' M" S. P, p  B. P6 l4 g7 xchar RxBuffer[RXBUFFERSIZE];
  ! [% x9 L4 C  N5 N$ V, s  F
  2 e6 ]9 |7 l0 A. e
  

7 p6 I( Z% W  R: ?

• 
  0 I0 K  x/ t5 v% W; G5 d" L( V& }% P5 q! C
  . l4 z) N1 o" x8 x/ m  d1 Z8 s
    h9 G+ ^9 x0 K2 \5 o
  
• 
    U( m& U2 Y0 ^) c& s
    x: k9 R. l# jwhile (1)
  & ]8 a* ?( w9 O/ r7 Q, p/ O' k7 K
  1 Y4 X1 }+ p, ~0 y% s
• 
  : n4 D  G# g& \0 M: y* s
  {
  
  
• 
  ( C$ a: e' c  W+ r0 `0 p
  /* USER CODE END WHILE */
  
  
• 
  
  4 t. v- v  i1 G* Jprintf("Z小旋测试\n");
  3 d5 e# Z: j+ r+ X) F2 G
  
• 
  
  ; l; z/ ~" D( x8 [" a: EHAL_Delay(1000);
  
  
• 
    x2 E6 q3 Z1 t" T: `5 H
  # ^' m+ l( Y6 {7 ?9 o1 g" m/* USER CODE BEGIN 3 */
  
  0 V- ^% @; r. c7 K% a9 G
• 
  9 X+ v) F( o$ o3 i2 l0 t2 N% |
  }
  
  
  

之后便可以使用Printf函数和Scanf，getchar函数

UART接收中断

因为中断接收函数只能触发一次接收中断，所以我们需要在中断回调函数中再调用一次中断接收函数

具体流程：

1、初始化串口

2、在main中第一次调用接收中断函数

3、进入接收中断，接收完数据  进入中断回调函数

4、修改HAL_UART_RxCpltCallback中断回调函数，处理接收的数据，

5  回调函数中要调用一次HAL_UART_Receive_IT函数，使得程序可以重新触发接收中断

函数流程图：

HAL_UART_Receive_IT(中断接收函数)    ->  USART2_IRQHandler(void)(中断服务函数)    ->    HAL_UART_IRQHandler(UART_HandleTypeDef *huart)(中断处理函数)    ->    UART_Receive_IT(UART_HandleTypeDef *huart) (接收函数)   ->    HAL_UART_RxCpltCallback(huart);(中断回调函数)

HAL_UART_RxCpltCallback函数就是用户要重写在main.c里的回调函数。

代码实现：

    并在main.c中添加下列定义：

• 
  : ~9 }7 u$ `/ Y/ B; R6 _$ T/ I5 ?
  #include<string.h>
  
  
• 
  
  4 l( r" k: J1 i5 n
  5 N7 n. ~2 g1 o1 r. C
  
• 
  
  6 y6 Y  Q% r: \* B" W2 H) W#define RXBUFFERSIZE  256 //最大接收字节数
  " n0 V) Z1 D+ T; ?$ ~+ q
  4 s1 x  \. {6 Q: ?
• 
  
  char RxBuffer[RXBUFFERSIZE];  //接收数据
  
  
• 
  
  ; z/ p" I+ v2 _$ kuint8_t aRxBuffer;        //接收中断缓冲
  
  
• 
  + ]0 @2 k) g) s% L, h
  uint8_t Uart1_Rx_Cnt = 0;        //接收缓冲计数
  
  
  

6 P- u- n# y9 z- \) D( x

在main()主函数中，调用一次接收中断函数

• 
  
  /* USER CODE BEGIN 2 */
  7 t5 T" `- R+ @. P0 a+ g- a
  
• 
  
  4 A6 d3 q2 ?1 f4 WHAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);
  - o* V7 f+ p4 J8 M/ q4 ~
  0 y) f4 x  r/ L) G- }. V# f  s
• 
  
  /* USER CODE END 2 */
  
  
  

3 r6 @9 A5 D) D

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

• 
  
  3 [( {" Q8 I3 u$ E& \2 Y! G/* USER CODE BEGIN 4 */
  ; H9 `. W/ d8 ^$ O
  * ]/ z. \' X; @1 K$ i5 v. l
• 
  9 F) U& r8 t: j2 r9 _8 w
  1 \. c2 i% q; Y3 \- z: g
  : L1 h8 ]4 M1 n& W
  8 c$ e" w6 F! b8 V- C$ _
• 
  
  voidHAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  * ~% H  K. o" }/ O. Z' l
  
• 
  
  {
  
  
• 
  1 p- H9 L7 _6 P. A9 F5 T
  /* Prevent unused argument(s) compilation warning */
  4 e2 t# w9 f0 c; t5 ]
  
• 
  
  UNUSED(huart);
  + K7 K0 _1 C% o3 ?4 J3 [
  1 A" T8 p) U, B
• 
  ) c" M8 a% \  M9 ^0 o! K/ @
  /* NOTE: This function Should not be modified, when the callback is needed,
  ) B. g7 c% s0 H+ Z* |2 }
  , W3 d3 q! G( I; c; o4 V, X
• 
  " [$ w; g3 F" `! c. {* O
  ) ^! l  f$ d  j" O% ythe HAL_UART_TxCpltCallback could be implemented in the user file
  
  $ m$ Z% l# ?8 V5 r, R3 i4 B
• 
  ' }, e6 I0 Y0 K$ D$ E3 M& N2 o
  # t3 @( E4 s3 m7 L) S, f, f*/
  - Z: R' q2 O! Y  G5 k
  
• 
  $ r7 F# Y& Z8 Q. b; ^5 @  d
  4 k3 @- I3 c+ j
  5 q2 e0 r. x# {1 F) H
  
• 
  7 V+ }* I+ {2 A/ z3 v4 L
  if(Uart1_Rx_Cnt >= 255) //溢出判断
  
  $ T8 o& Y! m# p, ?4 Y* ~
• 
  
  & }3 z0 o/ {4 k/ R- T$ l1 m{
  5 o, v( k/ P+ e
  , Q5 v  ~* S* W/ l7 x
• 
  / t6 x& x' K# [! i
  Uart1_Rx_Cnt = 0;
  
  - j) y. m# p' ?! |9 N* F
• 
  
  memset(RxBuffer,0x00,sizeof(RxBuffer));
  3 ]  F0 H+ W' @0 N% R2 D
  : o7 P; a2 D  ^* q8 w
• 
  
  * l7 X, D! U) r' }HAL_UART_Transmit(&huart1, (uint8_t *)"数据溢出", 10,0xFFFF);
  ' d' O3 r7 Q- D7 f
  $ X9 J. N' Z/ R" |+ I  f
• 
    V+ Y8 `, {+ y+ [1 K* ?. d
  5 Z. m7 u# x5 C- S( Q5 w
  
  
• 
  
  }
  + G2 G/ f! ]+ c
  - `( w6 U& k. X1 P% s- @
• 
  
  , o3 i+ u- a0 _# e0 p( `2 }- Celse
  7 V. q7 E/ f' Q7 M
  ; l3 R3 j6 m& ]/ I5 F# I0 J) X2 E
• 
  $ t/ p+ T: R2 ?; v1 O4 l
  {
    e! [( r8 d* z1 |( D/ d( o: P
  
• 
  : F! i. O; H" c  r, Y0 ]! P
  9 J9 W/ L% O9 g+ N" PRxBuffer[Uart1_Rx_Cnt++] = aRxBuffer; //接收数据转存
  
  9 a8 u5 q/ m4 I8 M9 ?$ Z
• 
  2 z5 \- `# [, ^  L+ H4 W% i& P$ W
  7 P+ I3 d/ J9 `- b7 ]
  
  ' o0 \0 M# c9 U, Z2 c
• 
  8 U/ G3 D5 N" @+ n& c& R$ |  g7 y
  9 \& X0 D" r8 }1 L& o8 [/ Nif((RxBuffer[Uart1_Rx_Cnt-1] == 0x0A)&&(RxBuffer[Uart1_Rx_Cnt-2] == 0x0D)) //判断结束位
  
  : Q, v% V: I" O# |; {
• 
  " @- M# x8 ~7 ]! l: o+ B% h  s. j6 y! {
  {
  2 U/ k2 s! i6 {' H+ V
  
• 
  , B+ M  w, Z$ S' K  e+ @# u
  HAL_UART_Transmit(&huart1, (uint8_t *)&RxBuffer, Uart1_Rx_Cnt,0xFFFF); //将收到的信息发送出去
  
  8 y( m  P% {) N
• 
  1 K. y. L- r+ N5 J+ @1 F, P6 t
  while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
  
  + y+ C! n! G$ _7 `! D: G" b
• 
  & ]( E5 }0 j9 ?* m8 j
  $ @" l0 ~5 v% y! g2 AUart1_Rx_Cnt = 0;
  
  
• 
  
  7 G- f" w2 E' Q. z5 b( {memset(RxBuffer,0x00,sizeof(RxBuffer)); //清空数组
  
  
• 
  
  }
  ' H+ ?1 O! G' L2 ~4 @% V4 z" g- U" n
  
• 
  
  }
  
  4 N5 o* L! z% ^& P  {" H' a! i* ^4 Z" L
• 
  8 J2 L* _# h9 M* v0 \- P
  $ Q' m( C* Z" h
  
  
• 
  
  HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1); //再开启接收中断
  0 g6 I7 c9 Z# [/ c
  
• 
  
  / Q# _4 Y. q6 z. H' ]5 F% u# @}
  
  / g/ {8 q$ m' b. s1 X# D
• 
  
  / X  J% ]% e9 I9 Y4 @2 i' Q- {/* USER CODE END 4 */
  
  
  9 ~% X- h- c% g

发送数据被正常返回