30.1 初学者重要提示
学习本章节前，务必优先学习第29章。
% |% |/ X0 w( J$ `) r串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
4 t: s7 c1 n4 R9 A$ Q: U$ F! ~本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
0 ^! U. Q* R6 T3 U大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
CH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
6 x. Y' N- C9 C) j30.2 硬件设计
STM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

串口USART1  TX = PA9，   RX = PA10

4 _0 F% v  H; s" m5 ^, Z串口USART2  TX = PA2，   RX = PA3
6 S" _/ b1 R9 a4 a7 @
/ L- s% F$ x3 l! j* }0 ~4 |串口USART3  TX = PB10，  RX = PB11
) K" N& T- r1 G
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

) ]  i9 @$ ]) H$ x) S. S5 J9 s串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
& P3 _: D) u, k  s
9 T  H6 K5 t4 y: W' z- D5 |串口USART6  TX = PG14，  RX = PC7
1 Y/ d* W2 M% d2 R$ _
串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

1 J7 v" J8 v8 h% e/ ]. w  M$ d串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

  {4 v5 o0 t" PSTM32-V7开发板使用了4个串口设备。

3 P9 y" ]! c7 L% d& n& B串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
5 a) Q: e0 a. Q3 _, p串口2用于GPS
串口3用于RS485接口
  c( w; M. N$ ]3 C- A2 G# K串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
) I* `/ D5 g4 t- B3 F  @下面是RS232的原理图：
* J/ k- g: W  ?# V5 B
) g, K0 z3 a- j. j5 e% K2 N

' \9 ?6 B2 ~- y* V0 l! M, o8 h
: S( @+ q1 g7 @, c& k; }; _9 y% t关于232的PHY芯片SP3232E要注意以下几个问题：

: p* @6 W* n$ p5 C& O; r4 Y. |SP3232E的作用是TTL电平转RS232电平。
4 t( C  x7 t& D/ }* y" q# P电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
! G) J- b" r4 T7 p6 V# M1 M检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
# H* N1 }& F) T: Y
! r3 E! M4 U! U' g

6 K( a0 Y1 V  M$ g
实际效果如下：
! `- z' s2 ~+ H
( r7 k1 U0 V4 s4 R

通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
% {' s) q  e: n9 J0 v5 y/ u
1 U4 b7 _7 P; c4 ]由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
" A6 b+ a% g8 \+ k6 q1 H' G6 Q检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
+ R, J8 H, a3 m% @- U9 U
30.3 串口FIFO驱动设计
30.3.1 串口FIFO框架
7 e( s8 V3 p7 \, [& J9 A+ O为了方便大家理解，先来看下串口FIFO的实现框图：
7 {/ V* Z9 ^. J: I4 E3 @/ \' v

  Q9 Q4 P+ g2 }: o" V% O
第1阶段，初始化：
& }- O. T# U, u8 {, M6 e; L
! X* [( B. D0 |, C+ ^6 [通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
8 y; Z9 m& A1 s* a' Z, z* R- r第2阶段，串口中断服务程序：
8 C' f4 S2 s8 x- e8 I  ], H
接收中断是一直开启的。
做了发送空中断和发送完成中断的消息处理。
2 j% J9 I! @% M2 ^9 A/ x第3阶段，串口数据的收发：

串口发送函数会开启发送空中断。
串口接收中断接收到函数后，可以使用函数comGetChar获取数据。

30.3.2 串口FIFO之相关的变量定义
2 q4 S1 J$ {# ]: w1 i: }  U串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

0 {8 z' @% b5 e这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。

; N/ {* u7 Y- b! H2 _* `3 e3 g每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
, d6 Z, ]5 U9 T( v* y3 K3 X6 k. b( p
  r  y3 Z; U! ]7 ]. y$ B我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。
* _( d! x  R0 U$ e

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   # \+ M6 r2 m- g2 ]* w
2. #if UART1_FIFO_EN == 1
   0 n2 E) k* G) j5 s2 S$ D2 g; d
3. #define UART1_BAUD                        115200
   
4. #define UART1_TX_BUF_SIZE        1*1024
   9 Z$ K+ `- W% V/ |% \3 y
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   $ V) i& L. [, l0 k% r: p
9. typedef struct
   . T: m- @2 l* ]/ z! \% m
10. {
    
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    : I) n- W- f" \$ }
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    4 g0 q% Z' x. d, K( B
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    0 ^+ j3 p3 T6 Q
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    4 t/ H. d- ^2 X( E
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    2 g% D" F  H1 B5 `0 p
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    , ~4 y5 r2 I8 M( I; ]" Z
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    
23. 
    ' l3 F) U+ {8 g* ?
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    ( |; q5 y# h. R
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    - B0 r# |* f! j% T! p5 S# ]6 `- a
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    % E% f5 A3 N$ g, }8 h
28. }UART_T;

复制代码

bsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。
! j  O1 {. y5 _0 P
+ C* n  C# a% O, f

1. /* 定义每个串口结构体变量 */
   : @  @5 @* R$ }" `) E8 a* f
2. #if UART1_FIFO_EN == 1
   - ^9 K0 l+ _( p8 a% s6 ?+ c+ i1 Q
3. static UART_T g_tUart1;
   
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   $ {4 ^" U2 i; g) Q2 J0 D
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   ; q9 J# h9 D% S
6. #endif

复制代码

关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

30.3.3 串口FIFO初始化
* ~! j* ^8 |. m' c0 y串口的初始化代码如下；

1. /*
   
2. 
   " F5 ]2 a3 r7 m3 P* y4 O
3. ---
   
4. 
   
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   
7. * 形    参: 无
   
8. * 返 回 值: 无
   ( t' ?0 q2 Y/ U
9. 
   0 L' |/ t2 ^# |# g
10. ---
    % }1 W: h+ N" F+ i  ]* R, m
11. 
    
12. */
    
13. void bsp_InitUart(void)
    
14. {
    ! c+ r, K0 h6 ^0 L
15. 
    
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    8 k. y2 V" J. _& y1 R
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    # @! ?2 R6 z7 v. v3 R; b
19. 
    
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    ) s& s% u( J- M2 c3 \( j
21. }
    

复制代码

/ Q; I7 P  g1 @6 z; Z下面将初始化代码实现的功能依次为大家做个说明。
: L0 H# S% S! M4 A! R, C
6 V: r6 p0 W9 D) j函数UartVarInit
- H: I& P8 c  \! ^这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

1 L4 J7 D( b! S" c/ \

1. /*
   
2. 
   1 g8 m' R9 C! r$ n# `6 K" E- E2 E% H
3. ---
   
4. 
   4 s% a3 [  h1 f8 l) ]
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   1 p  \% y) C2 V  y' ?( Z; ?  E
7. * 形    参: 无
   
8. * 返 回 值: 无
   4 P5 a7 t6 @9 B! U
9. 
   / e; n* I) E1 L. u3 C3 r: ~! b6 F
10. ---
    
11. 
    
12. */
    
13. static void UartVarInit(void)
    ; M, `' D/ w+ ]* f7 Z( [  c( F
14. {
    
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    & v) N' n$ H. V. T  q
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
      r0 J; F3 G$ ?$ L; w! g
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    $ D; e5 U$ I; E- p* e% a2 k
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    - ]* z$ F3 Y2 r
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    : F7 a+ \( t7 I3 ?) b: c
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    ! c% m! z, d  }' q! f1 G
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    4 k* U3 ]: `$ i$ I/ I5 q, x! t$ ]
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    1 i3 O( g5 r# s) C3 r# [: D8 q
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    3 O3 R" {; _0 ^" g1 B/ |
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    - i' L3 N. M" `2 {* P& o( q
31. #endif
    7 K( q* z% W, f7 y* U7 y
32. /* 串口2-8的初始化省略未写 */
    ; Y2 f3 K, \: a/ c/ o
33. }

复制代码

函数InitHardUart
! k4 |# A+ d8 i$ \( E此函数主要用于串口的GPIO，中断和相关参数的配置。

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   ' |* D; P% E2 {& m& n8 H: L
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   
3. 3.        
   : h+ q  D3 K1 O7 b
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   + @* v% B* ?- D
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   8 f, g6 ]5 `1 X: M/ V; H
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   - ~* H! h" g; F+ _
8. 8.        
   ; V0 c2 W3 Z# u1 m
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    ( }. S- P; t- N' a* V9 B" T$ w6 x+ U
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    
15. 15.        
    
16. 16.        /*
    
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    - E+ l& z$ |( e! a$ n
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    % T8 m- l3 D: m
20. 20.        *              发板
    
21. 21.        *        形    参: 无
    
22. 22.        *        返 回 值: 无
    
23. 23.        ******************************************************************************************************
    
24. 24.        */
    9 C1 Q/ B3 m& @0 |
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    % ~/ ^( _8 q3 I
29. 29.               
    ; a- }8 _7 b5 B- i  ]
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    / z# J, F* P3 r8 h& {0 i
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    ( X$ m$ `* S" t' r& `; k! F: W
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    ( {+ q- u: m5 V* o$ y2 o
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    % z* B' s& M2 f) T# S
38. 38.        
    , U) l+ h: k3 J% C0 l
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    3 X- m  x, y# I8 o1 T" L  F
43. 43.               
    6 J* U- z6 _; E# y
44. 44.                /* 使能 USARTx 时钟 */
    
45. 45.                USART1_CLK_ENABLE();        
    % E, Q* n3 |  `7 P
46. 46.        
    ) J3 Z, j+ X) O1 X
47. 47.                /* 配置TX引脚 */
    ! D0 c' z1 Y  U6 i3 @1 j. L
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    " o! q: r1 _/ T$ L. U% L8 V
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    4 b% @. X  V! @
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    % m+ k  k* x: H9 w9 }( O' `
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    0 s7 K) s8 T! [+ t5 W0 |
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
59. 59.        
    8 R% l9 K( a0 ]
60. 60.                /* 配置NVIC the NVIC for UART */   
    ! x; w. p& ?3 X
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    5 f' N1 L( @3 ^2 W( V+ c
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    + B7 D* j' Q" C& K9 w. m3 p: ]: D
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
71. 71.        #endif
    
72. 72.        /* 串口2-8的初始化省略未写 */
    4 ], ~  v, g2 f5 D, w
73. 73.        }

复制代码

% d, [# {" h0 S' b' o# e* J第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
% _  g( T+ X8 E4 _4 q第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
3 ~9 [  Y) r+ Z2 M" Z$ r' v' r: z( @                                                                                                                                                
- N) A. p  y4 g! m- j. H) t+ e

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_SetUartParam
   7 M7 K4 ~0 X2 F# V0 d
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   ( D4 f, e* ~1 f* w8 G- x+ I/ a7 c+ F
5. *        形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   : T) w: E8 l2 J
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   2 m; g4 z7 U. G: A' e
10. *********************************************************************************************************
    7 ]: H7 |; [3 u& C8 W
11. */
    
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    3 p) F- k- d. b3 T% v
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    4 Z3 z* Q, _0 F, k2 O5 M# j
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    , @% M2 Q1 n: B
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
    5 S" p- L" D6 z, k! h
21.           - 校验    = 参数Parity
    & {) k( q$ {# L5 k) J- V$ Y% ^
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    & \8 m2 k& W3 a5 E! ?
25.         UartHandle.Instance        = Instance;
    
26. 
    8 T+ @9 H! W+ `
27.         UartHandle.Init.BaudRate   = BaudRate;
    / h( P' v: ]. U% k5 E* g
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
32.         UartHandle.Init.Mode       = Mode;
    + ]0 h0 U' v5 @4 M2 G1 P! {9 K
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    8 F8 C7 F/ c3 K0 d
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    1 l: c6 t' p# _# I+ e- J& z
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    4 P. }" _& p8 p( d
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    3 i, W$ Q- g. L& [
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    , Y: [% v- }, n% ?! F0 }& P
40.    
    
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    6 q* r( {- \  p2 s# G
42.         {
    ) i: H6 |, s* _) M. x
43.                 Error_Handler(__FILE__, __LINE__);
    5 y5 U9 e. c' L7 a1 B/ k1 [
44.         }
    " l: ?: p* t3 d+ w6 o% O3 e
45. }

复制代码

& D0 G0 o- F, `函数RS485_InitTXE
  `6 ^9 D; U7 \% b2 i3 ?* y( C8 s此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
$ S9 F* w! a7 B! ^$ [) H% M

1. /*
   ) {* p. K, B# Q8 S, m+ p
2. *********************************************************************************************************
   
3. *        函 数 名: RS485_InitTXE
   
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   $ B$ K0 q- R3 H' v
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ( k. _. t0 \' Q. {7 Q: ?; ~
8. */
     U% h5 i( X' A) ^! r5 D4 x6 Z
9. void RS485_InitTXE(void)
   
10. {
    ) [" ]/ X6 T; x: ]7 p
11.         GPIO_InitTypeDef gpio_init;
    9 i/ J, @: \, W0 G: A
12.         
    1 m3 f9 _7 a! v" Y/ C, f( ~
13.         /* 打开GPIO时钟 */
    
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    6 _: o1 }+ i+ w* W% i
15.         
    " B7 h, W1 z6 K! v
16.         /* 配置引脚为推挽输出 */
    
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    3 h+ g4 |2 a, y5 D! v
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    1 _, Y( H3 ~1 u0 U
22. }

复制代码

30.3.4 串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能
& _% I8 Q7 N" S* B6 w3 s3 @2 T1 L8 m8 L
" W2 B+ Q. t/ Z" S! ]收到新的数据后，会将数据压入RX_FIFO。
检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
- m& S0 }8 l! {% o$ F% i" t
下面我们分析一下串口中断处理的完整过程。
) g- ]  j0 P6 m9 c% z3 `当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：
3 M  F6 n8 Y; n! s& F# `4 F- c6 I

1. #if UART1_FIFO_EN == 1
   0 T8 z, `& u- G2 N4 S- L8 X6 z
2. void USART1_IRQHandler(void)
   
3. {
   . n/ t& D  {4 Q5 J' V4 b. q
4.         UartIRQ(&g_tUart1);
   
5. }
   
6. #endif
   : @1 u! g) H$ a
7. 
   ' Y- d0 @- P+ A  P2 {. @
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   
10. {
    
11.         UartIRQ(&g_tUart2);
    / i' j, [# B* Q) o' p0 q8 i
12. }
    9 I- U- @+ A. \
13. #endif
    - R5 k" p+ i6 g9 R
14. 
    * Z4 j  J# O' @( l) E  D" j
15. #if UART3_FIFO_EN == 1
    . x3 p. E: g) C$ V
16. void USART3_IRQHandler(void)
    8 D  u4 L- i8 o
17. {
    % S0 ?# c7 a, C
18.         UartIRQ(&g_tUart3);
    
19. }
    + z% z% j, O7 {, `0 k
20. #endif
    
21. 
    
22. #if UART4_FIFO_EN == 1
    " o0 p4 a4 B3 Y: \% Z9 r
23. void UART4_IRQHandler(void)
    " m7 K8 Z4 m4 A( G9 V
24. {
    
25.         UartIRQ(&g_tUart4);
    & z" C- w" @+ N8 j% G) ]3 y
26. }
    
27. #endif
    9 ]5 s" L# n8 S% v; H
28. 
    # u. i' n' L' |4 M! ]- P5 e
29. #if UART5_FIFO_EN == 1
    # d( f! P, ~. c; A
30. void UART5_IRQHandler(void)
    0 r( g8 @) V* S- }; P* }4 f
31. {
    # H8 w  o- E" C- ]" D
32.         UartIRQ(&g_tUart5);
    
33. }
    
34. #endif
    3 w2 e7 b$ |* X$ _' t9 G0 u4 }
35. 
    
36. #if UART6_FIFO_EN == 1
    " p" r+ I5 ~- i, h) C
37. void USART6_IRQHandler(void)
    6 @. K9 b2 p' Z# X5 q
38. {
    
39.         UartIRQ(&g_tUart6);
    
40. }
    
41. #endif
    
42. 
    
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    7 z$ Y; I6 O1 a, f4 i$ o
45. {
    
46.         UartIRQ(&g_tUart7);
    ( |0 M) u7 x$ M; D5 }
47. }
    2 H0 W; {6 M8 j& Q
48. #endif
    
49. 
    5 n9 I6 U9 B/ [' d  ?
50. #if UART8_FIFO_EN == 1
    * g% F9 u8 v+ }2 C; F8 l
51. void UART8_IRQHandler(void)
    ; a) v6 N+ q6 F8 v+ x5 H1 J
52. {
    
53.         UartIRQ(&g_tUart8);
    
54. }
    
55. #endif

复制代码

9 A' s8 s$ c9 ]大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。
& ?( n! X' P; i) Z4 ~" X3 u9 I8 R
下面，我们来看看UartIRQ函数的实现代码。
; a' Q9 A+ D2 O. {( X% t

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   - r9 ^& V+ E' C
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   $ l+ q/ Y" `5 W! a
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   ' F* H* `" @# W! N' G; N3 z
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    $ C" I! [$ k; H- Y7 v$ y! P: S
14.         
    - T* E  X/ ~, ]
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    ( q5 a2 D7 T# R* s- Z+ f
19.                 uint8_t ch;
    
20. 
    0 O* `' C) [( l: h4 `$ B
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    ' r9 J8 K' ?! u! u
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    5 [/ k- U# y; S- Z& I
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.                 {
    
29.                         _pUart->usRxCount++;
    * ]8 L* e- f9 c2 x6 c9 i6 O1 O$ C
30.                 }
    
31. 
    ) e; ?, T, K7 d# w
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    5 Y& i. \" S) n5 T+ M7 {  g
35.                 {
    
36.                         if (_pUart->ReciveNew)
    
37.                         {
    
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    
40.                 }
    
41.         }
    
42. 
    + a* C" Z; h4 l  Y) L* f1 |
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    8 |4 \; L3 }/ x0 L) E9 j
45.         {
    
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    $ ~1 B' q  E! \8 B, w3 h
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.                 {
    ; R2 s) ^5 @3 u5 q. n
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    ' a) S/ e$ c2 \
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    - {2 M+ G( h5 l' Q+ }
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    & D3 P' P% ?4 q# @
53.                         /* 使能数据发送完毕中断 */
    
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    8 q" H8 ~2 R3 j3 \( Y! [2 s
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    1 Q. Q2 w; x" }$ k* `" y7 j
56.                 }
    # U2 q- p9 H* j7 S
57.                 Else  /*　还有数据等待发送 */
    
58.                 {
    
59.                         _pUart->Sending = 1;
    
60.                         
    8 [! J$ T% D% O. m
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    ) Y5 q5 D+ {( N% X
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    
68.                         _pUart->usTxCount--;
    ( b0 J) z" L% w# H2 v4 Q
69.                 }
    
70. 
    7 U. _7 Q6 ?( S0 B
71.         }
    $ O; v2 M' e" J" g- X9 C3 E* i
72.         /* 数据bit位全部发送完毕的中断 */
    
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    7 Q3 C+ r* j- s7 F; A! F
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    
77.                 {
    0 o7 \6 Y6 z* t0 J- Q' F
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    ' m+ l1 g7 H# e. t
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    : `+ j3 W; D: X. K: i4 f  L# V; |
81. 
    2 @7 }  T* V" b$ T1 L
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    $ q  R% B# X  x: h* ]5 z. [, R
83.                         if (_pUart->SendOver)
    
84.                         {
    
85.                                 _pUart->SendOver();
    
86.                         }
    
87.                         
    % e4 }2 J/ h  @7 o4 E" T$ ]! |" }" o
88.                         _pUart->Sending = 0;
    ( G$ U  E" Z1 m$ Y, _% o/ _
89.                 }
    
90.                 else
    ; j7 n- N5 H' G8 H& q) j% V' F
91.                 {
    4 c- n) b' t7 N* i. w
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    ) o% G  j( w2 P) Z3 O
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    4 Y( l* Q1 k0 b7 i; G$ y" }$ r; Z
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    : K& ?# `0 b$ S5 D& R% v9 H$ Q
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.                         {
    ) K" }2 ?, G4 T1 H8 j$ p- G* J
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     
101.                         _pUart->usTxCount--;
     4 D7 R2 Q2 @6 G4 P" A$ J# D/ U
102.                 }
     
103.         }
     1 H: d' U) l' l* n" A5 _5 Y
104.         
     
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     ) W8 v, v% }. B, y& m, X# f4 t
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     , i0 P( x9 n7 v* t+ i
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     ' |3 \" }2 D* R5 x: [
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     * j; X* }+ a9 h7 h
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     
117. }

复制代码

0 |  G5 V1 A. f, N6 v* m中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。

3 u0 B9 Z5 [, s; g9 ^# {/ j  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

  发送数据处理
* D& o0 \- w( X7 |/ y发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
* s" d) M2 Q. t* b% X5 d
8 P, H7 r2 c# {0 ]30.3.5 串口数据发送
  K+ m& C- L  a" [7 F0 W; d串口数据的发送主要涉及到下面三个函数：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   2 A, C1 e2 t0 Q5 D0 e
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   
7. *                          _usLen : 数据长度
   . h; s7 k2 j$ g4 _3 x7 Y& ~- K
8. *        返 回 值: 无
   % ]2 ^0 O% X( U  \) `! F  [
9. *********************************************************************************************************
   % u1 e, z0 X$ S6 e7 U) U4 {
10. */
    
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    7 p7 I1 K( q; S. Q' x) U1 z
12. {
    
13.         UART_T *pUart;
    ' I/ e# m6 `3 M
14. 
    
15.         pUart = ComToUart(_ucPort);
    + Y  S+ e; b$ Z  F
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    
19.         }
    
20. 
    1 R" B; x  S% Y/ k4 Y& X
21.         if (pUart->SendBefor != 0)
    - H+ z5 \7 f0 P+ k* \
22.         {
    
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    / l9 ^) g% K4 y# e
24.         }
    
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    / _: R4 @$ Q! s" Y3 e
27. }
      G8 t* f& a. y* s( T
28. 
    9 z! p5 w- ]6 e+ D/ s6 n
29. /*
    8 \7 `. c- R% T6 o+ s* |9 Z
30. *********************************************************************************************************
    + U+ G0 ~. m8 C' e( Z- P
31. *        函 数 名: comSendChar
    + F0 [/ E% Y6 u' M+ m
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    : G; ]! F  a, m& a
34. *                          _ucByte: 待发送的数据
    2 ]9 m/ ~4 n' w$ H
35. *        返 回 值: 无
    1 [1 Y/ H: [3 J- _$ i+ N
36. *********************************************************************************************************
    
37. */
    
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    
42. /*
    
43. *********************************************************************************************************
    
44. *        函 数 名: UartSend
    
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    
47. *        返 回 值: 无
    6 }( G* {* c" @5 Z: ?3 e# p+ p
48. *********************************************************************************************************
    
49. */
    
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
51. {
    . {3 I* w8 \3 V5 X3 k) H; e
52.         uint16_t i;
    ' \2 z, D5 e/ @2 |: L
53. 
    
54.         for (i = 0; i < _usLen; i++)
    + M% s, l) }+ ]( n; X. O
55.         {
    
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
57.                 while (1)
    
58.                 {
    
59.                         __IO uint16_t usCount;
      v4 `: J7 G) d
60. 
    8 k. [+ T# V9 A: G' a5 k
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    
63.                         ENABLE_INT();
    
64. 
    
65.                         if (usCount < _pUart->usTxBufSize)
    ' ]( U  c1 l- C& Q0 S" O/ q5 y
66.                         {
    : T7 j! r, w' O0 y1 @3 q: w0 l
67.                                 break;
    ' s/ I9 ?! L* D; l" c9 {
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
70.                         {
    6 U! C* J3 _3 @; E; b1 K
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    % h& X" z3 b( U/ M: M# J3 |3 b' X# ~
74.                                 }  
    
75.                         }
    0 R) L  B0 V9 P, I) v
76.                 }
    8 q6 m8 z# U7 h3 `
77. 
    . o! x4 `* ?* V$ O  C
78.                 /* 将新数据填入发送缓冲区 */
    1 [" ^. U, V* \; R" _& c
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    # B1 i2 x4 K3 i0 x  O4 A
80. 
      G; N5 J7 v( j" I) [
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    . ^* h, J8 U' q0 I- R! J
84.                         _pUart->usTxWrite = 0;
    ; A/ w, N# H* v% e  l  [: w
85.                 }
    ; g4 t; e0 N5 |% q( e. h- @
86.                 _pUart->usTxCount++;
    
87.                 ENABLE_INT();
    8 T3 F+ l; r$ b
88.         }
    
89. 
    - n) u9 u6 \& m7 z1 @5 w3 Z- x5 Q
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

  c; o+ W4 k' ^+ F( L  F( `. m函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

" P& v7 j5 D" O4 I* Q7 C! v函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
! o! A# p+ Z' r% l9 D; j
  [$ _) O! ?9 |5 @1 |9 M  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  K  l* ]& L  R0 r* B* d  G' Q  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
8 M# {( N/ J  C4 C/ X
9 k& }" I- ]4 O' M7 j6 J注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。

& Y3 E* T1 d5 @0 ?函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。
0 W( B" ?! B/ V, Q8 q

1. /*
   0 }$ C' ^/ u  a* `6 [
2. *********************************************************************************************************
   " F' a8 ~' z6 X. I$ o3 L* i
3. *        函 数 名: ComToUart
   0 ~' D  v6 V  F
4. *        功能说明: 将COM端口号转换为UART指针
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *        返 回 值: uart指针
   ' V3 ~! }! e# h, Z4 _# f6 T& _
7. *********************************************************************************************************
   9 B' Q- I: {$ G* E8 T
8. */
   7 m1 e; H' `( p, m* {5 i
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   - p4 l) H6 L' d) \! R9 Q8 J
10. {
    % j8 R8 w$ t0 D/ f" z
11.         if (_ucPort == COM1)
    & ^( {; w  e# g+ o" h  c' k- T0 u+ i: x
12.         {
    
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    1 D. R9 {1 N- x# ?5 H8 g+ B2 y/ W
15.                 #else
    $ d1 G" b1 {* J1 @9 G) V- q; i, y$ o
16.                         return 0;
    
17.                 #endif
    ; O0 b  I% }6 d  Z
18.         }
    
19.         else if (_ucPort == COM2)
    
20.         {
    * O, ~( R, d" q3 Y7 a. I
21.                 #if UART2_FIFO_EN == 1
    , _/ G3 H: ]; ]5 ?
22.                         return &g_tUart2;
    
23.                 #else
    + a- u$ V! p: J2 Q) I0 P
24.                         return 0;
    
25.                 #endif
    
26.         }
    
27.         else if (_ucPort == COM3)
    
28.         {
    ( ^; m) H9 R0 A, Y
29.                 #if UART3_FIFO_EN == 1
    
30.                         return &g_tUart3;
      J$ |" L- H0 F& q
31.                 #else
    : Y. Q% U" Y/ s" e3 n
32.                         return 0;
    & ]4 \, z4 d, m  b; y" T
33.                 #endif
    
34.         }
    , q3 d" Z0 Y) o
35.         else if (_ucPort == COM4)
    & J3 R- r  x3 o9 k" j
36.         {
    . ?: h- f. h1 }; _4 ]% g- s6 F
37.                 #if UART4_FIFO_EN == 1
    ( R6 X4 z- o4 y: g
38.                         return &g_tUart4;
    
39.                 #else
    
40.                         return 0;
    
41.                 #endif
    : }3 r6 ~; z& k2 ~9 ~& b
42.         }
    7 F. _1 m" S: X4 Z6 ^8 ]; D1 Y
43.         else if (_ucPort == COM5)
    
44.         {
      t; g# U* o/ H0 Y9 n$ u4 d
45.                 #if UART5_FIFO_EN == 1
    / R. b& y) N6 X
46.                         return &g_tUart5;
    ( s" @6 q$ E8 @( x
47.                 #else
    1 n+ v/ D  h4 N+ I' R
48.                         return 0;
    
49.                 #endif
    : |! m+ u) X; t. D
50.         }
    
51.         else if (_ucPort == COM6)
    
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    
54.                         return &g_tUart6;
    % D' ?& ^8 ~/ D
55.                 #else
    6 a9 @- v/ A2 J& \; J5 p% m, G& s  Y
56.                         return 0;
    3 Y1 }# |5 a- g! g: ?+ G
57.                 #endif
    6 e# G( B! I) ?3 i2 r
58.         }
    / G; E* K0 x0 X, `8 O
59.         else if (_ucPort == COM7)
    
60.         {
    # u- t: P6 k) ^& z- k- z5 Q/ p
61.                 #if UART7_FIFO_EN == 1
    & W, U; c" z, [" n6 p
62.                         return &g_tUart7;
    * V* ^- _0 [# C
63.                 #else
    
64.                         return 0;
    / S  q; V( g+ T5 r2 M9 ^
65.                 #endif
    # o7 L  A9 B  i: [: k
66.         }
    6 j0 V1 |: ^: ^
67.         else if (_ucPort == COM8)
    
68.         {
    # d5 Y0 d  F4 v& H6 f
69.                 #if UART8_FIFO_EN == 1
    : n/ O$ ^$ D3 W7 I2 o3 J1 ?
70.                         return &g_tUart8;
    8 w; f. Y  H: d' z$ o
71.                 #else
    $ H6 v+ ?) B% F
72.                         return 0;
    3 @: A! B4 Y. x' O
73.                 #endif
    
74.         }        
    
75.         else
    + j4 w" U5 X6 h& S1 r
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    ! P9 R) \! b# ]; C
78.                 return 0;
    5 N! D3 G& T  |+ o! g
79.         }
    
80. }

复制代码

" R3 }! D; t7 K* \% [0 v" E% j) h8 q30.3.6 串口数据接收
下面我们再来看看接收的函数：

$ R* l4 s7 G7 y" ]: {

1. /*
   , `  r- I/ @$ _) D, N
2. *********************************************************************************************************
   2 E! Z8 O& K1 q
3. *        函 数 名: comGetChar
   & D. h+ |5 J' @; i4 t5 S7 J
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   " }; x" _: G1 @2 p6 z
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   3 E9 l; U  E* w! q5 e* F: v9 _
6. *                          _pByte: 接收到的数据存放在这个地址
   
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   9 A4 q; c9 x. A8 e
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    * S. A4 m: s1 K
12.         UART_T *pUart;
    
13. 
    2 A( p& e. D; C) V' x
14.         pUart = ComToUart(_ucPort);
    
15.         if (pUart == 0)
    / N8 e* {: y% x- d6 R, q, l/ n' l: M; W8 ~  B
16.         {
    
17.                 return 0;
    1 P/ b/ ^/ A$ n: N% I/ b6 ~1 R* s
18.         }
    
19. 
    1 t6 f6 @* T  `. w" F
20.         return UartGetChar(pUart, _pByte);
    7 N* g' c4 D7 ~2 w+ a9 ^" ^1 q
21. }
    
22. 
    : _, I* w& U& v# I( c6 E4 i9 c
23. /*
    
24. *********************************************************************************************************
    7 L6 K, r3 v' J/ b, ~3 p4 m
25. *        函 数 名: UartGetChar
    2 `, W7 ]5 s/ X' `9 h
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    % b0 k; V+ D- ~6 i9 _
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    , v8 m- H% T4 P; u; x
30. *********************************************************************************************************
    , V( e% z8 n5 `$ q
31. */
    8 @- Z+ q) {, S2 L6 _7 g) S
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.         uint16_t usCount;
    ! ~# \! i7 j- x& w6 ?6 o
35. 
    3 j1 j' c8 U2 Y' J* A; |' [
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.         DISABLE_INT();
    # u) K, [9 u1 f- q
38.         usCount = _pUart->usRxCount;
    ) Z+ G6 S8 e' P- V% ?9 U
39.         ENABLE_INT();
    7 i# H! b- z# M8 G% c
40. 
    0 Q# o, G2 H: v; v5 B0 ~# R
41.         /* 如果读和写索引相同，则返回0 */
      ~# ?; m0 Y( l2 z& T8 ^! o
42.         //if (_pUart->usRxRead == usRxWrite)
    / z. C/ C8 L1 J
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    
45.                 return 0;
    ' p; w6 q2 \0 Z
46.         }
    + C7 R* C! I+ q) L. E6 K; }5 {
47.         else
    
48.         {
    
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    
50. 
    
51.                 /* 改写FIFO读索引 */
    # J& r3 F2 u4 `5 e1 y7 l
52.                 DISABLE_INT();
    3 U  E/ s. o# Q4 C
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    # ]4 _% Z& N+ E. a- x
54.                 {
    $ K, J6 v* J- p
55.                         _pUart->usRxRead = 0;
    
56.                 }
    . _5 O- P. R9 k7 g: \; S- z
57.                 _pUart->usRxCount--;
    6 ]) I, Y" A9 J) P
58.                 ENABLE_INT();
    
59.                 return 1;
    
60.         }
    
61. }

复制代码

  S8 }0 {. u4 y' K# a9 j函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。

- z8 h; p! @5 H* Q& j3 h注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

30.3.7 串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

& {5 s" g) {+ B" ^  y. ?为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
% m; b8 E. `  H8 Z9 o) y! B
实现printf输出到串口，只需要在工程中添加两个函数：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: fputc
   5 A" Z$ n1 s4 G' T  c7 r+ M* |2 w
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   * c# M3 I+ t! |/ X. ~9 r
5. *        形    参: 无
   
6. *        返 回 值: 无
     _' O) d9 l: W1 p2 j
7. *********************************************************************************************************
   
8. */
   " U) b. Y* y0 C; q8 h3 m4 ^2 D
9. int fputc(int ch, FILE *f)
   
10. {
    1 |1 g' T7 J: \5 j4 b( Q& I
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    6 g0 X+ f7 T# |6 s
12.         comSendChar(COM1, ch);
    
13.         
    & W/ e, y0 ]  r$ g2 B
14.         return ch;
    2 a$ A5 ~+ L3 n; S- J
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    * t" s) a7 }5 H2 Y$ C7 n9 o
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    
18.         
    1 x3 _1 T" L/ k+ t) H
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    ' }, Y4 d3 x, B6 R/ s
21.         {}
      W3 e7 k( k' m! y
22.         
    / c& Z) u2 s3 \7 o$ ^: M& s  J
23.         return ch;
    
24. #endif
    
25. }
      Y# F$ |2 x& B: ^9 j
26. 
    , ]" |. v$ T  V1 Q% o& L% r
27. /*
    " p2 C- e( Z! B0 L0 L2 D: Q
28. *********************************************************************************************************
    8 n2 {8 Z- c) `- _' L9 i$ e
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    ( [2 N/ [' c+ N3 y5 w
35. int fgetc(FILE *f)
    / d2 T3 S. S/ k
36. {
    - G* K2 Y& l' o
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.         uint8_t ucData;
    7 e1 y3 a9 L8 h; [
40. 
    & i5 l1 z6 r2 z- d
41.         while(comGetChar(COM1, &ucData) == 0);
    
42. 
    2 ]4 N# r/ g2 W' o1 }0 j
43.         return ucData;
    / X, k+ n* b) e( m$ r* @
44. #else
    
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    
48. 
    2 G- b% L. W3 _; o- i3 G* H
49.         return (int)USART1->RDR;
    & g0 P! V) }$ |5 V/ n$ |
50. #endif
    
51. }

复制代码

printf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。

30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
$ d& e$ a( J$ ?串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：
) }0 m. m( ~. C1 J; l/ J! F
  bsp_InitUart
  comSendBuf
  comSendChar
  comGetChar
. @1 j( ^) {- ~: w; `30.4.1 函数bsp_InitUart
; h' @% p* J0 e0 l7 @$ E& o函数原型：
+ |" U( |) F& h0 qvoid bsp_InitUart(void)
9 z4 R0 E0 b6 w& p# O; x1 E' ~
函数描述：
此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

9 k4 O9 f! a; K8 p; i. I/ R使用举例：
/ d# U% A% N- }* K串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

30.4.2 函数comSendBuf
' G4 X* ^  G9 i  ]函数原型：
, x% F4 Y( z7 G' b" I% Y6 Gvoid comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

6 C1 p8 R* c* A# _- F, B9 Q
; x' a; h4 T! M" j0 Z1 B, g7 n8 r) b函数描述：
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
2 P% ~! i1 q6 c
函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
1 W( `: A  H# N0 V5 K. _  第3个参数_usLen是要发送数据的字节数。


1 k$ q% M  P( v- q/ o% q; l注意事项：
  此函数的解读在本章30.3.5小节。
% G# w4 E3 T* e6 u6 ^  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
; ]9 ^/ i  A, f7 x! x% L  l- R

; }' ~( ^9 B4 d/ B; s1 M% I1 s使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

5 G( U' L% ?1 _7 A" s2 [const char buf1[] = "接收到串口命令1\r\n";
+ b0 N. c; S; |5 R6 lcomSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
5 Y: D0 R" a" J. `6 Z

. Y# s7 a* P0 h2 g* c9 P30.4.3 函数comSendChar
/ @- w. I: e1 m3 }" W- c+ \函数原型：
; @/ s4 d3 U( E, p% {: v" Nvoid comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);

. Q( [1 [' n: E1 u5 ?
函数描述：

% _3 d7 k' ^8 W; v5 v% M" u此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
9 L& I. h: \+ w
函数参数：
7 Y- B: k5 T' Q/ n+ K3 @3 m% i. m  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucByte是待发送的数据。


/ Y& W; \* i. n- L注意事项：
3 l% ~7 o; w: Q  此函数的解读在本章30.3.2小节。
, V, L( c; h% f4 z
  T. B0 g3 J# w$ l
; {. n8 I2 j1 d- k2 ^7 r5 a使用举例：
( z$ o9 D3 u" v2 P' F( Y9 [' M! v调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。
6 @% r: C# @3 `# G. W" U
30.4.4 函数comGetChar
9 q! }- n) w+ @$ r( A/ g0 S+ W函数原型：
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
. n$ @# s( @5 m0 Q. X4 S0 v
; [5 v# f! q% m2 ]2 x
" L! e! E# [* C7 b1 M! t3 z2 o函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

. L3 n5 z( Z: G. G0 `  i函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_pByte用于存放接收到的数据。
4 o3 i- F$ ?5 V! m/ O5 c6 Y6 V( h  ~5 h  返回值，返回0表示无数据, 1 表示读取到有效字节。


: N, _0 C! ?1 }3 R7 v) v注意事项：
  此函数的解读在本章30.3.6小节。
  M. x$ f, x( E8 x. e! v

使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
8 o0 r2 P6 s/ g2 ?
比如从串口1读取一个字符就是：comGetChar(COM1, &read)。
5 l0 f$ z# M3 N# h) i( ~; h
30.5 串口FIFO驱动移植和使用
8 c' E  Z+ S5 B0 i' g5 X8 w  `串口FIFO移植步骤如下：

  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
* ?/ r& M6 Q6 Z1 p# I

1. #define        UART1_FIFO_EN        1
   9 s2 Z" K- i& P. h
2. #define        UART2_FIFO_EN        0
   ; f& L3 M5 ^/ S0 f/ A! y( v( C
3. #define        UART3_FIFO_EN        0
   5 l0 g  i' J3 i2 ?: F% E  z! H
4. #define        UART4_FIFO_EN        0
   
5. #define        UART5_FIFO_EN        0
   ) \* |9 Z# N6 P9 t
6. #define        UART6_FIFO_EN        0
   . w1 c/ H; j& o: m# d. I
7. #define        UART7_FIFO_EN        0
   & V0 S% r; q3 A3 a' g% @" H: m
8. #define        UART8_FIFO_EN        0
   
9. 
   
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    2 P( |) S1 J6 ]! _# z; F8 `% y$ }% V
11. #if UART1_FIFO_EN == 1
    + r  G+ R+ M# k+ e7 T! P; X9 \
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    % ]' V& x3 j0 y6 Q3 f
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    
16. 
    / d# R( g- \6 a
17. #if UART2_FIFO_EN == 1
    
18.         #define UART2_BAUD                        9600
    # _" s. v* Y& \+ `
19.         #define UART2_TX_BUF_SIZE        10
    & c  l/ e: u1 T8 ?) w- v- V8 K
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    
22. 
    
23. #if UART3_FIFO_EN == 1
    
24.         #define UART3_BAUD                        9600
    ! `$ A4 Z8 f6 l" b6 ~- m
25.         #define UART3_TX_BUF_SIZE        1*1024
    # E/ w0 ]7 H( a
26.         #define UART3_RX_BUF_SIZE        1*1024
    
27. #endif
    
28. 
    ' r; j: H# ]7 }  b4 h
29. #if UART4_FIFO_EN == 1
    . ~. i3 R: T: C. t2 T! D+ A+ G
30.         #define UART4_BAUD                        115200
    " N- }) H% t8 y9 ^" `! c0 k
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    9 ]& j: \0 Z; I+ E8 U! Y' q6 f; m
33. #endif
    
34. 
    . c/ J" X0 y# z. H$ a
35. #if UART5_FIFO_EN == 1
    , h  n/ f: A8 {' ]/ I% n# F6 a7 G
36.         #define UART5_BAUD                        115200
    
37.         #define UART5_TX_BUF_SIZE        1*1024
    , J5 e# P* D# T. ]: f
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    0 K$ r2 `% ?0 c$ A
40. 
    $ n7 K, W( o0 a# C: ^- I2 q, w
41. #if UART6_FIFO_EN == 1
    6 k: j) q# n. @5 q+ V
42.         #define UART6_BAUD                        115200
    # k9 s2 r2 q" p, p+ t5 p* x( q. k7 N4 T  ?
43.         #define UART6_TX_BUF_SIZE        1*1024
    
44.         #define UART6_RX_BUF_SIZE        1*1024
    1 K0 C2 z8 v! S! w( B1 M% J/ @
45. #endif
    1 _" L3 C, m  F' N
46. 
    " f1 D! V: n+ ?) B+ c
47. #if UART7_FIFO_EN == 1
    
48.         #define UART7_BAUD                        115200
    
49.         #define UART7_TX_BUF_SIZE        1*1024
    " `9 X! g) G+ m) D
50.         #define UART7_RX_BUF_SIZE        1*1024
    + y) F1 H# ^- r  ~& u8 p
51. #endif
    
52. 
    , m' T2 |7 I# m, h+ f; V
53. #if UART8_FIFO_EN == 1
    
54.         #define UART8_BAUD                        115200
    
55.         #define UART8_TX_BUF_SIZE        1*1024
    ) b2 C& G9 P; @' F
56.         #define UART8_RX_BUF_SIZE        1*1024
    ( i& T& q; M4 Q# A8 Y+ Z( H4 a, N9 d
57. #endif
    

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
" k- R& u& F0 P- s0 Z. X: u( P3 s4 C! N
30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
5 i; p- _  i9 y+ [
, U7 R5 l" ]; G$ }

0 d4 [4 t9 z  a# ^+ L0 P! W1 H  第1阶段，上电启动阶段：
' S  k0 ?; b2 O
, `! y) Q" a# S/ }# r这部分在第14章进行了详细说明。
. E8 s8 g6 [6 |6 A6 h6 p& h  第2阶段，进入main函数：

8 g  B- ^3 F7 V  h4 f4 j' e  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
0 m- q7 S# u, N( _: c* V6 L+ `  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

30.7 实验例程说明（MDK）
配套例子：
" ~. U3 H0 S5 m4 y
; r$ u5 q2 t6 l) s# CV7-015_串口和PC机通信（驱动支持8串口FIFO）
1 @, q# C/ [: W* a. o, [
实验目的：
- G3 X% @. W# C  \% ]* @学习串口与PC通信。

7 y: R  {  c& ~( i( S
实验内容：
3 {# k. g$ p- y4 E6 e) O2 `0 ?启动一个自动重装软件定时器，每100ms翻转一次LED2。

. w, m' h1 H1 c" D# }# O: O3 c
实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
1 R8 k* [7 c: Y4 j  b; j" VK3按键按下，串口打印"按键K3按下"。
# i; Q# m# i: v# `5 ?) @2 M上电后串口打印的信息：
: S6 N" f& O! |7 a
2 ]3 B5 X, l+ d波特率 115200，数据位 8，奇偶校验位无，停止位 1
) ?8 k) w9 u; c- D( w2 {
; b' p* b! ]; @; A7 I: d

6 a$ ~2 X, M5 o, c
程序设计：

2 N1 Y% |  L4 t! ~3 e9 K5 @6 f  系统栈大小分配：

, n# H" J, R4 E( P& d' C( k. n

  RAM空间用的DTCM：
4 z+ O1 a: D) H* \
) x- n. T: e1 }6 j$ [

8 R# B) E# j4 x/ x6 {+ m  硬件外设初始化
% B1 d: f, H- W0 j/ d
) E) q4 Z1 @" O+ b硬件外设的初始化是在 bsp.c 文件实现：

! ]* S1 v% P- H* e

1. /*
   " H' Q2 x/ O8 I8 i+ r! P6 I
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   ! R) }! _  Y, f; Y" a/ }* N
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   0 p  [% |  F% g3 u# N
8. */
   ) T/ U9 |, ]5 H- v
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    : B" W, B' A5 n- |
13.         
    2 M! \- w* y+ u, G" Y: [+ h2 i
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    4 s  J. l* p% s9 v$ ~/ @/ T
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    ; u+ o4 U& R- v" [
24.         /*
    
25.        配置系统时钟到400MHz
      C0 F7 B: }2 [, U( A' S! R  P4 z
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ( F  p8 G/ }& X8 G
28.     */
    
29.         SystemClock_Config();
    ! I& @, Z2 t' T$ Z* N# x# _
30. 
    1 @+ g6 x# F( I- E
31.         /*
    ) _+ y. L- M+ F
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    & p# q9 N8 j7 v# {0 x
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    1 Y! B8 A6 S1 I/ x! w* w4 k
35.         */        
    1 r1 G0 O* a7 I& L/ G7 B2 u
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    # m, q0 |: D# s6 b0 R" b3 X+ n' d
39.         EventRecorderStart();
    5 N! M: y5 z2 ]" a
40. #endif
    
41.         
    , A& D0 j1 S; K4 V0 k2 _9 D; L! {
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ) u7 l; S. S; Z7 b* }- U( i  G
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    " o3 }: q5 F# j1 {( y8 [: u/ L
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    8 N$ f8 P2 \. H4 R  s! T+ N3 q
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

7 r3 c& o3 w7 n+ q% ^  MPU配置和Cache配置：

9 T2 v$ f. c, u' I1 K9 L% F数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
; @) d+ O. o: Z# r

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   * m# i4 g% K2 H6 @& Y
4. *        功能说明: 配置MPU
   ; j! l/ p5 W" w/ o
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    - Q( R- O1 d  V9 y" m
12. 
    . T; U( `. z0 \2 E
13.         /* 禁止 MPU */
    5 }( s1 Y( J6 l2 E5 Q
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # u3 D+ k: f3 G9 G
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 `; v& s/ H5 s' w9 }% ^- q- T# ~
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 M" x4 j. r. D2 Q  ^% S
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    8 [2 ~% Q+ K% ^1 L
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    ! X8 e* X, R% J+ Y
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( d$ k% u$ i$ m, R8 b8 T* X7 D$ w4 i* v
30.         
    
31.         
    0 w7 y/ s, m7 f3 F/ z
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    2 J. T& ~  D! _8 t. Z: D
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # I* Y  y/ Y" C) ]& v  n
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    6 }. D) J* j3 Q; d5 M( f; I
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + v! l* e+ ]! H) C" V
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    " T; g7 w. G9 q  X2 u4 o
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    . ~- g+ k+ P4 q; W# b
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    , {  o0 B: X* q3 h+ S. I
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & `0 O# {) o$ p* W& H9 K5 c
44.         
    9 m+ e% p' q. y* T; h
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 R/ H2 t4 _( [: F
46. 
    & _0 r9 N) b+ J# A
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    9 a" a/ F& k1 Y7 X+ f$ _
49. }
    
50. 
    0 H# I; @* F/ O) B9 A" h3 }
51. /*
    
52. *********************************************************************************************************
    8 ]* T+ q2 d+ `, U
53. *        函 数 名: CPU_CACHE_Enable
    0 Y& ?" V3 R3 p% R& _+ g* C* v# n
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    : |3 i) o/ X/ A( p& L5 z4 w. k: e
56. *        返 回 值: 无
    , }7 m" j' m8 c
57. *********************************************************************************************************
    
58. */
    1 `9 H" i3 b3 `/ ^3 S9 M+ X
59. static void CPU_CACHE_Enable(void)
    0 V. P* c3 _0 ?- J
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    3 ]* O; y, [0 @5 z! x/ A6 X5 j, P
65.         SCB_EnableDCache();
    , }5 L, Q1 C" z' f3 u" b7 V
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
  F4 u; j! C% f0 f+ @# a
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   % j- I8 U( @. V# ^3 y$ `5 N& [7 R
3. *        函 数 名: bsp_RunPer10ms
   3 X- \% p( \4 X- P& H/ x$ Q2 j
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   - W* a1 R  J  N- S
9. */
   ) H9 g. N% B$ q# U
10. void bsp_RunPer10ms(void)
    + w  I5 c) U& O& ]$ q  y. V
11. {
    . O+ I5 d+ L4 @" R/ |  D9 Y. h
12.         bsp_KeyScan10ms();
      m0 a  q3 B) s$ m% o
13. }

复制代码

  主功能：

* o9 B& n5 i9 f, k主程序实现如下操作：
" w/ E  L( g: y2 l# A. s& X
( [' ^5 _1 A- m' J* |  启动一个自动重装软件定时器，每100ms翻转一次LED2。
8 ]/ F- u9 F8 W% D) `6 Y3 G  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
3 ^" d" o6 J; c% \& N! o( Q. l0 t, N  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
: \3 o+ ?2 Y; b  K3按键按下，串口打印"按键K3按下"。
% w+ S. i$ |6 g1 F

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   / i: ?2 s0 C- T/ R
4. *        功能说明: c程序入口
   6 A- a+ h+ v7 B9 F, U7 @" U) ?
5. *        形    参: 无
   ; O9 R  A8 Q: X# [7 i) W
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ( a; W8 z) \# N& ~. i7 D3 K
8. */
   
9. int main(void)
   , |: s4 n) j( C8 e* Z) W9 D
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    2 j$ J& u7 h, |# B; k  F% Z7 V
14.         const char buf2[] = "接收到串口命令2\r\n";
    : f! S: I4 n: g9 t3 H3 B
15.         const char buf3[] = "接收到串口命令3\r\n";
    ' L; F1 s, M. _9 L& C
16.         const char buf4[] = "接收到串口命令4\r\n";
    : v# g( _% {" G' s' ~
17.         
    
18.         
    ! J+ `' v4 w8 K3 j1 }
19.         bsp_Init();                /* 硬件初始化 */
    " K7 s* h$ H5 K+ T' \, V
20.         
    - v. X( n2 m0 H
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    1 |. @4 j/ A3 ~
23. 
    . l( [) I. t& S2 C3 Z
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    6 j' c' r' U* P0 @
25.         
    
26.         /* 主程序大循环 */
    - ^* l8 o4 b* |5 Y: X/ j! q% `( L
27.         while (1)
    
28.         {
    & R6 F2 `2 q! C( m) Y7 D
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    % f. `1 ^$ z" m4 G# W$ Y) N) d
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    0 Y& o1 X( o) W3 k) p$ ~; u
34.                 {
    & U& \* w& X( x' h+ m* Y' ^
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    " N2 [0 [  ^! G: D# S9 b$ ^2 o( `3 x
38.                 }
    / s4 P9 y2 k) U$ e5 ^! b
39.                
    % c, M7 V- `1 L! F5 n
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    , T5 c4 \3 X- x+ ~; C
44.                         {
    + z0 [3 c9 g2 q, \8 ]. x
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    # e9 F7 z+ }# C. a& N
47.                                         break;
    4 n- `5 f) I9 A, V
48. 
    
49.                                 case '2':
    0 K0 q# f8 ?" y" c/ R4 A
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    . X3 ]( K" m8 O& _% K
51.                                         break;
    , T8 n/ _$ J: T& ]2 q* O# d
52. 
    . G6 a! k7 c1 y8 s8 C& R3 o
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    4 n% v- x5 s+ `
55.                                         break;
    / L2 ?7 ]3 y& P
56. 
    
57.                                 case '4':
    # U) t4 M: _1 u/ K
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    0 J9 {$ }! d* e* }9 V: _. ?
60.                                 
    + X) k7 K$ X7 Q
61.                                 default:
    7 H: x; R$ G1 A* o
62.                                         break;
    % \( {  A5 p* [4 z
63.                         }
    $ [9 j) w- h) v& W
64.                 }
    
65.                
    * i) m7 l0 w1 A$ l/ u2 K
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    7 ~  Q' L. h$ L5 {$ Q3 E0 x6 @3 q5 }
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    / o) v3 m5 \, J5 m
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    ) i2 ^: q( f9 B, y" I7 V( G
75.                                         bsp_LedToggle(1);        
    % f+ e7 l& j0 b7 [; z) B- g2 d
76.                                         break;               
    5 w3 J8 j$ U; r# R. l2 X
77.                                 
    + }- ?, u6 ~1 x4 _8 |
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
      I- X/ T  |8 b$ n# S- W
79.                                         printf("按键K2按下\r\n");
      S$ k4 n# k0 J# ]% }  F5 f
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    1 Y: N3 Y0 A+ W5 f! z
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    . F; M: x+ y8 N- t3 Y7 S6 z; B
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    + z4 r% \4 f/ }7 ~
86.                                         break;                                
    ' \6 R2 H) q; I" z# C$ |) S
87.                                 
    8 a" W- q, s! ]0 j$ Y5 P% q# Y
88.                                 default:
    , K; ~. y+ S9 Y1 L  M4 G
89.                                         break;
    
90.                         }
    
91.                 }
    ) H- _3 o; p7 h( w2 E
92.         }
    4 l. T8 J9 p9 i" w2 q& f4 b- }
93. }

复制代码

30.8 实验例程说明（IAR）
, |+ a" b% e8 J8 o% C( a' v" J配套例子：
8 y7 Q2 k, `, J7 S1 J5 |# ?
% P8 u! p# ]% XV7-015_串口和PC机通信（驱动支持8串口FIFO）
) m: r9 z' C7 Q1 o* c& l2 ~3 m, }4 m
' ]/ v2 y2 l6 F5 E0 Q$ c+ Q/ K8 s0 H实验目的：
学习串口与PC通信。
( l6 S" _- r/ M8 y+ r; y
; [9 y/ i9 E) B- }4 ?- f
实验内容：
8 s7 V' _( K9 ^9 c" n+ v7 r. Z( ?启动一个自动重装软件定时器，每100ms翻转一次LED2。

' ?$ u; f  h' X# M
实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
) O; r7 L7 o/ r; l5 S串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
& Y3 C( n8 z0 Y串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
( w. U$ y/ J" D% U" X! q* D3 T4 HK1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
! N, R# W# U5 j- T- dK3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：
3 C7 p  y  v9 W
/ J' z6 T$ j! |+ i波特率 115200，数据位 8，奇偶校验位无，停止位 1
5 U; E- P: {& r! e- R

程序设计：
" G* `/ x$ [" F1 y( b* G6 A
7 e( Z: o; v) S4 L1 {: H9 d   系统栈大小分配：

2 v2 ]5 y: K, |: h8 Z
" N, x* I6 ~/ Y+ M" L   RAM空间用的DTCM：

5 N, k# @+ k! i: Z8 `* `1 K1 S  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
8 s+ {* O$ ~& r2 D$ j1 }

1. /*
     y3 Q& o, w3 F* s% Y
2. *********************************************************************************************************
   " t3 `$ B3 D6 e
3. *        函 数 名: bsp_Init
   : c1 F0 x7 w0 y. W
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   , q% H0 D; S/ d2 ~
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   7 D  E& C  s4 q  i
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    * E5 _2 J3 y- S9 x
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    $ u6 T9 y! B% [% E" h
17.         /*
    * q+ @$ i# X6 m+ ~
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    1 e7 [3 F4 {) i* `% y+ k
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    % W+ Z2 p. J4 _8 q
23. 
    
24.         /*
    3 H* q* ?) v' Z3 F" o. j( M
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ) ^4 f  g' T: i4 _: B
28.     */
    
29.         SystemClock_Config();
    0 V# y/ `5 E( r" r
30. 
    
31.         /*
    : \* A& h) L7 ^' q+ b
32.            Event Recorder：
    * U9 n: M  |* O2 P
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    # u2 q/ M% }4 ], ]  t8 [$ v
35.         */        
    ! u5 l# `( ^) s* i- O; m
36. #if Enable_EventRecorder == 1  
    8 f- ^7 \2 u3 b( p9 k, j* o- h
37.         /* 初始化EventRecorder并开启 */
    $ s  c# M$ E  l) b( Y
38.         EventRecorderInitialize(EventRecordAll, 1U);
    1 F( w6 ~; n- O& S" P) `8 n
39.         EventRecorderStart();
    ! ]( h1 q1 L* ^( f: |% J
40. #endif
    8 Y$ ~% i# K6 H: ^
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    : x$ c$ r# f( K5 h: {# K$ Q
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    4 N3 u$ A. L$ b0 O, R' c
46.         bsp_InitLed();            /* 初始化LED */        
    0 x6 p+ E" ?& s. e$ O. b  Q
47. }

复制代码

6 l6 F- l# P5 y: K# Q  MPU配置和Cache配置：
1 [- i0 p: o, |& ~
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
- A6 C4 F5 V4 Z' f: k
9 \+ c6 i" w+ r

1. /*
   ' \) U/ l2 P) X4 C- B6 {' \$ S* R
2. *********************************************************************************************************
   3 p8 P' V9 j- V) P+ g; c' \
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   % `) n2 m' C' I8 q' b* C
5. *        形    参: 无
   . v: I% w, n3 X  u$ Q* D5 J4 W
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
     b" }" M( M6 m" U: i- n
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ; u( x# Z9 r% |/ k- |$ ?% n, }
12. 
    5 Z) ?* x/ K- H* j
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    8 |3 j# V# E6 w7 }( u2 [3 o6 w
15. 
    , T: v) F" F" I# e
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' L& \: u! K, G4 r% e* }
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    ; }% h0 t' F1 I6 |) a' w
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    7 {( v$ z* u8 Z  \2 k8 p. [6 h
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    * I5 V. I" A5 Q' ~9 x1 k4 [
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ' e" ^' X( H4 l- P
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    7 `5 h" I- P* g8 p. ?7 ]* ?
31.         
    - d. D3 p1 }! h; ~/ v' M7 \; y
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 @6 h. M) `* H. C
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    # R* K# ?0 }) N' T
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ! n' U+ }: i5 E4 Y" R0 u7 a& `; m
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : T) m4 ^! q/ b. I6 a
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    9 E9 z# l" v$ [0 V7 i
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( R$ T7 Y: ~% K0 ^5 u5 P: N
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ) n( _0 I2 g, w
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    # ]  h8 f4 a4 |$ c9 u1 z
49. }
    % H$ I! y5 N& Z7 K( v5 a* @/ ?
50. 
    * Q4 i" b% E: |( q! G
51. /*
    3 Y0 \$ _0 @7 e: t
52. *********************************************************************************************************
    " W8 n8 u% y, ]% `& @2 c# v, j
53. *        函 数 名: CPU_CACHE_Enable
    : R6 |- L. Y1 r5 J. R/ X8 G
54. *        功能说明: 使能L1 Cache
    0 y; F5 J( A: f/ S7 O
55. *        形    参: 无
    6 L' U' b9 W0 I
56. *        返 回 值: 无
    1 c/ m, V9 R% p" y3 a
57. *********************************************************************************************************
    , g  \/ z( l- n
58. */
    & T) Y2 S, V3 S' X1 x; h6 W: _. N; B
59. static void CPU_CACHE_Enable(void)
    
60. {
    * ~4 e: v8 f1 e4 c* C( Q$ z$ x3 a
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    ! m# Q. u# A0 F1 m' I0 L; n
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    ' G; q% W+ u& \$ p6 I) o
66. }
    & c4 Q9 T( ~  G
67.   每10ms调用一次蜂鸣器处理：
    8 s/ h; V6 E! P" q
68. 
    
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    
70. 
    
71. /*
    ; t  y: \2 v) e* {/ A4 }7 X
72. *********************************************************************************************************
    
73. *        函 数 名: bsp_RunPer10ms
    ; |+ R: M( @) C4 x; {: q# a
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    0 I- @) i0 M. }+ ~- K4 h/ @5 G6 i
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    # A/ R2 ~8 p& `% r0 g' l2 [$ Y7 o9 F
78. *********************************************************************************************************
    " s# i. N9 v6 a/ }
79. */
    
80. void bsp_RunPer10ms(void)
    
81. {
    
82.         bsp_KeyScan10ms();
    
83. }

复制代码

  主功能：
$ a8 M( ]8 w# ~  d
# {0 g8 y4 W$ v6 L5 o3 Z主程序实现如下操作：
+ m4 n& s& c! I- o! `) L1 J# o
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
8 `7 @8 n5 q; t) ?2 Z4 O  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
) A$ B  w' `$ `0 {) e

1. /*
   2 t0 M$ w1 ~8 {) e$ N" E) P$ T
2. *********************************************************************************************************
   5 q) Z3 K6 H6 m, ?
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   # N6 e5 R% X. z( z+ e6 p5 m
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   8 `/ w5 O# i/ Y+ _. y
9. int main(void)
   ! B* L/ G, a. s, Y
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    4 q; |+ A, `) o
13.         const char buf1[] = "接收到串口命令1\r\n";
    
14.         const char buf2[] = "接收到串口命令2\r\n";
    7 J7 T# g/ H& r; w4 T% j2 E
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    
18.         
    3 T& g& X, Y+ {: f2 v6 r
19.         bsp_Init();                /* 硬件初始化 */
    ' \0 o0 {: Z6 v: _# P; G
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    * C4 K5 e6 |9 l0 v% b$ E9 t
25.         
    
26.         /* 主程序大循环 */
    - t' D( z' G/ a: A
27.         while (1)
    8 u8 @$ {( }) B/ N" n. }0 o
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    ; G" \# `6 H4 y6 w0 H
31.                
    4 j) Y. u. C1 P3 A; W4 d
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    1 x  o. Q1 r% {9 _: _% T9 \+ T
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    / u/ g! @. H8 e6 ~) U
38.                 }
    
39.                
    , k5 N3 ^( [4 X+ }; N  l: N
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    + \# Q, b; V& w; u1 U8 S8 }0 g
44.                         {
    
45.                                 case '1':
    4 n4 @6 V4 D6 Z4 d) i
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    0 v! c( q" W# Z5 B2 q+ W) t& l7 U
48. 
    5 r4 ]1 w+ v$ |' P# V
49.                                 case '2':
      h- o2 s2 \- A& }3 s
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    + O1 f9 x8 b+ Z9 `9 ]6 l& c
51.                                         break;
    / I. |. f: {( V9 ~$ |1 ]/ S$ \
52. 
    
53.                                 case '3':
    + U9 O7 H7 x! W7 @& M  {" {* E
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    
56. 
    5 f0 \. u& ~6 o6 }5 e
57.                                 case '4':
    8 ?& n- a8 P7 O# ~0 B
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    1 [% M+ ]2 D! c$ {) I: w
59.                                         break;        
    
60.                                 
    / A. p  U$ J  h( F# W3 }
61.                                 default:
    
62.                                         break;
    5 v, B7 C- H' u+ }9 z: i0 J) S8 v
63.                         }
    3 Q& m9 d; B9 A7 }" x5 Q8 q
64.                 }
    
65.                
    ; j* y) }- k4 a; M  g7 S
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
      j4 L% g4 P: s9 B0 S
69.                 {
    1 W5 t& L$ T: d8 u# h9 n: q2 z) v
70.                         /* 有键按下 */
    1 |4 E, C4 V& t* o6 R$ M7 A
71.                         switch (ucKeyCode)
    
72.                         {
    # h. b- N, f4 J8 x2 E! j
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    3 t' J  Q# p2 A9 }' N& |
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    ) c3 p3 F$ x3 b6 Z0 C
76.                                         break;               
    
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    6 Z7 a+ i& N" }' D; T
79.                                         printf("按键K2按下\r\n");
    ( N0 V, D) j' v
80.                                         bsp_LedToggle(3);                                       
    8 t$ m3 h4 r5 o0 U5 Z
81.                                         break;
    ) f  s6 R& O2 x0 t5 }7 F6 C4 ^
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    $ F( d, Y( F5 A+ E
84.                                         printf("按键K3按下\r\n");        
    ) r/ d& W8 z4 P. S  D9 c, r
85.                                         bsp_LedToggle(4);        
    4 J$ Q+ @2 @9 `3 X1 x$ ^
86.                                         break;                                
    $ k* J: c! @- u, U, }" H6 }
87.                                 
    
88.                                 default:
    % x# z2 J+ z, L( n
89.                                         break;
    
90.                         }
    
91.                 }
    
92.         }
    
93. }

复制代码

30.9 总结
! n$ p1 g& u) L本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
' p  {" j; d" m  c6 }
. [( X, L# r- ^& d1 X8 _/ F0 T! a+ z

2 r4 k+ n" a. {, [* k( k  O
) v2 m! b4 i3 X  G3 P) f
" Z0 h8 a  `0 F  z1 H$ s5 v                                                                                                                        
- Q3 o& b; x1 N/ E