前言：

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

所用工具：

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 选择外部时钟源
  4 v% X& f; }6 ^% M& P( E4 m/ Q- h' f

2设置串口

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

3设置时钟

我的是  外部晶振为8MHz

• 1选择外部时钟HSE 8MHz
• 2PLL锁相环倍频72倍
• 3系统时钟来源选择为PLL
• 4设置APB1分频器为 /2
  

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

4项目文件设置

• 1 设置项目名称
• 2 设置存储路径
• 3 选择所用IDE
  1 l0 l/ e7 I* N- O; e0 G

5创建工程文件

然后点击GENERATE CODE  创建工程

配置下载工具

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

HAL库UART函数库介绍
4 x# U1 N5 U( z& g  o" ]- U

  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
9 q0 c2 r1 `/ f4 z1 U. Q

中断接收数据：

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

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

参数：

• UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1
• *pData      接收到的数据存放地址
• Size    接收的字节数
  * k. W# |: ^, b- B# d+ X) K

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

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);  

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

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

参数：

• UART_HandleTypeDef *huart      UATR的别名    如 :   UART_HandleTypeDef huart1;   别名就是huart1
  $ |+ k: m  X" {4 p' j

举例： HAL_UART_RxCpltCallback(&huart1){ //用户设定的代码 }
+ z1 R- z- o- N7 o2 ]: Z

串口中断处理函数

HAL_UART_IRQHandler(UART_HandleTypeDef *huart);  

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

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

• 
  
  9 U# ?: A  E( m% j/* UART in mode Receiver ---------------------------------------------------*/
  * s6 g0 z8 T& Q, ?
  - m: H0 P' p3 Z
• 
  - M; [0 Z' r# E" b
  if((tmp_flag != RESET) && (tmp_it_source != RESET))
  
  ( s1 [  B) n: D9 n1 b3 v
• 
  5 D/ C6 e1 y5 q; W  `7 ]3 G( t' V
  {
  9 [0 r4 O) @, H+ z9 i# y$ y8 I
  
• 
  & L' Z: _7 D9 r: M: {6 ^: p
  UART_Receive_IT(huart);
  
  4 E# @3 a; f7 _8 f
• 
  & Q* C) q# W: u
  # }' }( A. ]! T) U}
  - q/ |% c5 u0 w$ n, z3 b. w
  
  ' i' m0 o8 z7 Q4 y7 b+ e

3 n+ t7 v5 L0 ?: G& m

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

• 
  
  4 o  D$ J' `) j, E2 E/* UART in mode Transmitter ------------------------------------------------*/
  " m: F5 K4 E6 ]% p
  
• 
  
  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  5 ~: P5 _0 ~( a5 {! u
  
• 
  ' ?7 S7 u! m0 h
  {
  
  
• 
  ; ~4 t/ z$ c) e$ O3 I% w6 ^1 w- k
  UART_Transmit_IT(huart);
  
  : ~, N4 L. w2 l
• 
  
  return;
  
  " Y, h& j4 M) p
• 
  
  }
  
  
  

3串口查询函数

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

  举例：     

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

USART接收与发送
9 u3 }) s" i( C重新定义printf函数

• 在 stm32f4xx_hal.c中包含#include <stdio.h>
    O4 y# y/ }, e0 R- A7 Z

• 
  
  #include"stm32f4xx_hal.h"
  
  
• 
  
  $ ?6 p" f' T. Z4 }' E$ z#include<stdio.h>
  ; s0 R3 i5 m9 r3 v* q6 y) l8 @
  ; y8 d2 W5 ?  C% p
• 
  
  1 U6 L( b; @! w2 n5 o" c7 y8 Wextern UART_HandleTypeDef huart1; //声明串口
  
  4 L4 H( B% r4 u) e5 o
  

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

• 
  
  #define RXBUFFERSIZE  256
  / J2 g: l! c7 q+ V" V5 y9 b
  : @8 q9 P8 R, R+ \  z# y3 N. p
• 
  ; w3 k8 {% D+ c3 U9 D9 V8 j
  char RxBuffer[RXBUFFERSIZE];
  / r* u/ H2 F5 u+ w
  ' C3 _3 q, X# |5 T
  

• 
  
  
  # ]% b' ]) B. j  q- [; C6 \
  
• 
  * Q: b  c7 q- C' Y9 R# p. j
  while (1)
  
  * g, X9 K* x, a3 z+ d7 N5 R# V
• 
  
  {
  
  9 k& P( @) `/ {/ Y+ k& Y
• 
  4 k' s  C& U* J  J% A
  /* USER CODE END WHILE */
    R1 Z. f8 Q2 m% O: ]$ e& x6 Z
  * A6 g6 H+ m9 w6 j
• 
  
  printf("Z小旋测试\n");
  $ x3 a5 t, c  p; C( S
  3 c. S; H& b% @  s2 g. G! Q: Y
• 
  : J! R' x/ s4 i
  HAL_Delay(1000);
  & G2 `, T' M1 y0 |
  0 R8 b; p3 {% t1 G- B: |7 ?6 y
• 
  ! @( T  D0 D0 `
  ; @' D" [0 l: D8 Z/* USER CODE BEGIN 3 */
  
  $ y: q+ V7 d9 y7 T/ Y3 T- d
• 
  9 w8 ]1 `8 g% Y- `) g! j" z
  ! L4 H) }& N, C. u; O, k}
  . a: V, B1 _# s, u# ~) h4 t
    q, k+ i4 Z. x+ A
  

" E$ F1 e& q  E1 H" s0 i5 I- R

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

• 
  
  #include<string.h>
  
  
• 
  % W  R! p9 ?( u& y3 [% j
  
  
  
• 
  
  #define RXBUFFERSIZE  256 //最大接收字节数
  + n6 I5 |0 B- Y
  # F" G% `& r0 l% r/ r
• 
  
  / T- d" x- r/ C6 V4 s+ q' t3 pchar RxBuffer[RXBUFFERSIZE];  //接收数据
  , y/ G& @2 T2 ?
  
• 
  ) Y; c, J0 i: J* Q  t
  uint8_t aRxBuffer;        //接收中断缓冲
  
  8 J" |- V0 x  y
• 
  
  / K& t* f9 x( ~% r, A# ^uint8_t Uart1_Rx_Cnt = 0;        //接收缓冲计数
  & |. T6 Q( M, `5 p9 c8 l0 a
  ! L/ l$ H( e: F" B4 v: Q
  # N$ w( M7 b$ M$ S

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

• 
  
  2 C3 r! u2 B4 O: z/* USER CODE BEGIN 2 */
  " \3 N, R+ r; l# E0 S+ X% @
  
• 
  , s  E$ g" ]5 ]! g* D
  ! u% R4 {; `, N" P8 |HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1);
  
  5 n. i$ _. }% o. H3 v( C
• 
  
  3 `8 I$ j- o0 ]" U  r( u/* USER CODE END 2 */
  ; ]  l4 X- l0 ?
  
  ( X  L* P1 k0 W+ K4 m9 F

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

• 
  
  . {' Y; k% C6 m& d9 D8 D/* USER CODE BEGIN 4 */
  
  
• 
  
  & Q+ E# Z* u2 q: u
  
  . m" |' h0 @% s. `( q7 Z* ^
• 
  
  , U: N# p) j( v; W% xvoidHAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  
  5 t+ E' x9 p* F( M- n8 Z0 w
• 
  
  {
  * ^% V' i/ M, ~% Y0 q7 |5 O  y
  
• 
  # j/ O' L7 _! K2 ]7 m
  ( `; p% e, ]5 x5 n/* Prevent unused argument(s) compilation warning */
  
  ; q1 I* H8 n8 C" W1 p( K& S
• 
  
  . ~: i7 H$ G" d9 h9 ~1 fUNUSED(huart);
  
  ; B1 M* v1 u9 z) k8 A. X
• 
  % y) |# V5 y8 y4 c& g# I# p$ W) b1 V
  /* NOTE: This function Should not be modified, when the callback is needed,
  : V5 o% M& x5 o/ F7 j7 h
  
• 
    b' P/ A9 X4 y, Q
  8 T6 R# m( v9 v, Y4 e" Ythe HAL_UART_TxCpltCallback could be implemented in the user file
  
  
• 
  
  . o+ t9 a8 a  |1 E, X*/
  / k% ?# h6 l! Y, }( p6 a' i
  7 \% J; Q6 ]; s/ N  N1 C
• 
  
  
  # x* u* N- r$ e5 W* W% Z
  1 N# r- ^6 w2 V+ @1 n
• 
  9 ]! a3 _1 h" L6 ]
  if(Uart1_Rx_Cnt >= 255) //溢出判断
  + b% w2 W. \) _/ S" i
  
• 
  % _( r0 i1 W# W2 \4 b% P( j/ c
  {
  
  
• 
  ) Y% f& u4 g0 n6 v: @- q3 D4 ~9 X
  Uart1_Rx_Cnt = 0;
  
  
• 
  
  memset(RxBuffer,0x00,sizeof(RxBuffer));
  ( w8 f6 O: s% K* u" t% u+ P
  
• 
  / R) x3 q7 a. u6 H0 Z" n
  HAL_UART_Transmit(&huart1, (uint8_t *)"数据溢出", 10,0xFFFF);
  
  : i' c8 Z6 s, j7 x, ]! D
• 
  
  
  # ]! {- n4 ~4 s" Q5 s4 e  q" |: q" g% p6 X
  
• 
  + s4 M# f: X$ E0 w- O
  ( c0 e4 d- d% k! k; }+ O# z}
  
  . t# g; b/ s; t$ B- J
• 
  ! R* c) x3 z7 [, X
  else
  
  " v4 `9 l% l/ j
• 
  * x' Q% B7 w; @0 i2 V9 p
  ' h8 p+ o  W# w$ u7 A" w{
  
  , L/ w+ q7 n. F9 ]1 d
• 
  
  : p: W  E% c3 @RxBuffer[Uart1_Rx_Cnt++] = aRxBuffer; //接收数据转存
  
  : b( p; r, [4 ?5 j2 T  @; e
• 
  # n3 `% p5 c% R  n
  7 ^! s. z- P2 ?: b: X& p1 d. n
  
  $ k: f( G  X0 h# T3 z  R2 R6 ]
• 
  # Y& e2 y$ k! I6 R* B0 W$ T2 z
  if((RxBuffer[Uart1_Rx_Cnt-1] == 0x0A)&&(RxBuffer[Uart1_Rx_Cnt-2] == 0x0D)) //判断结束位
  1 [3 N& j8 I/ Q
  
• 
  
  {
  
  
• 
  
  0 d: _+ z" K( G+ ~7 J. dHAL_UART_Transmit(&huart1, (uint8_t *)&RxBuffer, Uart1_Rx_Cnt,0xFFFF); //将收到的信息发送出去
  
  # l/ ^- @, Z1 {, I1 p. c
• 
  
  , N! j/ G: X% n8 S4 B( _while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
    ]+ Z2 ?" e; n; y
  
• 
  0 n$ X' c; ^) A2 h* K# D
  ' R* a6 g: \  C& k& `  M, KUart1_Rx_Cnt = 0;
  - X$ G7 F" E3 p5 W9 M2 S' y
  
• 
  
  + t$ r. h8 ]; A: v% c5 Nmemset(RxBuffer,0x00,sizeof(RxBuffer)); //清空数组
    z0 j3 C* b" x' m1 T6 }- ]7 C. i
    f8 `' X# B* v$ G) Z7 B
• 
  # w' ~2 h! q; K7 G4 v8 s0 f- q! v
  }
  5 Q9 V2 |# y! q2 O! j7 ]: }# Z
  
• 
  & J9 q5 \( C5 \3 o: M" g
  }
  
  
• 
  
  
  
  
• 
  / S3 C% ]+ g: j5 X$ g7 p
  HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer, 1); //再开启接收中断
  & G" B- R0 b/ _  m# B
  4 G6 \) V4 x% E* f1 E! D8 X7 g# x
• 
  ( O9 q: Z5 \1 V- `' i, ?
  }
  0 ~) j1 Z: P, n/ q
  ; k% R* A7 \* T% d6 x
• 
  
  /* USER CODE END 4 */
  9 @) S, Z9 {+ K! G% |" i
  
  

发送数据被正常返回

$ B5 V  A0 a% N7 j& b7 j* L
8 R% v  X! D5 M