30.1 初学者重要提示
学习本章节前，务必优先学习第29章。
串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
/ [0 |" |! P5 C2 W; n3 G7 t' h( A/ B8 h/ t本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
, i( w: t# h" I: j; Y大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
CH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
! t5 k+ t4 H( m! X! h+ t2 X/ j30.2 硬件设计
3 t- S" \  _8 _* t( o3 O6 kSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
  c' Z- O  P% [7 H6 w, P
5 P% ?8 o) s, K+ j5 i+ `% D串口USART1  TX = PA9，   RX = PA10

串口USART2  TX = PA2，   RX = PA3

串口USART3  TX = PB10，  RX = PB11
' R& W# @- j+ x4 T0 c
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
, X7 M) q1 m  W' b
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
# @7 J1 q+ V3 ?- j6 X
4 j( s1 ^& Y: ^7 x, \串口USART6  TX = PG14，  RX = PC7

" V0 V, L5 F* ^. Q串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

2 @  x1 ]0 L/ W  L7 C串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

STM32-V7开发板使用了4个串口设备。

串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
串口2用于GPS
) ^- t) ]' P+ v: |% K) h! Z串口3用于RS485接口
串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
* f$ t% q8 f' X1 C, r. m下面是RS232的原理图：

" U* Z8 {; }$ W

关于232的PHY芯片SP3232E要注意以下几个问题：
9 A! k9 t' M  l
SP3232E的作用是TTL电平转RS232电平。
电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
6 v8 J) J* r2 M0 o: \
5 `5 q) k4 p( G8 s( k

/ c8 H8 [5 k+ p4 B
实际效果如下：
5 s: W; k$ U: r* z7 I9 y8 @0 E% H
+ s. P7 ~' I5 s, n' ?" U

8 |+ ^" Q) d) F+ v' F
0 n" [( s, Y- i; Z: E9 f; e" s2 |通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
" r/ [2 ^7 l6 x, T, a, {
由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
2 Y9 B4 j* z! c3 E3 p$ A检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。

30.3 串口FIFO驱动设计
30.3.1 串口FIFO框架
为了方便大家理解，先来看下串口FIFO的实现框图：
1 y# B1 ~& P1 J, ^6 c

6 g: k0 O  o6 Y: _! A) x# s+ Y
第1阶段，初始化：

通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
; [; a4 G3 m# m6 h; {第2阶段，串口中断服务程序：

7 i2 M+ k6 w6 A* Y# y2 H接收中断是一直开启的。
做了发送空中断和发送完成中断的消息处理。
( J( j6 ~6 J/ n0 s. b$ x第3阶段，串口数据的收发：
4 h7 m; ?" v! \9 y  j" j' n7 M8 o
! f" o+ W7 X8 u  ^8 E5 O( Q/ N串口发送函数会开启发送空中断。
4 W. e* n! H7 I3 _  q# H串口接收中断接收到函数后，可以使用函数comGetChar获取数据。
" [5 T3 d3 q! W; L6 I$ T7 B
30.3.2 串口FIFO之相关的变量定义
4 b8 z( m9 h( n- S5 y; i串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。

每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。
  u3 J9 X. P8 J+ A

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if UART1_FIFO_EN == 1
   
3. #define UART1_BAUD                        115200
   
4. #define UART1_TX_BUF_SIZE        1*1024
   ) ~8 ~1 B4 _6 g
5. #define UART1_RX_BUF_SIZE        1*1024
   3 |/ ^) a+ ^- G* \6 L
6. #endif
   6 I  Q. b4 s( v" S9 T  I. d" C4 a. f
7. 
   
8. /* 串口设备结构体 */
   7 y' F1 h' y' u# p
9. typedef struct
   
10. {
    
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    , `* E* x$ x4 r, j+ N2 w. C( x
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    
23. 
    
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    # Y: p) X* X0 ~. _8 `& [
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    . ~1 G- J6 w# m3 ]$ G- f# X
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    9 ?9 m0 w# {" W. m$ z" V
28. }UART_T;

复制代码

bsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。

4 A- V8 O7 [3 Y( e. z

1. /* 定义每个串口结构体变量 */
   
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   
6. #endif

复制代码

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

30.3.3 串口FIFO初始化
串口的初始化代码如下；

4 }7 z1 v4 b+ `, N: _# S

1. /*
   % \# p  \& y& z( G! k
2. 
   ; Z% q+ W6 f' g* z( U* u9 K' i
3. ---
   
4. 
   
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   % Y4 q" @% ?: K
7. * 形    参: 无
   
8. * 返 回 值: 无
   
9. 
   $ E1 X( i5 e" l
10. ---
    
11. 
    & p" n' D9 I+ e0 a5 l
12. */
    . {; V2 R0 T) ^% ?2 L! z
13. void bsp_InitUart(void)
      W; J2 `3 m' o, M6 [2 E$ j
14. {
    ( n0 {+ F; K# ?7 `2 r4 J5 b+ r3 h
15. 
    
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    ) l7 W2 i  e0 }$ T; ~* I! H
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    # o+ X5 a# Q  j  t+ C
19. 
    % ]. m( `- V& {/ q
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    ( a0 |; X4 a. p  n( j2 A
21. }
    % h3 y9 L/ ^7 V9 ?: E% s1 Y

复制代码

. N7 I+ O9 R* b: U2 @下面将初始化代码实现的功能依次为大家做个说明。
. N0 ]1 J: p. _1 I: h
函数UartVarInit
+ T& l9 p& B/ B: ?这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

/ J9 T% k* @" T, F

1. /*
   
2. 
   
3. ---
   
4. 
   
5. * 函 数 名: UartVarInit
   6 N4 F5 {  S+ P% @+ I3 a6 ]2 Q; _
6. * 功能说明: 初始化串口相关的变量
   % g6 `& R6 e% K  Z
7. * 形    参: 无
   , v4 M& N9 m# B# m6 x  n' O" @
8. * 返 回 值: 无
   
9. 
   # E& ?, a9 V0 M0 w5 B+ O" r
10. ---
    ( ]  F, j1 ^* V1 {9 c
11. 
    
12. */
    $ `5 X1 E, s, h* Q* t5 y' c+ e
13. static void UartVarInit(void)
    
14. {
    
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    " v- L; p$ x5 ?1 }9 R, k% k# _4 W
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    * ]6 ?: X$ W& P* {! {$ d5 m
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    & N9 ]& m; w0 t) U" E
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    ; |3 E7 E9 O4 d# m
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    , y. w* r7 @- |  H$ N
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    " y  R5 n8 X% U/ O: F0 o! n, Y
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    8 e8 j( m3 {4 m5 D* e
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    . K7 I5 R) i! f" {
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    % F0 R6 B* Z& F  F5 u
31. #endif
    ; B" k3 _+ \9 o1 r. f
32. /* 串口2-8的初始化省略未写 */
    % F" B4 `& O3 y& S6 c
33. }

复制代码

函数InitHardUart
此函数主要用于串口的GPIO，中断和相关参数的配置。

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   7 O$ O) o9 ^) o9 p
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   0 I5 J* o! A1 y5 G
3. 3.        
   
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   5 ?+ |, ^4 }: Y% [$ o7 G
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   ) c% F, G3 P; `8 y7 c" ]
8. 8.        
   7 V9 M7 c8 B- B8 ]8 E! u/ s6 c
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   6 R  y* h- m# `! \" x; _
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    . ~7 M, h: y: b, u5 b- }
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
      W$ t- m7 h; q2 t  D6 ]
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    
13. 13.        
    , H7 P9 @3 }! w* ^5 |8 D6 ?
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    & m) }% r+ u" W/ \% A! t) s1 e
15. 15.        
    - t# K" x% D0 r+ \$ }
16. 16.        /*
    
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    1 o1 ~. I% `$ x- y# T
20. 20.        *              发板
    
21. 21.        *        形    参: 无
    9 C' X4 E# R4 E# k5 X* A
22. 22.        *        返 回 值: 无
    ; n& I, C# ~+ T" ?
23. 23.        ******************************************************************************************************
    * b6 F! L! U8 c# D# M5 d! e0 b1 Z
24. 24.        */
    " E9 v- g; y. C8 |
25. 25.        static void InitHardUart(void)
    % B" ]- e% I6 ]; E6 T
26. 26.        {
    3 I3 r4 g7 m! N8 j$ L
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    , L" g7 f$ J6 \$ {8 K' H0 h, y
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    " a# U9 `7 \1 o8 `* I0 E; T; W  H
29. 29.               
    ! a9 P! m2 ?# |( Z: d
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    - }/ n* |% w- m- @2 f4 {! `4 [
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    % ]2 D" I7 t" ]$ Y4 @  r2 F5 L# m
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    / M9 Z. V, Z4 |$ I, Q6 }
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    ) ~, Y! U& z; D/ G
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    8 p4 E- O  [$ k+ K1 _& V
38. 38.        
    8 n/ ^7 X* k" b5 Q  G3 Q5 B
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    4 `1 G% s( a0 F  M
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    2 v7 y0 A3 c- U' b4 P" O7 Z6 g
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    ; g# |2 F+ `' m, W# P2 _9 _, [
43. 43.               
    
44. 44.                /* 使能 USARTx 时钟 */
    4 G7 {: f3 d: o1 |
45. 45.                USART1_CLK_ENABLE();        
    ) b! Q$ Q7 ~. G7 c: b' w
46. 46.        
    1 _( a+ I5 f5 Q/ K& t7 M9 w, H8 w
47. 47.                /* 配置TX引脚 */
    / @: ?! R" j+ m/ p  r
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    # Z5 b: z$ m# m+ C; `
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    & R5 r8 B, e, @) R
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    0 n# w6 [6 r/ O( [4 K
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    ' g- O) l' m  U/ o( ^$ F  `# ^
54. 54.               
    / x% q' y+ Z. f/ I1 a* ], A, [+ X1 }
55. 55.                /* 配置RX引脚 */
    
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    % S) w. Q% s& S& A$ x% c# N
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    , E& E. L5 T7 w/ Q: A. X$ i7 ?
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    , [7 G- `/ n2 c. \0 P7 y
59. 59.        
    ! |1 c" J# Y9 Z; `  d& s2 _
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    ( J- Z+ U% t7 f
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    / R5 v; ]5 f: Q4 E
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    , Z% Q8 c: Y6 g* g0 m5 g
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    ' Q/ o  f1 v+ A) l  S
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    6 A0 x4 c9 d# N5 V( c
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    : l+ X% f' X+ B
71. 71.        #endif
    ; x' y- v6 u$ J- g' @" I# d
72. 72.        /* 串口2-8的初始化省略未写 */
    
73. 73.        }

复制代码

1 T7 j/ k& G) o) ~5 p第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
- `: c: i% P% k" D4 v第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
5 {. i$ N- i% `& ?5 {' L3 e( B                                                                                                                                                
, j) Z8 w5 g5 I, D' u7 T0 Q5 b

1. /*
   ' b9 s: B, c" S
2. *********************************************************************************************************
   1 U3 B% X7 w" y# b& F% f0 e0 j2 L( {
3. *        函 数 名: bsp_SetUartParam
   + @- _$ y, g, `9 P0 _. z! @
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *        形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   9 Z) A: x( Q. K4 l4 [# E: ^3 p8 U6 r
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    6 \: u) |& L! t8 n+ }# \
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    
15.         
    3 F. o0 ^" _. P0 E" _
16.         /*##-1- 配置串口硬件参数 ######################################*/
    ( u4 p# P+ n2 @5 O8 P2 H% J
17.         /* 异步串口模式 (UART Mode) */
    ( T5 V1 Y9 I* Q
18.         /* 配置如下:
    : r/ ]- ]3 W  i( P$ J, c
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
    
21.           - 校验    = 参数Parity
    
22.           - 波特率  = 参数BaudRate
    8 i; P4 n) ^/ s+ C6 q7 s6 P8 Z# |
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    
25.         UartHandle.Instance        = Instance;
    
26. 
      Y, Z: _' e3 y
27.         UartHandle.Init.BaudRate   = BaudRate;
    
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    ! W  e/ ^2 `. {- ?5 `( H/ e
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 u5 V: U0 S1 T
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    # O6 @9 ]8 x4 t' c) \
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    8 J; d2 y5 b$ c1 B
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    : J, d9 D/ E; r
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40.    
    
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
42.         {
    2 J( R2 o0 q! m* L3 N
43.                 Error_Handler(__FILE__, __LINE__);
    2 m( L$ e, {, b+ O/ d: b6 J1 w
44.         }
    
45. }

复制代码

5 V" _, K7 k6 j函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
' u8 E+ ?, O* A( |' ?
: |6 s7 V. n1 c: `& W

1. /*
   
2. *********************************************************************************************************
   1 v9 J: g: `7 m1 U1 r
3. *        函 数 名: RS485_InitTXE
   - h# T6 v! u2 S# \) y
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   - @$ G' w  I0 K* H6 j) ?1 m
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   1 _6 n+ d" p0 G, ~( ]9 u
9. void RS485_InitTXE(void)
   1 n2 p' X" ]7 i: r' b- T. T
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         
    * ^- {1 b! V/ h" G/ @5 r4 M0 c4 }2 }
13.         /* 打开GPIO时钟 */
    ; A+ N" f8 z' W# z& `. q4 O; T: M
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    5 T, h% p4 N" C5 \4 K0 ~! U: s
15.         
    
16.         /* 配置引脚为推挽输出 */
    8 u% V5 D& D0 X$ V. K" t5 d
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    " J" T4 [+ r; l: X+ ~
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    4 I3 W0 g+ z0 a. h2 i( u/ K
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    
20.         gpio_init.Pin = RS485_TXEN_PIN;
    0 l  K0 }9 N) j+ q/ v3 l
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    . D: ?7 q% d9 ]$ g6 k7 T2 c
22. }

复制代码

; O: V0 P+ |" d6 a$ q30.3.4 串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能

收到新的数据后，会将数据压入RX_FIFO。
, L3 Q* O' L. G: U0 |% d6 J7 `检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
/ h" g8 t$ B* ]2 K% A
下面我们分析一下串口中断处理的完整过程。
' {5 j2 Y1 w, A/ _( R当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：

1. #if UART1_FIFO_EN == 1
   ; i8 K1 q6 p  d2 f
2. void USART1_IRQHandler(void)
   
3. {
   ! b$ e: T3 H: f1 V- I
4.         UartIRQ(&g_tUart1);
   
5. }
     N+ v5 q. z+ [$ ?
6. #endif
   
7. 
   
8. #if UART2_FIFO_EN == 1
   ! U( R7 o+ s3 W6 Z7 M
9. void USART2_IRQHandler(void)
   
10. {
    ; G* D. A# D) d
11.         UartIRQ(&g_tUart2);
    6 z2 F5 b. g" o/ j4 J
12. }
    
13. #endif
    . g5 g' Z# R7 S  M
14. 
    
15. #if UART3_FIFO_EN == 1
    + v  e0 z) {+ a# l) q4 G% |- _1 G
16. void USART3_IRQHandler(void)
    4 I( {9 f. ]1 @# T9 @+ V
17. {
    
18.         UartIRQ(&g_tUart3);
    * g/ p, T* M, U9 G; S; k* S* Q
19. }
    2 @( O. G; v2 Y- z  A0 O# i
20. #endif
    & |9 y0 z' u/ J$ m( j/ U
21. 
    ; {; r- P% z. u& K" N6 X
22. #if UART4_FIFO_EN == 1
    
23. void UART4_IRQHandler(void)
    3 j) r. t6 E  T6 I. B
24. {
    + U6 F- H4 p% K9 g& G1 h- u
25.         UartIRQ(&g_tUart4);
    ! I- d- p1 i# U. n0 O
26. }
    
27. #endif
    6 X% x( o' p2 ?1 f) V0 l7 I
28. 
    % Q% k% u' ~6 O2 t( {
29. #if UART5_FIFO_EN == 1
    5 ?( P  \: N) t. x7 y
30. void UART5_IRQHandler(void)
    6 m  G+ f% f4 r9 ^7 n5 _3 b& c9 _) E
31. {
    5 \  ^5 y' |# `  {# o
32.         UartIRQ(&g_tUart5);
      C3 e: z; b, g
33. }
    
34. #endif
    
35. 
    
36. #if UART6_FIFO_EN == 1
    1 O( g2 l0 ?' V$ M( B8 @! ?
37. void USART6_IRQHandler(void)
    
38. {
    
39.         UartIRQ(&g_tUart6);
    
40. }
    " c, P- p0 G4 Z. ?
41. #endif
    
42. 
    
43. #if UART7_FIFO_EN == 1
    , |  M, n& E, D( W2 m0 J
44. void UART7_IRQHandler(void)
    9 t- @, B. o7 w6 d& S. o3 _$ h
45. {
      j2 q0 b, u- h) ^" V2 x4 K- i2 z1 Z
46.         UartIRQ(&g_tUart7);
    
47. }
    
48. #endif
    ; x) k4 C  u; D5 u3 |' q
49. 
    
50. #if UART8_FIFO_EN == 1
      `, c) P9 Q! ~2 |7 b
51. void UART8_IRQHandler(void)
    ' M3 [2 x' Q& I
52. {
    
53.         UartIRQ(&g_tUart8);
    
54. }
    
55. #endif

复制代码

大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。
: G* v4 g# Z" ?
下面，我们来看看UartIRQ函数的实现代码。
1 }+ g* q8 `. \# A% A7 ~! N

1. /*
   5 c& z# i  z' y; t6 Z
2. *********************************************************************************************************
   5 I/ C0 F: J9 E
3. *        函 数 名: UartIRQ
   & I  r# S. r2 u
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   # f9 S0 p. k6 K5 }+ R# N' L
7. *********************************************************************************************************
     o2 u# m, x$ Y9 O0 H6 a* L
8. */
   # x8 _" V+ ^5 p- v9 K5 g
9. static void UartIRQ(UART_T *_pUart)
   6 W! T, w+ V  i5 L
10. {
    1 r/ a1 d& w9 @' K4 K
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    " U3 o( G4 p3 ?# Z' t- T5 [
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    " A' T8 h& t+ {" `$ J4 s5 r: k
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14.         
    ' H% w. @1 Z1 Y- n9 p& Z5 j
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.                 uint8_t ch;
    
20. 
    * x& m9 d3 g5 V: f4 D
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    % k6 |4 C! u  a+ v, m
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.                 {
    ; ~9 |3 N, K0 ^8 A  g/ P, K6 u
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    ' r+ A2 w, \; x1 W1 y
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    ! y9 Q' F  l+ C8 q, q: p
28.                 {
    : o# ~* j& e/ i9 L1 r4 ~5 W& M5 i
29.                         _pUart->usRxCount++;
    
30.                 }
    " p; @4 R  ^8 ]2 x2 y  {
31. 
    
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    ! R3 ~3 Y7 Z, C1 [' B! V6 U
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    % F$ h- d4 i5 e8 i8 X% w8 `: y
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    
36.                         if (_pUart->ReciveNew)
    1 c" Z& {1 T& a" V1 w1 L7 K7 @0 L
37.                         {
    
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    ; S& E  C( y- T# X1 L' i: o
40.                 }
    3 k/ ^$ k) p! u6 y
41.         }
    
42. 
    
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    & }2 |* H3 Y0 C: Y
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.                 {
    7 T: \# a, y* k# W
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    - k2 n4 f1 Q- p1 F( S
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    2 p/ Z+ }% a. i5 D
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    
53.                         /* 使能数据发送完毕中断 */
    : x) l& r( N* R) @7 z
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    $ v' ?4 J) b, i9 E* g! X
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    , Z  w* X8 {% \$ V" W
56.                 }
    9 u2 A6 Z; \. V
57.                 Else  /*　还有数据等待发送 */
    
58.                 {
    5 b# G: f# Y  `( R# y' N4 `
59.                         _pUart->Sending = 1;
    : ^9 S2 n; \8 `" W3 D- Z5 f7 o
60.                         
    
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    # Z0 y( |$ u/ E
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    ( u* b& L* N, R5 j
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    ; @, W. j/ W' Z# T
66.                                 _pUart->usTxRead = 0;
    # Q8 c: e4 @5 F5 R% e
67.                         }
    # Z( `$ m7 x8 f3 o( h
68.                         _pUart->usTxCount--;
    * [9 d5 S0 F/ {$ P: `
69.                 }
    
70. 
    
71.         }
    
72.         /* 数据bit位全部发送完毕的中断 */
    4 y1 ~% H, \: F9 R( C8 E3 P% Z) Z
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    : f* S8 M% W" U; h8 P4 b
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    # D3 s/ x* s1 }) g6 M* w
76.                 if (_pUart->usTxCount == 0)
    
77.                 {
    
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    ' a7 l! j. H9 Z: J
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    - L! @' z+ g- U$ Y" s9 V. D
81. 
    
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
      ]/ |1 M3 g, `  l4 y; t- _
83.                         if (_pUart->SendOver)
    
84.                         {
    3 [5 Y% o$ V9 R8 p/ A
85.                                 _pUart->SendOver();
    7 [% ]( ?! M( I/ L+ ^4 g4 h
86.                         }
    
87.                         
    0 G" q1 h! S0 I9 ^3 U
88.                         _pUart->Sending = 0;
    
89.                 }
    
90.                 else
    
91.                 {
    * K# y6 L5 p  j
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    1 F+ B& }' [8 f- Z
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    7 O% i+ o; y! R5 Z' l; r
98.                         {
    
99.                                 _pUart->usTxRead = 0;
    6 [7 w: o% S; u; f
100.                         }
     2 ?+ e5 H" @- ^/ E
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     " Y" H; l. Q: _+ Y* s( ^
104.         
     7 U7 M2 B4 O% ]7 i6 z9 T
105.         /* 清除中断标志 */
     8 H' Q+ c( W" J
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     ' |. z1 U* D7 d
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     9 r0 j3 ^3 j7 b% q6 s6 C  Z! V
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     - }( g! U$ |2 p% E2 M
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     1 v: w6 l8 q  L* J! o2 z4 ^" b9 Z/ y7 U
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     & B0 L/ H* X3 t
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     3 J# @- {  R4 G3 g
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     ) y6 g1 N3 ^) Q
117. }

复制代码

; v) T/ T% U; u( L# O6 E2 ^中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
$ Q# a  X: ]2 A3 w* @! w
  接收数据处理
! b* f# M2 ~0 P" m9 C接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
) {  _9 F3 V9 f1 k+ s; g! s  M3 K7 h
8 B" ~& t1 }! U* p  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   ( `, Q2 U) F" |
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   1 U# K3 D  P, \. j* b
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   - h7 U& p9 P4 H, g* \
6. *                          _ucaBuf: 待发送的数据缓冲区
   5 E+ V+ ?5 Q# }. D0 T
7. *                          _usLen : 数据长度
   
8. *        返 回 值: 无
   
9. *********************************************************************************************************
   , Z' C! ^& b" \# |/ z0 W
10. */
    
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    6 h' U7 W% V" U" r: C+ K
13.         UART_T *pUart;
    
14. 
    
15.         pUart = ComToUart(_ucPort);
    
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    / t9 f3 ^% K0 ]: D4 o' V* @, o1 ]
19.         }
    
20. 
    & Z+ V) o0 X. p$ e. h0 X
21.         if (pUart->SendBefor != 0)
    
22.         {
    
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    $ i/ t6 @) M+ [- j
24.         }
    + K+ o  L% S4 t+ I7 |% }
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    / [( E- i: E" Z& T( }* p- f
28. 
    ' K" b' f: k/ M: d2 J5 E3 w
29. /*
    / X+ ?2 Q# G3 p5 O! H
30. *********************************************************************************************************
    6 L9 W! L% `  s- p, \
31. *        函 数 名: comSendChar
    
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    0 _$ P  J) w0 b' [1 B% ~6 q) z
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    
34. *                          _ucByte: 待发送的数据
    * {1 U8 H2 M: ]( h2 y/ `
35. *        返 回 值: 无
    * e/ h) J, W5 z  P2 W7 f1 C
36. *********************************************************************************************************
    
37. */
    / K! I/ c9 t7 B8 H2 [( Z
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    & n8 }, I! K" t) f; S" O9 a
42. /*
    + ~" P& ]4 T) T; }) `& F- T
43. *********************************************************************************************************
    % g* G3 o0 j% Q2 f8 y
44. *        函 数 名: UartSend
    , ]  ~2 ]1 A' O, c5 N
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    
47. *        返 回 值: 无
    , E0 E9 [, F$ N; B2 b/ B) t2 X
48. *********************************************************************************************************
    
49. */
    / b' B+ p5 F2 P/ y/ }
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
51. {
    $ `3 s( M6 s7 I4 J* R! H
52.         uint16_t i;
    
53. 
    ) D$ o& [, G4 d8 I3 T+ }
54.         for (i = 0; i < _usLen; i++)
    
55.         {
    
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
57.                 while (1)
    4 J; o" H6 v* M/ }' w
58.                 {
    
59.                         __IO uint16_t usCount;
    
60. 
    * f' b2 R4 P9 L
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    
63.                         ENABLE_INT();
    
64. 
    . [# q# K. r7 y( P* S% `) m
65.                         if (usCount < _pUart->usTxBufSize)
    * h- [$ ~; j) M9 r9 f! u
66.                         {
    3 y: {7 s# j" x# R& y- r: ?
67.                                 break;
    
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
70.                         {
    & f6 K/ Y+ {3 [) Q1 Q. r3 S1 f
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    , l3 h) A) [7 Y! e
72.                                 {
    6 r2 C! u+ ^5 @" R; z2 C
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    ' m; Z' Z1 F/ f4 t* Y7 W) `, [
74.                                 }  
    
75.                         }
    " d# M) Z& @8 F3 b& b
76.                 }
    ) R1 J# s1 I  \& A7 `+ q
77. 
    7 O6 C/ O# e* l/ j8 b
78.                 /* 将新数据填入发送缓冲区 */
    
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    
80. 
    
81.                 DISABLE_INT();
    * G- R6 S# N' Y6 i
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    
84.                         _pUart->usTxWrite = 0;
    
85.                 }
    " S/ {/ ]4 H* I9 c7 Z
86.                 _pUart->usTxCount++;
    
87.                 ENABLE_INT();
    
88.         }
    
89. 
    % K1 Y# q9 z; @; P4 O
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

: l/ z# k% n* a  v1 \/ G函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

% d- n# c. j4 y: D7 N, I8 i; v  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
6 l3 ~' ^# v4 _$ g) A8 |. a2 k  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

- Q4 i+ `# f/ Q% P' ]2 E2 T注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。
5 [0 d% S; _7 P, ]8 i/ H
+ X! _# J# S* x函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。
; M4 [) l8 w" m; h  h

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: ComToUart
   6 t+ W7 g+ C' r! A! p
4. *        功能说明: 将COM端口号转换为UART指针
   1 N0 f* Y5 s9 l4 B' h3 m2 e: @
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   0 e2 r, {1 r) T9 r+ f1 {
6. *        返 回 值: uart指针
   8 _% c+ i& u/ E& W% ?0 g4 k
7. *********************************************************************************************************
   
8. */
   # n3 l* h: L& e6 E( \
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   3 v6 f% H% m3 ], ~/ f$ M1 G0 b3 _6 G
10. {
    & S& s4 d! v# @9 w. `- t1 o
11.         if (_ucPort == COM1)
    
12.         {
    
13.                 #if UART1_FIFO_EN == 1
    % |% r1 h6 C% R5 D
14.                         return &g_tUart1;
    / Y% E+ E$ q* {+ f& E2 i
15.                 #else
    
16.                         return 0;
    
17.                 #endif
    
18.         }
    1 U7 c/ E  w# h3 J5 t, s% q
19.         else if (_ucPort == COM2)
    3 t0 ~( e$ A% |! M8 x4 B
20.         {
    , z* X! [% R" s! Z% N& G- y2 Z
21.                 #if UART2_FIFO_EN == 1
    7 s+ {1 E' N( V5 Q
22.                         return &g_tUart2;
    
23.                 #else
    # |4 x3 ?$ U; @
24.                         return 0;
    
25.                 #endif
    ' M) U7 X3 O2 y8 C. W& v
26.         }
    
27.         else if (_ucPort == COM3)
    ) f+ s& e7 u9 }
28.         {
    " W( I, v$ ~" K" N" S7 T2 |: _
29.                 #if UART3_FIFO_EN == 1
    0 J7 C6 Z! M0 N8 R: b0 T
30.                         return &g_tUart3;
    : E3 W. m, Z( B+ m( R, C4 j' W7 I7 f
31.                 #else
    $ P5 R3 P! v" A1 N( V
32.                         return 0;
    
33.                 #endif
    
34.         }
    
35.         else if (_ucPort == COM4)
    , D. V  [: ^. h
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    
38.                         return &g_tUart4;
    
39.                 #else
    
40.                         return 0;
    8 e& t* _# D, i! `3 q/ y) }. J1 k
41.                 #endif
    
42.         }
    * O" c- c! l" o8 t
43.         else if (_ucPort == COM5)
    + r+ f5 G) M8 c" {" _& |
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    * z% |* V/ z. Y9 x
46.                         return &g_tUart5;
    : i" b$ f( l4 m1 A# Q
47.                 #else
    " [+ A+ ~, @3 q' d" l- y, i; c# q
48.                         return 0;
    
49.                 #endif
    1 T" W! G1 w% e& [6 ~  x( @; _
50.         }
    6 b4 v" J5 Y/ r4 a
51.         else if (_ucPort == COM6)
    
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    , k, W+ R+ T" k$ X" i4 p
54.                         return &g_tUart6;
    + Z/ ~$ }& J" R5 D4 M, Z
55.                 #else
    % ^2 ~/ f2 j+ k7 m
56.                         return 0;
    
57.                 #endif
    
58.         }
    6 E- t) v) h! k( D- }1 @3 i* h0 R1 Q: b
59.         else if (_ucPort == COM7)
    ! C& I. o8 a2 ]8 \2 N
60.         {
    ; V+ V$ V" _1 I, T) L3 M
61.                 #if UART7_FIFO_EN == 1
    
62.                         return &g_tUart7;
    
63.                 #else
    
64.                         return 0;
    
65.                 #endif
    
66.         }
    ! ~4 r1 E+ o. w
67.         else if (_ucPort == COM8)
    
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    
70.                         return &g_tUart8;
    ( Z& V$ M' j( ^7 J# G
71.                 #else
    
72.                         return 0;
    
73.                 #endif
    . F# z# b7 B/ @# e/ {4 Y0 C
74.         }        
    
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    . \; l, @3 I" [) u& m# R- k* w4 p
78.                 return 0;
    * j0 T0 y% ~! |4 J. l
79.         }
    % g! ]) T, y9 N9 M
80. }

复制代码

30.3.6 串口数据接收
下面我们再来看看接收的函数：
* ]& D/ r- i0 v) x( J. A! S
4 ?; p" F" j8 [3 Z+ K

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comGetChar
   ! U  p4 r) ~$ f, k9 }* Y
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   + s4 s7 i. ^; D( z; L5 a4 ~
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   $ {5 \) f# a5 r; y; y- V
6. *                          _pByte: 接收到的数据存放在这个地址
   
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   1 y0 K0 L; M/ K
9. */
   & v) h0 ~- `; N6 K
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
      \; Q3 x& p9 m) n: a0 V3 G
12.         UART_T *pUart;
    ; p: n6 c8 j" {% d
13. 
    
14.         pUart = ComToUart(_ucPort);
    6 u5 o, D5 a: E& G& \( k
15.         if (pUart == 0)
    
16.         {
    
17.                 return 0;
    8 }' E6 @( U/ y  U
18.         }
    
19. 
    ' l' V- }8 K$ A" i$ N" y" F; P+ |; q
20.         return UartGetChar(pUart, _pByte);
    ' i5 R+ t& K/ `$ D+ Z
21. }
    
22. 
    ' i2 R% u5 [2 [" u
23. /*
    
24. *********************************************************************************************************
    
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    + n3 W9 t/ {# x0 t7 ~* y( P7 d# T
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    9 p0 s- \1 P" M) P' g
31. */
    7 a8 ^" Y9 v4 w! N  d4 Z
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    4 J/ x$ G( Q: X& t; t3 y9 v
33. {
    
34.         uint16_t usCount;
    
35. 
    / B  H1 x7 B/ B
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    % y. Z% x3 @' \, e* e- r- o
37.         DISABLE_INT();
    / [+ |. A1 P2 \( |! c& z
38.         usCount = _pUart->usRxCount;
    
39.         ENABLE_INT();
    * r; _5 ?, u  y1 I) M% a
40. 
    & s5 v( h" J* I2 d6 O* P5 d7 G
41.         /* 如果读和写索引相同，则返回0 */
    4 l; W2 E; K7 q" [* {$ J
42.         //if (_pUart->usRxRead == usRxWrite)
    
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    ; P8 X/ `8 ?+ p. N' q1 t
45.                 return 0;
    , v7 e% M: x1 [7 g2 j+ ?8 E/ \
46.         }
    
47.         else
    
48.         {
    1 v9 K, ~- Y5 s' X; w. Y+ |/ L5 p2 P
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    ( n" L+ c$ G# T) v
50. 
    
51.                 /* 改写FIFO读索引 */
    
52.                 DISABLE_INT();
    
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    3 G' s" r; @8 Z
55.                         _pUart->usRxRead = 0;
    
56.                 }
    : Q# V: V7 g/ K& X: X
57.                 _pUart->usRxCount--;
    
58.                 ENABLE_INT();
    . L/ j; ^6 t9 m: l% h
59.                 return 1;
    
60.         }
    * o9 @& C& p; H
61. }

复制代码

函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。

  q$ K/ w3 Y3 U6 I" j) ?注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

30.3.7 串口printf实现
3 P1 F7 H  B9 Z: V- x$ _4 w& iprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
1 v( p9 Q) R4 u0 T' {& Q$ z. P
8 r7 f8 U% `$ \% I" R( v' O( Q, l为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
( x5 c3 v4 C* z! H) M9 }# e
6 @! E  S+ E% f" q- f# J我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
; p# _% y$ {5 [  R
2 i6 b  W! K. o$ K& @实现printf输出到串口，只需要在工程中添加两个函数：

' h  ]5 [; y$ G% t1 c4 r8 D

1. /*
   # }, Q8 x! M9 w0 Q3 q& t4 ?
2. *********************************************************************************************************
   
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   5 D, {4 d% u, w) _; r
5. *        形    参: 无
   
6. *        返 回 值: 无
   * r$ W4 e+ a) }0 n+ b9 V/ R
7. *********************************************************************************************************
   
8. */
   
9. int fputc(int ch, FILE *f)
   
10. {
    
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    4 a( h3 N( I8 s+ {0 t
12.         comSendChar(COM1, ch);
    
13.         
    
14.         return ch;
    2 s0 n% C2 V8 z- w
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    , q! {6 R( }5 W, m) @
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    
18.         
    4 s3 ]1 b; K5 G; ^7 W7 i( O3 x
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    
21.         {}
    
22.         
    
23.         return ch;
    * t5 l$ g$ W+ K4 i
24. #endif
    
25. }
    
26. 
    / F; I$ ?- y7 o
27. /*
    
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    ) V4 ?4 X" h; X+ G5 D; m8 u
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    * U6 @3 _6 i9 L6 p) C0 W$ J$ j
35. int fgetc(FILE *f)
    
36. {
    
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    : @, j( X' e- I' m1 A
39.         uint8_t ucData;
    : s8 A. k* u- o/ t
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    
42. 
    
43.         return ucData;
    % P3 j2 |1 h. m
44. #else
    
45.         /* 等待接收到数据 */
    3 j8 A1 Z2 `5 ?! a8 r# H
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    
48. 
    , Q1 x! e3 \, {' t3 c, F5 ?
49.         return (int)USART1->RDR;
    * g. S# x5 e; q  ~$ z" a
50. #endif
    
51. }

复制代码

& t" y$ t3 X; o# k$ f, c1 {, L- yprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
% P& m2 n# F0 N- M; H
" n# w( Y6 W* n4 L30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
# h( M8 C% x! S串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

  bsp_InitUart
  comSendBuf
  comSendChar
3 G: b# Q& N9 q  comGetChar
$ e" l, C' [# U4 a30.4.1 函数bsp_InitUart
函数原型：
% s7 T2 M- N) p7 e: s9 d2 c2 l" g! tvoid bsp_InitUart(void)

函数描述：
此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：
2 l$ F# a( L, Z, G) v% F+ u串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
5 ]* e5 J0 q/ p, z3 J
30.4.2 函数comSendBuf
函数原型：
" r+ T0 u' X$ R7 `/ x1 L  P+ c% ]0 Bvoid comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
" w9 D; V3 E9 Q, u  u6 _
7 ~) S9 f  B6 \, ~8 O; u
函数描述：
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

" A5 l( M1 @, S9 ]" y函数参数：
9 M0 G+ J( P* G, q+ M  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
* X! d# D) @7 g& ~9 ^7 P
- E: Y3 z, P- r* r7 o( F( b
. H; g5 B- N% e( z4 I% E: w注意事项：
' I' q( ^7 A6 a. P$ S+ b; r$ K( P  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
# ]% V  k, o& Q1 Z

6 W! n  }$ c6 R( }% i& ]) ~使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
2 Q1 S( p  M' {( R
  Y4 H5 N' A- |1 |" ]" Qconst char buf1[] = "接收到串口命令1\r\n";
comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));

- J* m# w8 v* _( ~9 |$ m9 j$ U
4 s/ R9 l, V" i% f% _3 P30.4.3 函数comSendChar
函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);
# G& M- }! Y; ?# n/ n1 f% q% C

函数描述：
  _7 f: C! Y& B8 e: B1 G
此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。

" w4 U2 d& x& s. Z8 T! E函数参数：
6 h" \# o) `5 V* g# Z& G3 f8 D  第1个参数_ucPort是端口号，范围COM1 - COM8。
7 y1 |% i% r. \) u- e# T  第2个参数_ucByte是待发送的数据。
: O2 F1 Q1 K0 k/ U' {

注意事项：
  此函数的解读在本章30.3.2小节。

0 \7 ~( b% `4 \, [, n
使用举例：
$ r5 m3 j: h3 B+ @8 _调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
9 [- T- W$ O1 x: @, J/ Y比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。

30.4.4 函数comGetChar
函数原型：
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)

! v$ |& n/ f' C( X
, F( Y! s' e( C, Q& q函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
: n2 }  Y" N/ l- B# o& e" g- P/ N7 Q
  O7 Q1 D8 }) N+ X8 u函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
/ d: E( u7 d" D0 u  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
( z9 d3 D% O; \' @' g/ V

注意事项：
  此函数的解读在本章30.3.6小节。
5 A: _9 C# w/ ]! e

3 K  J3 T( @) t! G) Y: Q$ D( |0 q使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：
1 f2 ^. J! b8 `- d5 N
0 c+ D& [' G1 n  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
' T0 a( W1 U/ A! G( E" ?/ m9 J

1. #define        UART1_FIFO_EN        1
   
2. #define        UART2_FIFO_EN        0
   ; P% k( @, `  X+ j% h; `5 D
3. #define        UART3_FIFO_EN        0
   ; z8 z7 v3 `6 S, Q5 r0 s0 ~
4. #define        UART4_FIFO_EN        0
   # y$ w# _$ [1 }! a9 ?
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   2 {' ~! m$ M6 n
7. #define        UART7_FIFO_EN        0
   
8. #define        UART8_FIFO_EN        0
   
9. 
   # ?3 Z; D" A2 Q
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    
11. #if UART1_FIFO_EN == 1
    0 h0 r8 i6 w, a* w- V9 s) v6 I( J
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    , u. n0 E; ^+ X$ ]1 Y) ~- D
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    
16. 
    8 M6 {3 P7 }" g* Z1 H
17. #if UART2_FIFO_EN == 1
    $ l6 x3 ?% d  q  x" _0 H
18.         #define UART2_BAUD                        9600
    , C9 g7 A$ I- m" h; H8 _* _
19.         #define UART2_TX_BUF_SIZE        10
    + @- C4 M! y# i
20.         #define UART2_RX_BUF_SIZE        2*1024
    $ R3 ]$ e; g8 i4 l: V$ i5 K( Z
21. #endif
    5 O5 Q, @" X+ ^0 y/ P
22. 
    # I5 |- ~' Z+ g, P' f
23. #if UART3_FIFO_EN == 1
    
24.         #define UART3_BAUD                        9600
    
25.         #define UART3_TX_BUF_SIZE        1*1024
    
26.         #define UART3_RX_BUF_SIZE        1*1024
    
27. #endif
    $ _$ H- Z* s. C1 H7 L6 g( x+ m: w" a
28. 
    
29. #if UART4_FIFO_EN == 1
    
30.         #define UART4_BAUD                        115200
    6 Q8 D- e% z( f+ s  u; G8 T( J
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    1 K6 _; f1 G' B! P6 O( c2 v
33. #endif
    0 K) d9 J$ ^+ t& ]# x
34. 
    ! a% d0 `1 y8 w! L/ p
35. #if UART5_FIFO_EN == 1
    # y5 H; w$ i( l/ m/ W! f- m0 _: F$ s  ~. H# K
36.         #define UART5_BAUD                        115200
    
37.         #define UART5_TX_BUF_SIZE        1*1024
    , _6 L4 y) x) z
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    
40. 
    ( Z) X( H8 s- ?$ Y
41. #if UART6_FIFO_EN == 1
    ( h7 _* Q- m, K( s7 V
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    ' K8 e6 c& F& ]7 a" r  C9 `) q" ]
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    - R! ?6 m9 Q7 p: h6 Z! b
46. 
    $ m6 j. e) R* i9 J9 L# k
47. #if UART7_FIFO_EN == 1
    
48.         #define UART7_BAUD                        115200
    2 _- E8 J9 l$ B
49.         #define UART7_TX_BUF_SIZE        1*1024
    8 v: m5 r7 J9 q- B4 _# ?
50.         #define UART7_RX_BUF_SIZE        1*1024
    7 X% l: [* |1 v
51. #endif
    6 U  e4 s% q4 y" K+ A: \* k4 w2 d
52. 
    
53. #if UART8_FIFO_EN == 1
    / w! \9 a9 V7 i# R: ~7 g6 A
54.         #define UART8_BAUD                        115200
    / c$ m3 e5 |* B( A' {8 V8 w& K) c1 e% `
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    ' M) e# f+ p. p* Z  |7 J4 y
57. #endif
    & F) M, C8 v6 F6 N' C$ v$ B

复制代码

2 O  p/ Q" i% {: p
: U0 e8 }% V5 S  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
. U1 f5 g  W) n6 y; ?$ y) m
8 v1 G2 v2 `/ P30.6 实验例程设计框架
; j1 f  _& Z' H& r& T通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
! T$ b, w9 F+ }$ q; J" j. f1 w
/ K. p1 m# G5 W  [0 D' E" W: |

% ^7 |: \6 N/ m5 t  第1阶段，上电启动阶段：

; `' E& A4 U; b: e4 ]2 G( x这部分在第14章进行了详细说明。
* w% w& o+ k$ V* u9 w  第2阶段，进入main函数：

4 h; [. F5 ]* D8 a5 F  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

8 Y. u# G! X0 v6 R( h1 I30.7 实验例程说明（MDK）
/ V% ~+ g, T& Q配套例子：
8 }4 S* W. i9 q, B- o+ L: n/ d
V7-015_串口和PC机通信（驱动支持8串口FIFO）

实验目的：
学习串口与PC通信。

9 ?8 E$ n* Q4 ^! \
实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
/ J4 k+ w+ h4 r6 p4 C

3 i/ K' T3 W( k( b' k实验操作：
$ [6 M$ G2 [+ w% A1 h串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
6 {1 ^1 C7 r( N" ~* V& E串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
; T4 C* Q) B( G2 p8 S6 K: ^. j串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
& C( K6 r# Z" A  t$ e8 ~K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
+ _- i! _* z/ L0 m  A- CK3按键按下，串口打印"按键K3按下"。
) ]5 N# ]- Q. @+ O: ^1 c上电后串口打印的信息：
9 e" C! w  v. v
波特率 115200，数据位 8，奇偶校验位无，停止位 1
* K9 v9 _9 C2 K: C/ H0 I

) A1 p- U' m5 U; v8 g3 k
, O* Y# o2 h! f" ~5 t4 K, k程序设计：

  系统栈大小分配：

$ [% O$ m1 h! o3 n. P) K

  RAM空间用的DTCM：

0 G  h4 S" ~/ l* g* c
8 ^  c7 r3 r' ~8 H( l  J  硬件外设初始化
3 l5 x% ?) A* C) a8 h
/ C4 b5 C% Q+ {$ v9 Z6 D硬件外设的初始化是在 bsp.c 文件实现：

) i: d. {& G0 f

1. /*
   8 O! P" P7 R" x3 b! b! J3 f
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   2 k% [' \2 o& j6 ~1 J( @- B9 x$ M+ }
5. *        形    参：无
   . k7 g* `" p" s) V- l
6. *        返 回 值: 无
   7 X6 f% Z3 r0 w6 b9 j
7. *********************************************************************************************************
   / [9 H2 N" f9 R
8. */
   
9. void bsp_Init(void)
   , D! k; P- }% {3 Z' M2 U4 y
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    1 J5 o- J0 K; x
14.         /* 使能L1 Cache */
    ' k3 O! _% l/ U. E% u6 \7 X' c
15.         CPU_CACHE_Enable();
    
16. 
    9 A: f# B9 O) {2 r& A: ^  h% t
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ( y% D; i4 J0 l% c) o- n
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    & i, S  q( x9 E$ b- L3 I
20.            - 设置NVIV优先级分组为4。
    1 `4 N- H9 q" V! l
21.          */
    5 i. T/ w' f" x' n3 Z4 J
22.         HAL_Init();
    $ @+ D9 R2 C& R* h, v' M2 Y6 M
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    , U/ q0 h) z9 h5 f# C
26.        - 切换使用HSE。
    ; O+ P+ n8 I6 B8 M# o
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    : R4 b$ o0 s, L& N: F1 i
30. 
    ! I- @0 @! s' ^/ ?: b. n& r
31.         /*
    $ X+ W4 t( E0 d+ O
32.            Event Recorder：
    ; \/ E% ^3 U4 @4 A6 Z: c  s2 u
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    % O$ Q3 x. A" O4 ^: K
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    2 M  V( R) {) r6 j" Q4 Z6 O
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    # {  T+ r1 S* b2 f% t  _+ u. F0 U
39.         EventRecorderStart();
    5 i6 X7 C) ?; I# ?
40. #endif
    6 s) i- Y3 d1 f; R7 J
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    ' a6 _  P/ N; i+ `
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    8 c% M4 Q- ~% e6 [' I, ~. }
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
: Q" }9 Z$ i9 {$ u

1. /*
   7 |6 f* F# p8 {
2. *********************************************************************************************************
   : L3 Z; x/ m9 S* u
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   6 h' H4 k' q  R6 P1 g+ O3 y
5. *        形    参: 无
   / g8 W  ^+ Q! o" r/ j
6. *        返 回 值: 无
   
7. *********************************************************************************************************
     Z. o+ x* a9 k& T0 m7 F; `: H& e
8. */
   * ?1 X9 Z  j$ h9 F1 Q/ H* o
9. static void MPU_Config( void )
   1 n! f8 v. f7 B4 \, k0 u
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    * ?2 e8 B4 {/ |, r: q: ]; Q) ^6 [
14.         HAL_MPU_Disable();
    6 v; ]8 ?6 X9 u  h5 w' [5 D: u. Z
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    ( L8 D1 Y. [% m$ c$ k/ `
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 ]* I3 N+ y2 ^6 p  \9 t
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    * e# c& E6 l# l
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    - p+ E* u+ i/ ~. |
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % C9 }1 q+ x+ Z* [6 z9 \. y3 A
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    & {0 P, {( l1 U- }2 }! |2 v
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    % `, v8 m2 f/ d& K+ r1 X
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ( i* Z6 `  V( \# s/ {1 r
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    0 V) O; Q8 j/ A3 k8 H  m2 K
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    - ~. T6 B" P$ H# h
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    . A4 _. s3 v; }$ H% B! b
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    * W6 k3 i2 O- t
42.         MPU_InitStruct.SubRegionDisable = 0x00;
      Q  F$ |2 D/ t: m7 {+ T
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 C$ R* x) l9 f, Z) z+ b
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    7 {4 m% G3 F: s/ K. }% Z0 \
47.         /*使能 MPU */
    ; n- e0 g4 H6 }2 e" B) n
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    / W3 K+ @& P6 O& u
50. 
    + F- l9 z2 B% H6 F3 M6 Y, i% g
51. /*
    9 d% j0 S( A& f; ^6 W7 R2 J: t
52. *********************************************************************************************************
    ' l; Z8 y4 ^& h8 p; |/ g1 |
53. *        函 数 名: CPU_CACHE_Enable
    : |+ N5 T' D- m, N4 n
54. *        功能说明: 使能L1 Cache
    ) r' O8 H) I* y+ P; Q
55. *        形    参: 无
    - q2 O5 w4 F9 Z! X  A/ s7 C) [
56. *        返 回 值: 无
    ' e6 j# w. o- X. Q
57. *********************************************************************************************************
    : _9 c1 S/ S( `, X8 K
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    : I. K: w3 ?, a) [! C8 ?: q
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    5 v* Y: a7 h: G6 `% ^8 e" {4 j3 b
66. }

复制代码

9 K; E, j; ]% N: c( G. l( ?! D  ~  每10ms调用一次蜂鸣器处理：

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

( D8 G. ?5 \# ^9 B/ s

1. /*
   7 g4 a; H, Z# o* z1 d
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   3 Z- @, _# [% ]$ w; K; Y) m6 c
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   2 [; A% a/ \4 Q$ d1 y. P
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
     `8 u7 n% N$ C' D6 z7 P: `
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    + v9 Z0 ~! W3 s1 \
11. {
    # f) [, G3 L4 V" H+ s$ f  E) h
12.         bsp_KeyScan10ms();
    0 Y' x  D  t  V; p1 F4 d
13. }

复制代码

4 [; t7 |! Z/ Q: \3 I  主功能：

# V: Z, n! S" C2 `6 a8 c0 B主程序实现如下操作：
: i7 ~$ n1 x/ Q% b# g) V- l
4 Q7 \. W+ h( e3 v) v+ f$ T2 Y  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
9 g, B# Y- N) V+ C. ?  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
) ~& Z7 N' z7 H" ~( \- l/ F, F* z' P  K3按键按下，串口打印"按键K3按下"。

1. /*
   $ x( V+ |% l! y" i0 V- O
2. *********************************************************************************************************
   0 `1 H! f- o4 I" Y5 b
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   / U  s. B. g3 m3 S& `8 i/ J
7. *********************************************************************************************************
   3 J2 W' G- O* L. N  g
8. */
   ; J4 @; O' ?* r+ ^
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    1 ]0 Z- e7 _2 C6 V
13.         const char buf1[] = "接收到串口命令1\r\n";
    " u2 R9 q1 O6 ^1 @0 }3 e6 n
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    ' A+ U+ j: S+ G) u0 G7 l- M4 V
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    , l% g4 s; q1 T% D, }
18.         
    . ?- c" k; d- z* D7 g) s% h1 n
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
      |9 c' N- G6 O% T$ z) l
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    % W/ y% o! U2 f% C2 D
28.         {
    # b& q$ [! [% P: Z/ f( q# z
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    / {/ _0 T6 }/ {4 e3 e
30.                 bsp_Idle();               
    & q- V# K4 D0 v' W
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    3 q  T' X2 i5 M- }" o1 @& X. h
36.                         /* 翻转LED2的状态 */
    . q0 J8 k3 S; S; t  M# m
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    ( E7 m0 A0 b8 u" k. v- b
44.                         {
    ) k1 I# [1 w) D3 U% c. u% L
45.                                 case '1':
    ) d6 l$ Z8 {' b3 V2 B4 L8 d
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    3 v. P6 d( u& }0 i
47.                                         break;
    
48. 
    1 i3 ~- \: O/ d
49.                                 case '2':
    7 C# a% e8 j" n6 A5 C3 N
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    # ~# Z' Q- {" S* }8 N5 b0 W
52. 
    # ]4 n& Y! _* W6 h5 k# U  f5 R
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    . d# J( G9 b  N% `7 P0 h0 M! A
56. 
    
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    ; |4 J0 j9 }0 L0 ?- V& F
60.                                 
    
61.                                 default:
    
62.                                         break;
    $ a; D& Z' ~+ X2 F
63.                         }
    ' d) C! z* R# L9 G3 t
64.                 }
    
65.                
    " @2 I. ]. p% L- L6 b
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    + b6 G& j0 V. ^2 |
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    
72.                         {
    " D$ l, x9 K+ f
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    2 ^; ~5 y/ J, ?; R( O, F! C
74.                                         printf("按键K1按下\r\n");
    7 V3 C/ b' x4 W/ U) u. H6 r
75.                                         bsp_LedToggle(1);        
      j1 U# t: e1 L4 G+ M, R
76.                                         break;               
    9 v9 t3 Y+ m) j
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    6 o. g" Q* ~' y3 q
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    : O* L! e. Q3 c
86.                                         break;                                
    
87.                                 
    
88.                                 default:
    
89.                                         break;
    , p0 C; B2 F1 J2 O$ A2 f  R
90.                         }
    
91.                 }
    4 i% _6 p( s; `3 E, W! N5 A2 j
92.         }
    - e* m8 |. G5 I# T8 H
93. }

复制代码

30.8 实验例程说明（IAR）
9 f. a* Z# H3 [1 L9 I7 ?配套例子：
' s8 w( M. a: ~# |* f4 v1 k
; ]  M3 l, ]9 fV7-015_串口和PC机通信（驱动支持8串口FIFO）
( r" `0 V& p4 F. U1 y5 F; h0 b. I
; M9 M* C$ y3 R/ M实验目的：
学习串口与PC通信。


! s+ G  A0 a( ]2 `& x4 ]  w- o实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。


0 a9 \- _6 o( i- Q实验操作：
" }0 I. x6 ~4 P串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
. T# s, ]5 l1 }串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
; n( n3 V' Y5 u( w) S; l5 cK3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：
+ _) U4 N3 u3 h9 A* X4 K" d
8 H7 m2 F$ F) G* u波特率 115200，数据位 8，奇偶校验位无，停止位 1

1 v( W0 L2 D  f1 G. b8 l7 K

3 w! L  X. K$ F  Q% F  T8 y! t程序设计：
7 T6 x1 ^. f& n& E$ g" Q
6 q0 m1 l4 j$ I1 S   系统栈大小分配：
7 u; s" K6 }2 |1 [

* J! X2 g1 ]+ q
   RAM空间用的DTCM：
' r; }- \+ W1 ]5 H, S5 c& I
9 \9 g4 N- N+ A

  硬件外设初始化
" u' L  O- ~3 J. }$ P2 y
# R  ]2 l8 N+ O! V1 i% e" f硬件外设的初始化是在 bsp.c 文件实现：
, N. Q0 ?0 v0 T4 A  A
. A( s: l3 ^: [+ G& I

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % p- |0 h& e, r9 T6 h
5. *        形    参：无
   " X# o& ?3 B7 e) n) f& ?+ F0 Q
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    % S  M9 y- s7 V' o
13.         
    . l; L) }  R% a  O0 Q
14.         /* 使能L1 Cache */
    3 s+ q  h0 B6 b+ M; G% n6 ]
15.         CPU_CACHE_Enable();
    ! ]) }3 ~% z* x8 }8 w7 |
16. 
    
17.         /*
    / {" U' E/ n2 j- F4 \1 x$ @; q
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    2 v& @+ z0 I/ z# b% W6 L' j
20.            - 设置NVIV优先级分组为4。
    
21.          */
    ) F, m1 f- F: c; _1 l+ z
22.         HAL_Init();
    6 h. Y5 M/ R" O
23. 
    1 r1 `$ e1 Z8 V; T1 u* c. q, D
24.         /*
    
25.        配置系统时钟到400MHz
    / C3 }- Z4 B% u
26.        - 切换使用HSE。
    ; A9 O6 g4 p  `
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    0 N( O) R; ]) ^. D- H- {
29.         SystemClock_Config();
    ; b; t0 J$ g+ _& X4 ^/ @" |
30. 
    + B( a' I- h. A5 L% ~5 W) E" x1 Y
31.         /*
    - Z+ d, a3 p' Y  W
32.            Event Recorder：
    " r. B0 W) y. r  V. p
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    5 l: F) f' t( M8 l, p
35.         */        
    * A# D- ?) F. ^; k0 c! {' r! W
36. #if Enable_EventRecorder == 1  
    & G  |5 _8 \. R2 [( h+ _4 T9 H7 t
37.         /* 初始化EventRecorder并开启 */
    6 q7 r- I, C1 ]3 G
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    " q4 H$ d: ?' w( c
40. #endif
    6 @2 |1 w+ U: j, i
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    2 G8 h# X3 q& U" d- z  ~
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    ' [* Z$ a8 J5 E4 e
44.         bsp_InitUart();        /* 初始化串口 */
    7 d3 _3 S; f6 Q! J. [$ {; C
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

- n3 M- c, X5 k- B  MPU配置和Cache配置：
$ g. o! C6 q, k; E
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
5 ?5 l: D. |- ^4 v% U; W- t

1. /*
   + U( E& H/ {* o
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   ; ]: a8 d$ ^, R& S
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   6 L* n- A: o1 Z$ `
8. */
   " J" f+ q$ G8 O; V- o0 r5 i3 ^+ g! [
9. static void MPU_Config( void )
   , A( I. I$ }1 O; z1 s4 Q
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    ! t( F) Y: a* b3 d' ?
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    6 |- U# ~  {5 w0 t, D% k5 H
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 U$ \4 R3 X% O2 N' a: y; [
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 Y, m+ ~" k: h& `
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    6 ~1 q5 r9 D+ m! g, p
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    5 ]% R7 Y$ I" \1 X2 X0 P( Z4 ?
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! q! p% r6 M- Q* ?! _9 D
28. 
    8 F/ J( y' S& {+ M. c( F
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    . |2 E4 [/ e/ j% C; t) \5 K
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' I- S+ P$ r2 I  ?# c
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ! {9 i/ I2 H' n  ~5 v
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ) i2 T  t5 M% r4 t- D; |
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    8 ^7 d. Y3 Q0 k2 _+ L- M1 S9 D! y4 J* u
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    $ y9 R' V( \. @6 ~- A" T
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
      y7 L9 ?/ T+ S, J* e
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    6 b' m! _8 `# R; l
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 @9 @7 V  u8 `# @! p/ H
46. 
    
47.         /*使能 MPU */
    6 d+ t; f# @* L* R$ I& t/ g
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    8 D5 G0 r6 ?4 j
49. }
    8 N; [6 f( f. u
50. 
    # s8 t1 T# [, b% ^7 P* m
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    ) {, H  E: k( R
55. *        形    参: 无
    / }- W0 C( _8 Z/ A* K* B9 e5 g
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    0 n9 E  R' |8 ]# z5 c
59. static void CPU_CACHE_Enable(void)
    6 P9 l" t9 B+ Z3 M, C% f
60. {
    # I7 j. p6 v2 M# b1 L
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    4 ], M- J5 C2 Y) A' s5 W. T+ |
63. 
    
64.         /* 使能 D-Cache */
    , X8 K% G% F/ |" J* X- |+ ]
65.         SCB_EnableDCache();
    
66. }
    
67.   每10ms调用一次蜂鸣器处理：
    & B! p# g) e: E1 P. {/ z
68. 
    : p! P0 X: f! F( F3 l
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    ! k& m  c/ [% v5 Z0 Q  P& V( @' L# E0 n% F
70. 
    / u& p, i% z# A6 |6 a
71. /*
    
72. *********************************************************************************************************
    ! b! j' l6 V, ]
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
      n- Y9 o# a" Q5 a
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    4 q4 `' L( n1 q, p* r
76. *        形    参: 无
    6 v  |+ d, |% W- P# J8 |
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    5 T3 T) {7 c0 w! F
79. */
    * }* c: u6 e; {* X, r. f
80. void bsp_RunPer10ms(void)
    
81. {
    9 @/ x9 _9 a% m7 l% ]+ x  [
82.         bsp_KeyScan10ms();
    : I/ Y# k  S9 g. y
83. }

复制代码

: t: A4 G& H' C% Y# H; c  主功能：

+ s7 D6 ^: k+ C5 x; }主程序实现如下操作：
  @% @8 x- x% p- K! c- r
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
( ]' q0 k' {+ g: }5 Y( V6 B  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
' [/ x; @9 w  w2 b0 }! ~! Q  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
; E/ ]/ j5 @6 |/ [; z  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
+ f- x' n" B! A6 x! B

1. /*
   5 H) w3 [- h/ q* p6 x0 S
2. *********************************************************************************************************
   % A$ d/ x! f, d. c/ F# w" M
3. *        函 数 名: main
   ! {; B. H2 ]- [* k
4. *        功能说明: c程序入口
   5 H% `) A  j2 Q* K
5. *        形    参: 无
   ! w, c/ O* h+ F1 e8 v+ y, u! S
6. *        返 回 值: 错误代码(无需处理)
   - `: t5 G  Y- O) ?! g
7. *********************************************************************************************************
   2 z+ ~. o7 O8 k1 ~) h. l
8. */
   
9. int main(void)
   
10. {
    . F2 O# @/ [  q4 E
11.         uint8_t ucKeyCode;        
    4 _( e/ l/ ^* [) h
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    2 g# ~, u; I. x: ]
14.         const char buf2[] = "接收到串口命令2\r\n";
    " X5 Z5 @5 ?* a
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    & ^: y8 p: T4 |( G
17.         
    # ^9 F  V% @! ?2 ^! U
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    5 d  r: j' O/ H) w- v
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    ) j* ?8 C8 Z2 C( X2 _
27.         while (1)
    # T# k9 v7 ?2 w5 `
28.         {
    4 f- d) h- J9 D9 d8 B. ~
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    1 _1 @2 v2 D9 F# C# ]; o  w" \
30.                 bsp_Idle();               
    3 s& p! G2 W  s% p9 D& O
31.                
    5 \6 n  V: P& @& ^- S* o
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    ; X$ v  S& }( V# [0 Z) \! x6 I
35.                         /* 每隔100ms 进来一次 */
    2 I$ m! ]6 B# Z/ C5 |
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
      }" X/ X" K/ _4 }3 U% e0 U
39.                
    
40.                 /* 接收到的串口命令处理 */
      M; Z4 T* t" W3 i+ @2 O+ n
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    * }0 P5 n6 D/ c" B  J5 a
43.                         switch (read)
    
44.                         {
    
45.                                 case '1':
    ( N& r7 Y2 U, J& T" E9 o" D
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    # l. }9 U5 ~6 a2 f
47.                                         break;
    ' V1 l2 ]& s  w4 q% Q# p
48. 
    7 H8 r9 o# }+ G( f4 i( K2 J2 _3 s/ u
49.                                 case '2':
    ; ], ^" ?2 N' _; x
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    - ~5 b) k9 b! B$ [! H
51.                                         break;
    ; y1 M& q1 X& T) [7 y
52. 
    
53.                                 case '3':
    4 E6 K( F8 n3 ^2 l0 O9 R
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    ; i! L, B( c' x4 H: |
55.                                         break;
    ) o- Y. b7 o& |" c" X" M1 {
56. 
    ( I3 X1 e. m3 F; M
57.                                 case '4':
    % }/ k2 S1 J1 L3 v" b, ^
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    $ @( B3 R; u* v6 M
59.                                         break;        
    
60.                                 
    2 O: l3 P: \) J0 \1 n$ i$ I0 u% U
61.                                 default:
    & h! y8 i* I( z8 b5 l; x2 C
62.                                         break;
    
63.                         }
    ) o6 u( t  \) ?# N; N4 T, }
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    9 e! n- M- |! U* D' w' }) b
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    1 Y, _: q4 Q1 Y% n- N* K
71.                         switch (ucKeyCode)
    - A, j$ b5 G; I
72.                         {
    9 B, b8 i7 I/ k" A" C4 J0 i
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    : x: i9 ]8 c  i. ~; [+ H& [
74.                                         printf("按键K1按下\r\n");
      J& ?9 W8 j% v! G; _! l
75.                                         bsp_LedToggle(1);        
    " c, i4 v  _2 b; i3 Q
76.                                         break;               
    1 W2 V% R) g- Y# @3 k/ l+ q
77.                                 
    4 h9 R! h$ i7 `
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
      u# M! b) x6 ~2 _8 a
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    - s1 A0 j4 M- E4 B
82. 
    . T/ i3 u7 M9 A; m, a0 f
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    7 f, W$ `. X  |
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    . O* u' r9 K: W) j9 U
86.                                         break;                                
    6 z: M- p9 F8 s
87.                                 
    
88.                                 default:
    
89.                                         break;
    
90.                         }
    
91.                 }
    4 t0 o1 `; g! `, B0 W" J$ E  U
92.         }
      Z, t8 P3 L2 x& G- V3 d
93. }

复制代码

" M) K4 l) c# H$ N# M30.9 总结
/ h1 M* p9 P! t8 `; c+ z. K, U# D8 h本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。

; t+ B  F- _4 i: e$ b8 W, r
+ P8 v8 @9 g! h2 a. e
) N6 C4 T' `4 m1 f, I