前言：

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

) b( v1 d: T' c2 ~8 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 选择外部时钟源
  2 @8 u1 X0 h: j+ t( U8 k: S

2设置串口

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

3设置时钟

我的是  外部晶振为8MHz

• 1选择外部时钟HSE 8MHz
• 2PLL锁相环倍频72倍
• 3系统时钟来源选择为PLL
• 4设置APB1分频器为 /2
  * r! C- F% f9 z1 _0 N& H8 ?

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

4项目文件设置

• 1 设置项目名称
• 2 设置存储路径
• 3 选择所用IDE
  . D5 ^+ L( o  ?5 }9 \1 w+ K0 c* t: V$ z

5创建工程文件

然后点击GENERATE CODE  创建工程

配置下载工具

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

HAL库UART函数库介绍

  UART结构体定义

UART_HandleTypeDef huart1;

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模式接收
  

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

串口发送数据：

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
) d5 w' W5 x! V' P

中断接收数据：

HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
, G; X* C) F) @

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

参数：

• UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1
• *pData      接收到的数据存放地址
• Size    接收的字节数
  $ s5 }! P9 I0 [4 n: C+ Z2 |( o  ]

举例： HAL_UART_Receive_IT(&huart1,(uint8_t *)&value,1); //中断接收一个字符，存储到value中
# k8 _/ {: r, B+ [

2、串口中断函数

• 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);  
$ w4 [' N+ p; y7 |* s; S

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

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

参数：

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

举例： HAL_UART_RxCpltCallback(&huart1){ //用户设定的代码 }
8 _  S4 O0 a  t' G7 j1 N$ \

串口中断处理函数

HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  
& q8 X2 @, j& T7 B% V& {0 t- c

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

' C/ o) ^; b$ V! a+ x4 T2 L

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

• 
  
  /* UART in mode Receiver ---------------------------------------------------*/
  
  ' Y* Y( n' s; E+ F. u) W
• 
  & h5 U5 l/ H8 q1 N  b
  if((tmp_flag != RESET) && (tmp_it_source != RESET))
  
  ! b) T* o% D; E5 c2 N
• 
  
  {
  
  + T/ j. K! }5 W- G/ L+ p( s
• 
  & p9 j  Y3 w* J+ L" z' o; I3 e" e# k
  UART_Receive_IT(huart);
  1 s. q' U8 `9 W* y5 S
  
• 
    `3 b. D2 v8 Y$ s5 V. ?% S
  ) c& |" v* s7 J! b}
    g. d5 Y# e2 j3 R  D
  9 y6 ~- z" E/ @: `( p$ _1 }
  

4 ^! `' g% g% o+ ^# e( z

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

• 
  
  /* UART in mode Transmitter ------------------------------------------------*/
  
  
• 
  
  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  9 e, }2 w! z" m* Q. d! z
  9 J" j6 u7 z" S6 k  H
• 
  
  & k7 P# ]& \- E$ b! z/ E{
  % C! K2 ~. z% k
  
• 
  0 D) J) }8 U# a% H; V$ p  h
  UART_Transmit_IT(huart);
  
  
• 
  
  2 }+ g, N3 s8 @$ T0 qreturn;
  
  
• 
  
  }
  
  
  ( [: `" O& X2 ]; X6 G

( G/ p8 n9 p2 s+ s: @/ L# ~! v, e

3串口查询函数

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

  举例：     

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

. j  G) V2 w. w% q# C( BUSART接收与发送
重新定义printf函数

• 在 stm32f4xx_hal.c中包含#include <stdio.h>
  1 M6 o# n/ n! N+ t$ N

• 
  " S5 n0 t6 V; q+ T4 E
  ; |6 M! Y7 M/ ^+ P9 l3 u#include"stm32f4xx_hal.h"
  2 Q% a. |) D- Y! ]6 K
  
• 
  
  % d0 |5 z, F# F#include<stdio.h>
  
  . Q3 _- V6 e/ e2 U2 r
• 
  $ M# |+ N% D) ~! u
  extern UART_HandleTypeDef huart1; //声明串口
  . V8 I' k0 k; \' z
  # Q' s3 h& \/ T- r. U
  # U9 W" j( G. I5 U& B, k- _; k2 y

/ w" v% S+ y3 j. p# e& L' v

• 在 stm32f4xx_hal.c 中重写fget和fput函数
• /**
  在main.c中添加
  8 k) I) x3 i- f8 Y% |& n% j

• 
  8 P- W( J+ P( f1 t) t4 I
  #define RXBUFFERSIZE  256
  0 v& z: y( ^% f( A6 B" `
  
• 
  3 E- g! l% |6 C' s4 N6 X0 D
  " U) K& I. C  a$ e) Schar RxBuffer[RXBUFFERSIZE];
  ( e- R' s7 G+ a& S# {
  ) n0 e* [! g  [" b4 H# u* |
  " i+ k) m+ ^$ `

' ^3 s, V9 W! F

• 
  
  
  
  
• 
  9 a. O- n! z0 e, ]( X+ ?, |) ?
  8 U% Q4 @+ `& lwhile (1)
  9 B9 x1 p/ A6 W# t% A
  
• 
  
  {
  
  7 K# E. ?$ p/ i# p
• 
  
  3 N+ A/ W( r4 g' c; [/* USER CODE END WHILE */
  
  5 g( w- F# W4 E/ F* S$ {4 E  ^$ W
• 
  + P: Z7 Z* T% i, |
  ' Z9 f" W# v' d6 W: k6 |! ]printf("Z小旋测试\n");
  / v! M* t# z/ C  B. C' {( ~7 Z  e9 V
  ' u& g& C' Z4 ^- Z5 D
• 
  & [; A2 i, a) r) [% p5 }
  7 q; \) s7 c. }, i( O" zHAL_Delay(1000);
  5 g3 \4 D1 ~' P0 n3 o
  ; j2 [! G0 j' z. }9 s( `% n
• 
  ' E% t3 s" Z/ B7 l0 Y
    ^- K' y/ ]7 x3 i/* USER CODE BEGIN 3 */
  
  
• 
  
  $ j0 [. y; Z- t4 U7 C2 _}
  
  
  2 h6 H& n# u5 G8 s* J: \* Q2 ^0 j

之后便可以使用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中添加下列定义：

• 
  
  + O4 f+ I4 {; z#include<string.h>
  / E6 s$ L2 _. m
  . P7 J! a7 h. s) l/ Q
• 
  $ A( P, h/ C( \/ w: ]' f& L" F, \
  $ U# E% W2 y7 s
  4 O: r% s% g4 ~
  % u# j: G) v& ~) y0 A( r) Y! o
• 
  
  #define RXBUFFERSIZE  256 //最大接收字节数
  . E+ ~' _8 |+ F- ~3 ~
  
• 
  
  char RxBuffer[RXBUFFERSIZE];  //接收数据
  
  
• 
  
  uint8_t aRxBuffer;        //接收中断缓冲
  
  
• 
  " ^# i# P- I6 v9 k5 w9 B% ]
  uint8_t Uart1_Rx_Cnt = 0;        //接收缓冲计数
  # X8 F0 W* B& U0 S0 `6 [9 Z- W
  0 ~+ d; ~5 \5 _
  

0 E4 ~1 E2 n- e, H7 ~& m5 `0 e

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

• 
  
  /* USER CODE BEGIN 2 */
  
  $ W) c( ]4 A' T/ K7 N  Q2 L
• 
  
  HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);
  
  
• 
  4 o. f* I& D7 C+ b
  + X7 |' t# n6 M/ ]/* USER CODE END 2 */
  
  
  6 u# j; j; n* N2 a# B1 w# ?

* v4 _; k5 c+ \  _* V% S; z

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

• 
  2 X% _' Z0 x9 S8 o# L# u0 c
  ' e2 w1 l( E4 |/* USER CODE BEGIN 4 */
  : l7 P) _' d! z! \& A
    t; K9 r3 [/ Z: X& m  T6 x1 v
• 
  : B: S, S& p( P' [* `
  ! e; M% u! [1 J2 l# N
  
  # v3 J" F+ h' [& H! E; V
• 
  6 P0 E( Z2 p5 d& y6 p9 @
  voidHAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  
  
• 
  ; p8 d) u4 y4 ]+ k2 p6 x
  {
  # q8 L  M6 n  L' q) b
  
• 
  
  /* Prevent unused argument(s) compilation warning */
  
  - p  d$ G4 I3 B% b  I0 u
• 
  
  UNUSED(huart);
  2 A: ]6 \# g4 q' M# i. X
  1 b( ?% _) V6 ^
• 
  , \/ z. G; b% Y2 _
  /* NOTE: This function Should not be modified, when the callback is needed,
  
  
• 
  
  the HAL_UART_TxCpltCallback could be implemented in the user file
  
  0 [+ a4 t5 d3 t7 g3 C
• 
  , ^- s9 y+ ~4 x9 w* b  }! }
  - M5 P0 q" X4 i2 ]; X*/
  
  
• 
  0 g/ ?9 n& R( u8 n, {
  : u" ~. ~& @) V1 L( y  X  I; n3 ?
  ) X2 @' U& P( ~+ _- A) ~
  
• 
  
    _2 y5 A3 o. m/ q" l. `if(Uart1_Rx_Cnt >= 255) //溢出判断
  
  / ?) o8 _6 r) V# ]7 N4 C
• 
  
  " ^6 E. A! h- ]+ v" @{
  
  
• 
  # d3 a) X1 x+ Z
  Uart1_Rx_Cnt = 0;
  
  
• 
  5 Y+ T3 P0 j6 `- c1 V
  memset(RxBuffer,0x00,sizeof(RxBuffer));
  
  $ d- A0 ]- J$ }& _: E# N0 [$ z
• 
  
  HAL_UART_Transmit(&huart1, (uint8_t *)"数据溢出", 10,0xFFFF);
  5 _5 X9 x7 K* o0 u
  
• 
  3 l8 V. Y; \  }. ?+ x+ I
  2 S* f4 [0 i  _- r, `
  # N  H0 D- D6 ], \
  5 F- z9 {+ O5 L" h
• 
  
  ) Q& c" T& |% |}
  * @1 L0 ?* F0 G5 g) B9 G
  
• 
  " z' g& ^6 ~' u5 q! Q/ E9 \% g9 h
  - h# [, o. _7 h2 A' ~: belse
  
  
• 
  0 d7 M& X: k7 d6 f5 ~  ]: L. j7 E
  {
  5 j9 {5 e0 v) i. l
  4 }( d2 U0 P; n4 I9 h; [
• 
  ! `9 z4 X- D, p
  RxBuffer[Uart1_Rx_Cnt++] = aRxBuffer; //接收数据转存
  
  
• 
  
  % Z2 O% J: q0 ?. i9 i
  / j. ?) e4 h  [) a- Y3 u( v$ [
  ; I8 D3 k" ~" Y3 x' e6 u
• 
  
  : q6 V/ \, R; M  _if((RxBuffer[Uart1_Rx_Cnt-1] == 0x0A)&&(RxBuffer[Uart1_Rx_Cnt-2] == 0x0D)) //判断结束位
  
  0 E4 T8 q6 G# O+ M( U6 i- l/ j& o: p
• 
  ' F; [, a, X! K' ?& O
  {
  
  $ t4 c& s5 R0 k5 f! R
• 
  
  4 D( |" F. z- |8 OHAL_UART_Transmit(&huart1, (uint8_t *)&RxBuffer, Uart1_Rx_Cnt,0xFFFF); //将收到的信息发送出去
  
  
• 
  8 T1 n/ W- c. \5 E1 x2 S
  ! h. ~/ |" @' @( Pwhile(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
    P& w$ S- i+ l5 D, \% T! J
  
• 
  
  Uart1_Rx_Cnt = 0;
  
  3 [# F* N$ ]6 U: r+ f) i
• 
  
  * T$ n+ H/ a! U; }memset(RxBuffer,0x00,sizeof(RxBuffer)); //清空数组
  
  . d; X0 T( R# i2 V' \$ `7 q5 Q
• 
  : q0 R* l; t7 |& [
  9 N9 S& I. A2 \" z9 d}
  / P. q- [" V" M( j! A
  ) V1 v. r) o) N
• 
  ' f5 ]& A  P* P) Z4 [5 O3 f
  ) N2 ^4 l' ]7 n+ ]% ?}
  ( A3 X' f) K* W( ~# L1 {
  
• 
  
  
  " L2 R6 I; r$ X0 T/ R+ Y
  
• 
  ! q- N- V/ a, w. O- W* U
  HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1); //再开启接收中断
  9 |, q5 `) V- c4 e5 k: {
  
• 
  
  }
  
  6 i0 z* E0 |1 s5 W* r2 R
• 
  : C' m( k: `; J: M& \" s$ L
  /* USER CODE END 4 */
  
  " R+ x$ X/ L4 v: r/ A* `: K% e
  

* a7 P! {2 }- V+ `: Z. w1 q7 \

发送数据被正常返回

- @$ J5 j. m. H1 j: e: }$ K4 x