30.1 初学者重要提示
学习本章节前，务必优先学习第29章。
8 ~. S& U4 ]: Z; k串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
" |3 C5 [/ m- J8 U( N6 H, dCH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
30.2 硬件设计
STM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
! `5 R: g2 |# \& V# M5 y  i+ j! d
串口USART1  TX = PA9，   RX = PA10
. H. K/ @* Y' m8 P) D$ N0 E& K
串口USART2  TX = PA2，   RX = PA3

) ]# b. o& m, d) ^3 U- w' ]串口USART3  TX = PB10，  RX = PB11

% ~, w8 f% ?" g) r3 |5 L) f串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

串口USART6  TX = PG14，  RX = PC7
  X* E" n& c" N9 C; g% V
串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
; i* b+ S9 f1 |+ s  L! G1 ~/ h5 F
1 U- X2 @" ^& B6 m1 L串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
' D7 K  L2 B3 a3 u# j
9 [2 v& I* H) z  T  i6 ~: HSTM32-V7开发板使用了4个串口设备。

串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
串口2用于GPS
' D' G( ]' s, L- Y8 e! h5 ^+ B串口3用于RS485接口
串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

% d. h" e6 |. G% [关于232的PHY芯片SP3232E要注意以下几个问题：

SP3232E的作用是TTL电平转RS232电平。
电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

实际效果如下：

& J9 I1 ^  c" s1 t5 A/ Q

. z+ H' {$ H, z2 T4 ^! R! u通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
9 S: N( M2 h* \- v5 ]. E
由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。

30.3 串口FIFO驱动设计
30.3.1 串口FIFO框架
为了方便大家理解，先来看下串口FIFO的实现框图：

8 k" S8 G; T# p6 E

' Y0 Y4 U8 `2 _6 }
: U! \4 T# D5 c, ~0 i; L4 j第1阶段，初始化：

通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
第2阶段，串口中断服务程序：

接收中断是一直开启的。
做了发送空中断和发送完成中断的消息处理。
6 I* D% \3 }# z) v" Z第3阶段，串口数据的收发：

0 O( {, u  A: J串口发送函数会开启发送空中断。
! Q7 J; r* [5 e9 V& i/ F1 I串口接收中断接收到函数后，可以使用函数comGetChar获取数据。

1 U% s! Q0 C1 u% X/ a" Y' W30.3.2 串口FIFO之相关的变量定义
$ ^) V4 T% y+ _3 K7 ]; ?6 _串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

1 O# h" t- G) m4 K1 e5 m6 S' v这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。

每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
2 E5 W# f5 {3 M8 A
3 R) c8 \9 M+ e8 l. P我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

  g0 s3 N/ j4 Q$ J: ~1 q' \! j

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   ( {: j& @9 a6 ^
2. #if UART1_FIFO_EN == 1
   6 C& G1 f" ^" s* P% |. ~* f3 c$ v8 J
3. #define UART1_BAUD                        115200
   / z3 p; a1 C/ [8 U
4. #define UART1_TX_BUF_SIZE        1*1024
   
5. #define UART1_RX_BUF_SIZE        1*1024
   - J. K* L" L- m7 W+ X3 ?
6. #endif
   
7. 
   ( ^  I+ `, \8 T$ q% c: @7 B
8. /* 串口设备结构体 */
   
9. typedef struct
   8 K/ Y6 }7 o+ n5 O/ r' ^
10. {
    6 O. }& v: g5 Z1 r/ L3 |( @8 q0 O
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    6 V+ m( u" T( d5 `
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    1 G( i. m7 s7 z' [5 @' W
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    3 i& M$ F, `7 w: W3 Q
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    6 v7 v% s) S( b# _3 D
19. 
    4 C$ B9 n' m% \
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    ( o! V3 h( ^8 P5 I
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    9 d$ B  `- L4 A
23. 
    
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    8 }9 I. Y3 A, Z) ^) d' g
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    + {/ t5 K( Y! L. H; a( u* }
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    
28. }UART_T;

复制代码

bsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。
1 K5 A' f3 P7 r4 A
; @& J2 s7 F9 \9 i# h

1. /* 定义每个串口结构体变量 */
   1 J" s0 }- g: B# Z
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   $ X" G$ {! T, t
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   $ g( o  q6 h& {
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   & @5 q" e; }! l! M6 m! Y" @  ~0 T! A
6. #endif

复制代码

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

30.3.3 串口FIFO初始化
% E! q* s: Y1 s1 b串口的初始化代码如下；
3 ~1 h! K0 r2 H' L2 G. e9 B

1. /*
   2 `) O2 s8 W/ C9 u3 Q. z
2. 
   5 {5 V( U% F5 n% L, L
3. ---
   
4. 
   
5. * 函 数 名: bsp_InitUart
   % F) f& E; u1 {( x% d
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   2 e9 X8 e$ m! L
7. * 形    参: 无
   
8. * 返 回 值: 无
     A  H9 `- p4 m
9. 
   
10. ---
    : Y; y/ P! i; [- m/ I
11. 
    
12. */
    
13. void bsp_InitUart(void)
    
14. {
    4 _8 L$ p# e5 A! \
15. 
    ' J. r/ a* C; M  K1 e5 l( p3 w
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
19. 
    
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    + L& }! }; a' g5 H. `* t8 Q& i
21. }
    

复制代码

下面将初始化代码实现的功能依次为大家做个说明。
- Z/ T- e: s- [$ B! y
函数UartVarInit
% ]4 y; t$ x* s  ]) }+ c& P( C这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
7 I0 d  f% g0 @) d1 B6 X$ x1 A8 C- p
, e: I5 P' \' Q" j: x

1. /*
   
2. 
   
3. ---
   
4. 
   
5. * 函 数 名: UartVarInit
   $ ^# B+ |! f2 n4 d/ r
6. * 功能说明: 初始化串口相关的变量
   
7. * 形    参: 无
   
8. * 返 回 值: 无
   . ~, j. T' K# u* G
9. 
   + _" h0 v/ x. l0 V5 w7 x! L
10. ---
    ' A3 d1 p- l4 y$ z) u& S7 |+ e
11. 
    . C% s& @2 a/ `" i3 Q, t' B) ^8 j
12. */
    + `+ d9 J  i0 Q: p; _
13. static void UartVarInit(void)
    0 L; ]; t$ {) Q  q
14. {
    
15. #if UART1_FIFO_EN == 1
    8 {  V8 J2 |  g+ d0 H* u. R
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    4 I! V0 A( X3 N& b# }
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    + g: s0 S9 E! A0 d, d
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    2 K, I3 t, v+ n" y3 p4 }
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    6 d. b. a& b1 Z3 ~0 |6 f& W1 m
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    0 `2 V/ e& h" O6 P1 S
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    8 x& L' g* ]% }+ {9 Q$ r
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    " P2 Q/ ]. E8 u, b
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    / L. ^& ]8 ~$ S* f# z* X6 q
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    5 {, f7 T/ l/ `- O& u) O. y9 ?" h
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    # I# k9 l; Y, Q' S2 Q2 L, p
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    $ Y, t* {. j$ s- [6 W" G% A
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    * C5 i4 L2 H/ r: b. q( g+ {: J& s
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    
31. #endif
    
32. /* 串口2-8的初始化省略未写 */
    4 |) e1 F4 [$ U% w5 F
33. }

复制代码

% }& b6 Y' y" i函数InitHardUart
: {3 m3 W1 H2 S' P9 a此函数主要用于串口的GPIO，中断和相关参数的配置。
: A7 J' v3 }4 W1 M/ @' p

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   5 K, w  N) O7 |& M) R+ N/ Q# [! X
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   : k8 [; v9 ?/ y1 S
3. 3.        
   
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   . f4 K0 m$ ]; Q5 s" e. A
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   5 D7 A2 b" y+ d/ @) i$ t8 u2 A: \1 T
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   # X9 H8 X& |8 w0 G5 T1 P
8. 8.        
   
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    ! B( X1 k1 u" n$ T7 x7 x" w
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    : q/ Y" a: v* S0 n: t$ [
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    
15. 15.        
    ; {9 j: F( M) Z
16. 16.        /*
    ! \+ @0 y0 @  c( Y
17. 17.        ******************************************************************************************************
    1 w$ B2 Y0 w1 X6 {$ Q
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    & P6 w7 [" i( n% S1 r
20. 20.        *              发板
    
21. 21.        *        形    参: 无
    1 }8 z# {' S& @  i% ~
22. 22.        *        返 回 值: 无
    2 m# W/ R6 @% M8 i- J
23. 23.        ******************************************************************************************************
    " J# j6 |# U; u, H2 R3 u1 m
24. 24.        */
    2 I/ ]) B5 @* K6 Z
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    ! ]5 f; h- G/ v. x' h/ O; V" X! |$ v
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    6 J. {  B. I1 P: o
29. 29.               
    8 X* o* Y( N* [/ B1 U/ ?) a- l
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    ! v% I& x- `7 u! o
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    + \7 M. z+ y" V' W1 ?
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    1 h( C: i* y' l" {# d8 E! L" k
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    " B4 k) ^' U7 v( o; b' N
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    
38. 38.        
    % a3 b& A2 q- a+ O( b: {2 l
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    8 \& N8 j9 [- W
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    1 p) j4 U0 }/ @8 c, k1 D, d9 p% f
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
      V1 W" g, H3 ~; [" q
43. 43.               
    5 i* a& B1 z5 T- N
44. 44.                /* 使能 USARTx 时钟 */
    $ l# u$ t* {0 s4 Z6 G% {- V2 `
45. 45.                USART1_CLK_ENABLE();        
    ! Z7 U) i9 [, w# G
46. 46.        
    * Q( i3 ^- i7 b
47. 47.                /* 配置TX引脚 */
    
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    ' d3 |1 }) x6 G0 W& V
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    * z: K9 Z; ?0 Q3 ^3 P
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    ' Z! P+ K& E  z
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    1 e4 t- @- n- q/ M/ j
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    . k) f9 s5 Z! v4 f8 t. a, L
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    * E- H0 Z- F1 \: I/ q4 L8 s+ i
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    , Q1 s$ }. u% A7 g7 E" P: |6 r3 V
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
59. 59.        
    ! L, k8 Q# A; ?* t$ w- a
60. 60.                /* 配置NVIC the NVIC for UART */   
    6 Q" ?" r2 V( W/ d2 s' U- k
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    + \7 Z* G$ r' L9 L6 [2 D
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    ' i5 D6 U! r7 O4 a
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    / t  m3 C8 @, o6 L/ O, a7 s
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
      c9 p( Z$ w2 O
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    . ]+ {% P) }  Z" T7 F; _& l
71. 71.        #endif
    
72. 72.        /* 串口2-8的初始化省略未写 */
    : S7 |" b( h" c/ O% k
73. 73.        }

复制代码

. K; I, z, G' k0 A1 k( l4 Y0 h0 g第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
/ K9 o- D) B2 W1 X6 h, C& S第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
9 S$ G9 t) l7 K/ G3 m第65行，配置串口的基本参数，具体配置在函数里面有注释。
/ i& w2 K8 ]: J% i& K) O                                                                                                                                                
  z2 M* X7 Z) c! `  P( i0 x

1. /*
   $ P7 o8 H- X1 c8 z6 P4 ~
2. *********************************************************************************************************
   6 ~1 U6 Q& S$ Q8 E( H6 P* `! @
3. *        函 数 名: bsp_SetUartParam
   ! i; p/ ~% Y; _0 z' x0 F' m0 F
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *        形    参: Instance   USART_TypeDef类型结构体
   6 h0 z6 m* A. U* R3 ?
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    - w/ }2 P, n) H$ J0 s, ~
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    , M5 v7 K, O* A  V; g8 P
14.         UART_HandleTypeDef UartHandle;        
    9 ], K3 v3 C" V" p( q
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    / H% f; q1 g7 S. }( W  V8 B; E
19.           - 字长    = 8 位
    . k' E) [3 G" @# [4 q
20.           - 停止位  = 1 个停止位
    
21.           - 校验    = 参数Parity
    ' H5 d5 U2 k& @/ V3 `6 O3 e' c# M
22.           - 波特率  = 参数BaudRate
    / V! m6 \4 j7 E& d+ H$ \3 I$ J
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    & x; j( \3 k0 j& P1 s# m
25.         UartHandle.Instance        = Instance;
    ! l* C$ X! Z- N" I6 u1 Q
26. 
    " Y* z3 X" Y7 P1 i
27.         UartHandle.Init.BaudRate   = BaudRate;
    ; B% m: i( _4 Y4 D- ^" E2 \! U
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    " Q) q- d) s6 S
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
32.         UartHandle.Init.Mode       = Mode;
    ! G3 x/ u  a, h$ J, W. h" h
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    8 d+ m) `& Q8 K% c5 y# l9 L
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    * G# S2 d9 Z5 q
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;
    
40.    
    7 \; F3 C1 x) Q" x5 g7 {; g
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    . [# r( V6 s. y# J; D$ g0 j
42.         {
    4 Q3 W) Q+ u; F$ C+ p& k% j0 `
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    0 _# t8 T2 E) q4 c$ k0 v
45. }

复制代码

函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：

) n- n; R/ [% W; ?; o% ^

1. /*
   ' |! N" N8 q. p- N& H" m# ?$ T! o
2. *********************************************************************************************************
   
3. *        函 数 名: RS485_InitTXE
   + x/ K9 D( q: w4 e/ {# O
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   9 B( N7 P- R6 k( Q- L
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void RS485_InitTXE(void)
   
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    0 D2 Q* H5 P& M8 L0 P0 _
12.         
    
13.         /* 打开GPIO时钟 */
    
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    / ^! ]; _4 n& E9 i- M, K
15.         
    
16.         /* 配置引脚为推挽输出 */
    3 k: P8 \& d( h; G' h) n- I" n$ c* A* T1 h
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    " h, j8 k/ z3 u2 J
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);        
    ; n+ j& \' P0 ^6 a8 n- U, @
22. }

复制代码

$ e2 @' Q1 O. j1 p6 U# E+ v- c30.3.4 串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能
; D1 }# x! B  U0 w* V, z/ w
收到新的数据后，会将数据压入RX_FIFO。
/ i; p  E8 {- Y, B检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
& A. Y' x$ ]; m3 W  h. B7 I
: R) y2 Y2 g8 @2 w下面我们分析一下串口中断处理的完整过程。
当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

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

- K! L( L: @' m; g

1. #if UART1_FIFO_EN == 1
   
2. void USART1_IRQHandler(void)
   
3. {
   ( v. d- @8 D4 S8 s! z* C
4.         UartIRQ(&g_tUart1);
   
5. }
   
6. #endif
   
7. 
   
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   
10. {
    
11.         UartIRQ(&g_tUart2);
    3 c8 d0 K! L  D5 S( J+ D
12. }
    
13. #endif
    
14. 
    
15. #if UART3_FIFO_EN == 1
    9 e5 M7 Q7 Z) R: n
16. void USART3_IRQHandler(void)
    & _9 g  p& L" X
17. {
    
18.         UartIRQ(&g_tUart3);
    
19. }
    
20. #endif
    - G0 a  m5 S! K
21. 
    # l) N- }$ d5 H, h
22. #if UART4_FIFO_EN == 1
    $ i, t7 g! U$ \' O/ l3 M) z
23. void UART4_IRQHandler(void)
    
24. {
    
25.         UartIRQ(&g_tUart4);
    
26. }
    
27. #endif
    2 q! [6 m: e; z" u
28. 
    
29. #if UART5_FIFO_EN == 1
    
30. void UART5_IRQHandler(void)
    7 X" j9 E7 }8 o# E
31. {
    % v* G0 I" q, U5 |0 s% F1 [
32.         UartIRQ(&g_tUart5);
    
33. }
    
34. #endif
    : F- o4 X/ C  t$ f1 K
35. 
    
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    8 M* P! ^$ q/ a" p
38. {
    
39.         UartIRQ(&g_tUart6);
    
40. }
    ' l2 p+ O: e! L. L7 q
41. #endif
    
42. 
    ( @" H- V: |/ t7 c
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    6 a0 S! z4 k# I0 \3 B% s3 v* E6 t
45. {
    ; v: D+ m- R8 Y8 s4 c0 [( B6 M
46.         UartIRQ(&g_tUart7);
    ' @5 j7 O+ p3 g2 D/ Z8 b
47. }
    
48. #endif
    ) z0 u0 ~# I3 t
49. 
    
50. #if UART8_FIFO_EN == 1
    
51. void UART8_IRQHandler(void)
    6 Q+ M5 A8 V2 v6 M! f8 S. J0 ?% ]1 ^: a
52. {
    0 t1 z9 |9 e& E
53.         UartIRQ(&g_tUart8);
    : N# X: a4 G  S% k# s0 q
54. }
    
55. #endif

复制代码

大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。

下面，我们来看看UartIRQ函数的实现代码。
8 N% v( M- Z1 v+ _% J

1. /*
   
2. *********************************************************************************************************
   ) p6 `9 |# S8 u
3. *        函 数 名: UartIRQ
   " E& r* u( i+ @- W
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   3 n9 F/ ~" E1 i" c% \
5. *        形    参: _pUart : 串口设备
   ; F7 x) S6 v' W) k7 _; r
6. *        返 回 值: 无
   ) a7 t8 [4 t2 Z& _2 @3 Z: ^
7. *********************************************************************************************************
   6 b) d5 c6 Q+ y2 z- |
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    $ ]  O- o. t- V  ]7 i
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    6 g+ ~' Q" d* R/ P0 q' ~+ G
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    , I0 O( b" e$ p9 R: l5 F9 C
14.         
    
15.         /* 处理接收中断  */
    8 Z. n4 G, r  O3 E6 s
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.                 uint8_t ch;
    ( R3 k& o0 H2 p6 r- Z0 L' D6 I+ w5 \7 \
20. 
    
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    % [: o: V5 Q  m1 Y
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    " i% R" u, b$ n4 D" D8 }
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    5 ~1 b0 W6 V* T$ v' Q
28.                 {
    * G5 Z, l" s' b1 m8 I( L7 ~
29.                         _pUart->usRxCount++;
    
30.                 }
    
31. 
    
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    # f5 b  P2 R! M3 {* ?0 Q1 N, j
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    - R7 r, `) F) P/ K( X: c
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    
36.                         if (_pUart->ReciveNew)
    1 ]8 c: B* i& {/ z- V
37.                         {
    ' b# X& Y8 j% K7 B# l0 L
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    
40.                 }
    
41.         }
    % `( z$ r+ o# N; K: v$ J
42. 
    : R  U1 n) a! e6 G9 D2 S. `! y- h
43.         /* 处理发送缓冲区空中断 */
    2 U$ ?( w7 U: X$ H1 {, ?
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    6 D1 n$ w7 a& M8 k8 j& F2 j  c
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    / B( j. m( Q2 {' q: ^: n
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    ( ?) u1 O! t- _! s$ m. _- |
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    " U4 e) [0 y, b" a% V( m* g  J2 z
52. 
    1 G. r$ @% Y+ s3 `! o
53.                         /* 使能数据发送完毕中断 */
    
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    - G1 \: I% |/ G0 z
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    $ R$ d1 e% i: O, r9 _& {0 s3 u
56.                 }
    
57.                 Else  /*　还有数据等待发送 */
    0 N1 {5 S- {" o8 z6 b, U
58.                 {
    
59.                         _pUart->Sending = 1;
    
60.                         
    2 Q3 }) ?) e) a2 u' k
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    * u: P+ ^% M  `4 ]2 g$ ]$ U) Q5 I
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    7 b9 o. n1 @# p) P6 y. b, n! H
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    ) I2 c! ?2 {6 d0 h; e( }
65.                         {
    5 f$ K( g- v! k" d6 ~% e
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    
68.                         _pUart->usTxCount--;
    
69.                 }
    * _  `6 L+ ~0 E! ]1 B. o1 M; `
70. 
    3 s: @5 f1 j# x
71.         }
    ) m; l" L, P" ?1 Y3 M4 [3 d; k) S
72.         /* 数据bit位全部发送完毕的中断 */
    5 L9 V& j4 A$ `2 a4 p) T9 w
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    1 H/ t! q' H2 s: m
76.                 if (_pUart->usTxCount == 0)
    # u& Y* U- l, `9 G
77.                 {
    
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    8 x2 i# r2 g5 y! }* A' C
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    " e$ _. h* B& g8 C9 M, l; e
83.                         if (_pUart->SendOver)
    * u1 X/ w& Y$ g( s3 r
84.                         {
    . H: T2 Y9 S4 w
85.                                 _pUart->SendOver();
    
86.                         }
    8 m) L$ [; }! E! H
87.                         
    ; n, c5 \9 k$ H. I+ ]
88.                         _pUart->Sending = 0;
    ( F/ v  R# T: h+ D, a: o: G
89.                 }
    
90.                 else
    1 w! |$ ]1 i8 j) _# u+ i8 x
91.                 {
    ; b' K9 K  t4 u- B0 o7 _) Q
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    3 [- i1 E8 T8 F; [6 S
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    & s$ D* y: U/ q/ o, {5 E, V
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    9 ~" B; ~) M4 B/ Q
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    1 Z+ V- A7 t* K$ w8 {
98.                         {
    ) m7 U  X7 z) {/ |! ?( c
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     
104.         
     
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     . ?! E8 V; _( l4 M$ t
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     * H, i5 r' R1 M$ Q) _6 I, G4 W
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     . d4 @% K* [* ?* U
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
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);
     ' G/ D/ ~8 ]. @0 c% L* t
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     % I. x2 S9 Q# r/ p1 ^" E7 i( z
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     2 I9 \" s& \- ]; l; }/ T
117. }

复制代码

4 @& B4 T/ m) {; `* K中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。

$ A+ x3 e  @5 Q8 @+ N7 X+ V8 ^  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
1 d/ @1 ?; L& m1 S) d* ]9 ?  \特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：
0 p/ C5 m: P! T( m; v  a$ y
) t% b  L. v9 j2 _3 o

1. /*
   
2. *********************************************************************************************************
   8 Z1 w$ q3 n5 ^( A; [
3. *        函 数 名: comSendBuf
   
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   
7. *                          _usLen : 数据长度
   
8. *        返 回 值: 无
   . b0 u. ~8 o6 I! h
9. *********************************************************************************************************
     d4 R7 f7 S6 |( S. G
10. */
    $ [1 b1 u2 a+ U' k0 f
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
      p7 `/ q' d, A2 ?# ?/ t) Q
13.         UART_T *pUart;
    
14. 
    / f+ F) y0 d; t( R( X8 {
15.         pUart = ComToUart(_ucPort);
    
16.         if (pUart == 0)
    
17.         {
    ; D. ?: i6 M2 G- \2 z' z8 b
18.                 return;
    
19.         }
    4 N8 O6 x) `7 N/ j7 m
20. 
    2 }' ~! O4 ?3 V9 E& F0 W( P- Z
21.         if (pUart->SendBefor != 0)
    3 b; f0 e: v6 x
22.         {
    1 P" q7 C3 s5 h4 l+ F
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.         }
    
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
      L0 p1 F2 U; F+ _  a
27. }
    
28. 
    * u& Z% S: F5 v+ C0 Y' L$ w6 x: B7 o
29. /*
    
30. *********************************************************************************************************
      h, ^0 X: D2 @) |! ?# x
31. *        函 数 名: comSendChar
    7 h9 c8 j# D  ^4 v' F% }2 ^; B+ |* ^
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    
34. *                          _ucByte: 待发送的数据
    3 @8 t, S3 P4 k4 y  C1 l/ L
35. *        返 回 值: 无
    
36. *********************************************************************************************************
    
37. */
      \+ |7 X+ E' H5 e4 n; r: M
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    ! v' c- k. _! T. l- b$ h8 ~+ V0 E( z
40.         comSendBuf(_ucPort, &_ucByte, 1);
    + Z; w, d. a5 F* p( w( q6 w
41. }
    $ _5 ~5 J8 M% y- ~" a4 W/ _" A' F
42. /*
    ( @6 h2 z( k" L
43. *********************************************************************************************************
    
44. *        函 数 名: UartSend
    * G1 V/ y0 {4 N& f
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    - }- r5 T+ h' c1 U6 a$ ^
47. *        返 回 值: 无
    
48. *********************************************************************************************************
    
49. */
    ) i  \/ e9 u2 `- R# k( G
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
51. {
    
52.         uint16_t i;
    
53. 
    
54.         for (i = 0; i < _usLen; i++)
    6 f; Z# |) r8 ^2 }9 V6 }) a
55.         {
    
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    4 r; O" z: }, a( l; P! ?
57.                 while (1)
    4 [& N6 ~0 D( g: K8 r
58.                 {
    0 M8 G, h) z& T. e) p
59.                         __IO uint16_t usCount;
    
60. 
    1 K* S+ m# W% f
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    
63.                         ENABLE_INT();
    
64. 
    
65.                         if (usCount < _pUart->usTxBufSize)
    
66.                         {
    
67.                                 break;
    & O( x) G0 r. {+ F; l" d. K# ]
68.                         }
    $ \3 v7 y# m5 W/ E
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
70.                         {
    1 t, _/ j, p5 D5 Y& Q* k
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
74.                                 }  
    
75.                         }
    
76.                 }
    
77. 
    
78.                 /* 将新数据填入发送缓冲区 */
    + i+ i: F% l; |; |. ~+ {1 z8 [
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    ( A) h3 X2 @( m2 ?+ U
80. 
    ; x$ L9 V! ?' E. r9 N$ n; p
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    
84.                         _pUart->usTxWrite = 0;
    
85.                 }
    
86.                 _pUart->usTxCount++;
    2 h2 M& p# D, q
87.                 ENABLE_INT();
    6 p$ b" ^+ Y- L1 l( X+ ?% ^
88.         }
    # r$ {& E& m7 B3 S4 V0 p
89. 
    + j! x0 ~! U2 i/ D  x
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    ! ~8 t9 Q  K- `  N$ s- R
91. }

复制代码

函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
( Z( G7 H  F/ w* v3 p
: d6 d& Z7 ^9 h  ?/ e  m# l& Z1 T  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
7 w/ T! t3 X" O  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

" n6 [' a) N# Y5 S3 C注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。
9 n" m7 x; |  g( i5 s# Z
函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

- _; T7 n# `! Q

1. /*
   7 g0 N* {) ^* ~# @0 a
2. *********************************************************************************************************
   . {$ R8 G4 }6 s0 J4 e
3. *        函 数 名: ComToUart
   - `$ {) o3 C/ |
4. *        功能说明: 将COM端口号转换为UART指针
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   / [" q( O$ }. Z- T- k
6. *        返 回 值: uart指针
   3 Y( x0 ]% h6 l
7. *********************************************************************************************************
   / D5 K4 b2 b2 R' j# a% N1 p
8. */
   ! ?9 ]9 y2 E' R8 C
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   
10. {
    
11.         if (_ucPort == COM1)
    
12.         {
    
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    
15.                 #else
    
16.                         return 0;
    
17.                 #endif
    
18.         }
    2 u* }& q% T; a/ P, C
19.         else if (_ucPort == COM2)
    
20.         {
    % r' N$ g5 @. u# I5 V  V- Y+ K
21.                 #if UART2_FIFO_EN == 1
    
22.                         return &g_tUart2;
    ! h4 H8 F6 [( F2 R' j8 B; [' b8 ]
23.                 #else
    . x2 h  E! Y5 O4 d, a* u
24.                         return 0;
    
25.                 #endif
    6 k5 i5 E( J9 T2 s* F# X3 t
26.         }
    
27.         else if (_ucPort == COM3)
    ! N: Y6 h+ d5 M8 z
28.         {
    3 T; N& P- U, h, L2 ?$ ]/ w
29.                 #if UART3_FIFO_EN == 1
    9 u+ c# D3 v9 F. V7 g! r
30.                         return &g_tUart3;
    $ P& |! u" J! K% s3 M) x
31.                 #else
    % Y: `% z& T9 K1 H
32.                         return 0;
    + e0 A: b$ t( `  V2 J
33.                 #endif
    
34.         }
    
35.         else if (_ucPort == COM4)
    
36.         {
    2 y+ }+ u. u' K+ T" N" i. W! \
37.                 #if UART4_FIFO_EN == 1
    ) G" q  G8 ]' r( P' j1 l8 @) d
38.                         return &g_tUart4;
    / f" |* L! A- T1 @5 w& J% t
39.                 #else
    
40.                         return 0;
    
41.                 #endif
    . t7 O* V- e7 x  f0 `
42.         }
    
43.         else if (_ucPort == COM5)
    
44.         {
    # [: d0 w( ~/ R* h
45.                 #if UART5_FIFO_EN == 1
    - E* A! h% |0 b/ z% l
46.                         return &g_tUart5;
    
47.                 #else
    4 z% _9 o4 t& v! D
48.                         return 0;
    
49.                 #endif
    
50.         }
    , F6 d, U3 h/ _: l+ N1 ]' C
51.         else if (_ucPort == COM6)
    
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    % B! Z* E) M- ?* B; O  Y0 ]$ a# ?
54.                         return &g_tUart6;
    
55.                 #else
    
56.                         return 0;
    . L& `7 A% f8 M5 m6 p, Y/ y2 U
57.                 #endif
    
58.         }
    
59.         else if (_ucPort == COM7)
    + V; O4 `# r0 o% @& o
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    
62.                         return &g_tUart7;
    
63.                 #else
    3 |3 C3 p2 U2 F# H; d* p
64.                         return 0;
    
65.                 #endif
    & A4 Q' w3 M6 N& Z  G) ^$ D$ ~
66.         }
    0 c3 ]' o5 h; B. V1 w
67.         else if (_ucPort == COM8)
    
68.         {
    0 {  B2 R# W6 b
69.                 #if UART8_FIFO_EN == 1
    
70.                         return &g_tUart8;
    
71.                 #else
    5 p, o) {* R0 g8 }# ^
72.                         return 0;
    
73.                 #endif
    ( E9 V0 a4 w5 W. D3 t% x
74.         }        
    3 L4 n7 f! a+ A1 S0 q& P
75.         else
    - X) q6 B# m+ d6 z5 |: F* k0 r
76.         {
    3 k4 ~4 Q, E2 J, Q- I
77.                 Error_Handler(__FILE__, __LINE__);
    " p* d( x) ~0 _( ~+ _
78.                 return 0;
    % M8 H: C, [7 Z- U
79.         }
    
80. }

复制代码

30.3.6 串口数据接收
下面我们再来看看接收的函数：
0 ^2 K" h3 c4 D# O( w
$ a* ^( L2 E% v1 y% }

1. /*
   0 K. G) S$ h  f1 }) s
2. *********************************************************************************************************
   3 d0 z5 L8 E7 A( |  P5 d
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _pByte: 接收到的数据存放在这个地址
   
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   " E! {) S0 h) c+ G2 b6 m7 S
9. */
   : s# c& C; M8 }* E
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    
12.         UART_T *pUart;
    $ |; [& D+ q9 F8 x2 `% f
13. 
    
14.         pUart = ComToUart(_ucPort);
    % c# ]: b) ]! i% E0 I
15.         if (pUart == 0)
    / N- k' B; y& O: V, D. ^  o
16.         {
    
17.                 return 0;
    
18.         }
    5 e2 Y; |# \3 ~
19. 
    . [" Y7 Y% c/ y' s0 ]' [
20.         return UartGetChar(pUart, _pByte);
    
21. }
    
22. 
    
23. /*
    
24. *********************************************************************************************************
    * I7 ~- z% K3 d& d0 d
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    , _6 G2 r. E4 |4 h, Y1 D7 k' K. p
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    " i. \9 l' K. X+ z' ]7 M2 `
33. {
    * O2 C5 U3 h& b3 n5 r$ m
34.         uint16_t usCount;
    2 `* k. I) c& w0 D- j) X) j8 P% Z
35. 
    , @3 A$ X7 M* r8 }) J# e
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    % P- |5 {+ {+ r2 N
37.         DISABLE_INT();
    
38.         usCount = _pUart->usRxCount;
    
39.         ENABLE_INT();
    
40. 
    # k( P& h# z  r0 c
41.         /* 如果读和写索引相同，则返回0 */
    
42.         //if (_pUart->usRxRead == usRxWrite)
      R  Q0 Z: t0 Z0 X5 }3 H
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    
45.                 return 0;
    8 v% {1 @5 C* p5 K- m, [
46.         }
    * @! J$ q0 d  D% S& |
47.         else
    / E& z: _+ X/ B  ^, p: _3 j
48.         {
    ' r: |$ u( i8 `3 n3 r7 M
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    
50. 
    
51.                 /* 改写FIFO读索引 */
    1 P: ?2 s1 |9 {* b9 u2 ^6 k
52.                 DISABLE_INT();
    1 v- j% d0 W& V4 W6 Y6 j6 _
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    
55.                         _pUart->usRxRead = 0;
    
56.                 }
    5 e4 j$ v( Z1 P$ E/ D/ s3 r* y
57.                 _pUart->usRxCount--;
    * q8 ?' x' f4 q0 N- W
58.                 ENABLE_INT();
    
59.                 return 1;
    + ^: \* ^( }( e2 l* `  R7 W5 N0 r
60.         }
    
61. }

复制代码

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

' t& x* b; j1 g# a注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。
" X% I9 W: R) E) L. e& ~
30.3.7 串口printf实现
* J# o4 ?& N* Yprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

: e" t- `  L- s$ f) B9 m, O3 d为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
' V: j2 y, s$ s- w* p
  _, J7 y* a+ \, k- }% i实现printf输出到串口，只需要在工程中添加两个函数：

- M; _/ _8 A2 u# u

1. /*
   
2. *********************************************************************************************************
   " U. B* m2 P; Y
3. *        函 数 名: fputc
   . B" e% c7 C& o  }' h
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   ( e$ Y: \  s: J, h+ j: V- x
5. *        形    参: 无
   
6. *        返 回 值: 无
   . i, Y7 X" g8 C/ m
7. *********************************************************************************************************
   
8. */
   & Y% h& o+ M, r/ g  F
9. int fputc(int ch, FILE *f)
   
10. {
    / _+ h$ e- K' M+ \' M. ~9 G& ]
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    / ~; W8 c; I" ~  C9 |! Z- I
12.         comSendChar(COM1, ch);
    
13.         
    
14.         return ch;
    
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.         /* 写一个字节到USART1 */
    ( F) i- s8 y0 a) N+ o( Q8 B5 d' A$ e
17.         USART1->TDR = ch;
    
18.         
    3 D/ o4 l# E# b; \& V
19.         /* 等待发送结束 */
    0 m5 T2 Y' y' `3 p* O6 ?
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    
21.         {}
    " {1 a# ]4 k1 W# E* ?3 ]6 [7 |
22.         
    " i  b5 B" g) q8 t9 y
23.         return ch;
    
24. #endif
    5 b0 R0 \% G' d" {- ]
25. }
    
26. 
    
27. /*
    
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    5 a5 n7 g  L" ]1 @) ?+ [, }
31. *        形    参: 无
    # W7 i( _- g3 D
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    ) b2 \* r' ]) D0 y
34. */
    * c% T; _* O* H0 L' I+ E! M! o
35. int fgetc(FILE *f)
    ) ]( J4 c( D5 l# ^# D# }
36. {
    ( Z$ F9 A( s$ J% ]
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.         uint8_t ucData;
    
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    % D' R9 L; m& m9 t
42. 
    & l, F% P* V2 K/ `" C' Y
43.         return ucData;
    0 y& L* b2 M7 X
44. #else
    $ s* g0 O3 I* {/ ]$ D5 R8 x! o
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    
48. 
    
49.         return (int)USART1->RDR;
    " ~, r5 ~5 F7 H4 Z8 e+ `
50. #endif
    
51. }

复制代码

: _1 M( }. \1 @! {printf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
# c* D% a" x- m* H3 ^4 l( @
, r% D) q7 G2 c3 [. ^! p30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

, ~% L  l4 L( C) ~9 _  bsp_InitUart
8 J0 [2 t+ o+ e) C9 `: \( H) q  comSendBuf
  comSendChar
  J' B2 A, @: K. ]3 Z% b0 C  comGetChar
30.4.1 函数bsp_InitUart
# B3 L- O" b) V! Q函数原型：
void bsp_InitUart(void)
& R* P8 k* M  N" _$ u
函数描述：
* H, B! e/ \/ `, j7 |$ N此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：
( ^) y$ S/ g0 T+ ~- a# l: O串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
8 H" y# N/ s0 Q( d
30.4.2 函数comSendBuf
函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

8 N( q. ~9 t+ R1 B1 Y; x
函数描述：
# r6 b0 Q0 j% y# [& A8 X此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

3 u& q  `8 _; @  E9 u5 h- X9 R  x函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
& w/ N6 x& o. X# T1 R: E0 h  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
7 T) T8 ^, e3 G! o9 P1 Q
  ^; U+ A. ?) [: y' y
6 l3 c5 A4 t+ W) S6 L2 Q$ U注意事项：
, J1 T. }  \! P3 f" {+ E  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。

1 @# t7 B1 M, ]( Z& L8 ]: P
! Z6 J  v# G& M% r1 G: R% R使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

: d8 X+ y# h0 ~7 x  aconst char buf1[] = "接收到串口命令1\r\n";
comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
- k+ Q; O) C3 u7 G7 s8 U7 E5 G

) x0 K( J8 T) D, q5 Z5 ^30.4.3 函数comSendChar
函数原型：
, X/ x  L/ H& _; ivoid comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);


( \+ m: V4 |1 g' a1 @函数描述：
' J+ D% j3 R6 O, m
1 L$ f- @+ C5 ^; @此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
  ?0 J7 I7 i! i6 c7 Q# G& ^
函数参数：
. _% U+ K5 Y9 W" t3 F  第1个参数_ucPort是端口号，范围COM1 - COM8。
2 O2 {+ G# }# Q! P% x  第2个参数_ucByte是待发送的数据。
1 M; {- X! E, |$ @5 ?3 s. x( _

注意事项：
  此函数的解读在本章30.3.2小节。
3 e, S( q. e2 R/ H' c( k5 a6 j- [( W
! ~" i2 F  Q+ p8 i+ }5 N) S' L
使用举例：
% {: t' e4 _& t* ?$ ^0 R6 Y调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。
, ^; d: `2 _0 U& q
4 ]3 o( {8 }$ Z2 W30.4.4 函数comGetChar
! v! ]& I# N, ~: ~函数原型：
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
& z5 _6 r/ p4 U* ?2 F

0 t. _. A5 [* g函数描述：
$ E) ?2 k: c+ ]. j此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
" b4 u: U$ I- s, _2 U$ C
9 L+ I% o# Y+ Z4 o函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_pByte用于存放接收到的数据。
% j' J- Z; k, @( e7 w8 m  返回值，返回0表示无数据, 1 表示读取到有效字节。

& f1 |1 R4 T! S* r/ s6 U+ r
注意事项：
  此函数的解读在本章30.3.6小节。

# x3 G5 B9 y8 h, r3 K, a( G
  T0 X4 |+ o/ Y- v' u使用举例：
9 b% N, Q& t0 s9 q调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
' u7 w6 |2 j- E2 E
比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

  x* R' p) [5 Z5 m7 s30.5 串口FIFO驱动移植和使用
. x; N7 E/ d4 |5 M) l3 B串口FIFO移植步骤如下：
; L1 p% y2 e4 S5 c( D
  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
/ e3 m$ U+ k. q7 n

1. #define        UART1_FIFO_EN        1
   
2. #define        UART2_FIFO_EN        0
   3 A7 F0 e% f# ?. g! Y6 L+ k& q
3. #define        UART3_FIFO_EN        0
   
4. #define        UART4_FIFO_EN        0
   6 x% f5 a: X/ J2 b, x
5. #define        UART5_FIFO_EN        0
   ; E" d) j( f; M3 B- {1 I# f
6. #define        UART6_FIFO_EN        0
   * J& S8 P" o3 o3 o/ B
7. #define        UART7_FIFO_EN        0
   
8. #define        UART8_FIFO_EN        0
     c' E0 q% e+ k4 P# P9 i
9. 
   4 m; @. j- o$ D0 |
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    
11. #if UART1_FIFO_EN == 1
    
12.         #define UART1_BAUD                        115200
    $ i$ M0 F' s9 \: @
13.         #define UART1_TX_BUF_SIZE        1*1024
    
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    . D  v0 y& k; A8 Q( t
16. 
    , Q) X0 R3 B- p5 _4 b. \0 g; e
17. #if UART2_FIFO_EN == 1
    # k. }6 u' M1 J+ Y/ j
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    
20.         #define UART2_RX_BUF_SIZE        2*1024
    ! m. d/ a% @$ c& N2 C  n: y& L
21. #endif
    + t8 g6 Q3 ^4 p  \% D" t$ x) A
22. 
    2 y. b, f+ _1 O8 B# 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
    5 A+ X: h3 a. [7 t( a; y5 l- S* s
28. 
    
29. #if UART4_FIFO_EN == 1
    5 }; D; D1 B2 T! a! z
30.         #define UART4_BAUD                        115200
    ! b9 r) C8 S5 a
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    
33. #endif
    5 L" _! \$ P! W+ `) Z5 p: w* p
34. 
    
35. #if UART5_FIFO_EN == 1
    
36.         #define UART5_BAUD                        115200
    # e' U) j0 i8 y! ?$ ^5 r
37.         #define UART5_TX_BUF_SIZE        1*1024
    ( q8 s: [" Q$ D8 M9 s
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    
40. 
    . f4 h" T# R- u
41. #if UART6_FIFO_EN == 1
    . \8 x: k9 }! G) M7 g' P4 B, w) ]& v
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    # m" J) Z! C1 l% Q1 T# i4 D8 d
46. 
    2 ^+ F1 T% E8 X$ N
47. #if UART7_FIFO_EN == 1
    8 ]2 {2 M- y# \9 C! }9 |: d
48.         #define UART7_BAUD                        115200
    3 }% {" O/ O& Q
49.         #define UART7_TX_BUF_SIZE        1*1024
    / c" C. u9 {/ }% j9 v6 M
50.         #define UART7_RX_BUF_SIZE        1*1024
    . t6 N7 ~; |. b) P7 }% V/ v
51. #endif
    % R7 x/ s6 U0 j/ _+ }. U
52. 
    
53. #if UART8_FIFO_EN == 1
    * N. f% y/ w4 r) I3 Y, ^
54.         #define UART8_BAUD                        115200
    
55.         #define UART8_TX_BUF_SIZE        1*1024
    3 P) j) S" r* c0 p" o+ n! v- f
56.         #define UART8_RX_BUF_SIZE        1*1024
    
57. #endif
    

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
3 O3 Z9 o- }0 l5 o  第4步，应用方法看本章节配套例子即可。
4 D; b7 H) n( E! `  T: t  W
30.6 实验例程设计框架
0 f( o- q# S9 ^2 _. J- H* F通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

  第1阶段，上电启动阶段：

' ?8 u$ C  d/ \. k+ b$ }这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
* A7 y; L7 E3 B/ N* z1 z
1 O/ I% ]7 L9 ?1 Q  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
9 o5 U  v; A1 k7 \5 {+ {( K  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。
" C3 `) M* R5 W2 \
* z/ f: J# |4 s. |! O- B30.7 实验例程说明（MDK）
配套例子：
  |; b- f4 g6 A7 ?! _8 O/ @
V7-015_串口和PC机通信（驱动支持8串口FIFO）

" Y/ H* e0 p2 u% W. s% j% G9 k6 b实验目的：
学习串口与PC通信。

6 k+ ~7 F6 y6 F. k5 q, B" Q
实验内容：
  u4 O6 [+ s" S" O- A启动一个自动重装软件定时器，每100ms翻转一次LED2。

7 v8 L! Y$ O+ Q& O5 z: q$ i
7 T1 Q  O' E6 ]* I( U8 j& Y实验操作：
! k  f2 Y; a$ u/ ^( [. ?8 z串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  u3 ^, D& o6 A+ ?0 B串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
5 R$ `$ \+ f& ]' W5 ?9 _7 M串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
# Y! ?. M% |* ~6 BK1按键按下，串口打印"按键K1按下"。
5 a. C4 U' G: ]2 e. I$ E2 a. DK2按键按下，串口打印"按键K2按下"。
' X6 B( P* d& Q1 zK3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
( C" J( P) x2 G$ D5 k7 N3 T

程序设计：
7 a$ x" b3 H2 M6 m- a
3 Z" z  x! T1 F7 N  系统栈大小分配：
5 \. Q* o; E5 d* d6 L
" n  ^) b$ s; _" X$ {, [0 i& t

0 I% |" @0 J; R
* [( f' v1 m" }" q" s  RAM空间用的DTCM：
* S) h9 e% u# T2 ]5 o

  硬件外设初始化

: B9 H2 X0 P, D4 f# M* P+ j5 F硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   ' d9 ?$ h5 o6 f1 k9 U4 v5 ?* L
2. *********************************************************************************************************
   3 l3 @: x, [' o3 x6 K# p2 Y
3. *        函 数 名: bsp_Init
   ! @1 v3 X4 J% Y$ F. ?* ^
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   & t9 B' K) v/ \9 {4 J& x
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   ) |3 U. r# V6 q# B) P( s
10. {
    
11.     /* 配置MPU */
    ; V2 K5 P( b/ m" o* @0 f/ W5 N( T
12.         MPU_Config();
    ) Z' t8 ?5 T* W
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    7 Z4 z9 w6 g+ V& @) \; w
16. 
    4 w3 t5 P3 C% t5 V
17.         /*
    5 \; `8 o& l1 A( ?5 g7 D
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    ) b& ]! M) h0 R1 r8 I. e; z
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    4 g0 K, J0 ?  i0 S6 Q' A
25.        配置系统时钟到400MHz
    , e8 S# C1 I, e- s/ Z* }
26.        - 切换使用HSE。
    , o4 s9 v$ X" h9 o, J2 w: Z3 ^$ k
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    % [' p  R# K6 G. V4 D' q
28.     */
    4 ]3 P2 {! A+ s+ x' k% q! s
29.         SystemClock_Config();
    ) h0 `. J5 `% K  h6 G, R2 D% Z
30. 
    + m0 F2 u/ F0 V) j4 K. }9 `
31.         /*
    ) f) T2 W" O/ u9 n& e2 y
32.            Event Recorder：
    4 R  V/ X6 r8 }8 s, m
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    : o/ x2 g3 k, s; p% I) H. j" ~. c. v
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    & p0 n5 S# T4 ^. X% m& y
41.         
    # h' q1 f) q7 H/ d  F8 j; J
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
      L8 Z( }, m6 E8 \3 `$ ~! k: q5 r
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    ) a/ L" c' F) V/ w! b' @: a6 y
47. }

复制代码

  MPU配置和Cache配置：
4 o9 K$ A0 u) q  c5 q- G0 P4 D
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

- u; T7 L+ n0 |" i3 j5 V% G

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   2 S6 N5 |2 s, J, T% J
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   $ \0 Z; c" p% L* t7 s1 i
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   8 d1 `. i7 Y6 G8 O9 C9 Z8 @6 K+ p
9. static void MPU_Config( void )
   
10. {
    # A! M. M6 K7 C! ~$ q* O" u, E# g
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ! W! n" N, s+ c& S  F* `
12. 
    / G4 w4 p8 W2 \& i7 A. V: y, Y
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    * ?/ q$ x* S+ H; E& c# z5 B
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    , Z5 w' C  e8 U; T8 Q
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ! i/ @9 Y" d8 G& r7 F$ f
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
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;
    3 U# ^) I0 f8 N2 D: P& Y' X8 M
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    5 e9 j; [  i# g1 n
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    % h; }0 [, l, ~7 r$ P# H
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    9 ~) H4 G" \4 o0 w+ p. k
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    4 Y% I3 V' _+ `2 j* ~
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    4 P/ c' w. m+ z) t4 ~+ j
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    . M! j- N, c1 H2 V. f- z
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
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;
    9 j" W: s$ g" v9 ~5 h8 V
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 A" S3 P4 b" E8 {1 V6 m& @
46. 
    
47.         /*使能 MPU */
    8 ?* B3 Q& l9 L) w* `! u8 I
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    + O6 b! {3 \9 h8 u. i
50. 
    
51. /*
    9 e& s! _# L: _5 s* q/ }: _* U/ H
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    ) W5 f$ I# e5 d6 o) M2 G" M7 Q
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    $ a. ]- J8 g' D7 G8 U; o% M
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    - s+ c1 ^8 t; |7 W- l2 K
63. 
    ' h8 R2 T3 w9 c
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    ( E2 [6 _: O8 u+ u& F* |: Z2 l
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
6 t* t" z1 s7 X! q6 `
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
' W: t+ k- P4 m
3 v( R1 K; ?) V* B( ~- a( Y

1. /*
   
2. *********************************************************************************************************
   # m" {& \0 m9 m" `# D
3. *        函 数 名: bsp_RunPer10ms
   ! `3 d+ u# H$ x* ^9 i
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   ' {# m' `; E" \- S6 x& G- A
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   # z9 Y. }4 j! H
9. */
   
10. void bsp_RunPer10ms(void)
    4 b( }6 h/ _6 e. d3 D
11. {
    3 p" `  e# e8 U: i9 _: P
12.         bsp_KeyScan10ms();
    
13. }

复制代码

2 c, K( ^; ]$ [  O. ~+ J/ Z+ B  主功能：
7 X' O" _( m& ]* b0 r
主程序实现如下操作：

, z+ Z/ O- I! z) i4 S  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
( f, t+ |* U8 I% |- z, L) J3 y  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。

1. /*
   ) j2 |$ f* Y: Q2 u* B* Z
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   8 L" ]: l; M# `
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   6 u9 N7 C: Z( c; h
8. */
   4 ?2 T/ O, w) q4 X
9. int main(void)
   
10. {
    ' t6 e& p; H$ X2 n, `0 B
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    : L  ~: f. v0 e' O; M/ v' s
13.         const char buf1[] = "接收到串口命令1\r\n";
    
14.         const char buf2[] = "接收到串口命令2\r\n";
    3 P3 I: v  D" S% A- U
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    ' C: |9 T( s0 u0 F$ ^7 ?. C
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    ! I/ X& N! ^! Z
23. 
    8 z: W; }" S# d$ G5 H; |" g% P$ Y
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    ( H1 C6 Q! ?, ~7 H( ?8 V/ e
28.         {
    # e- @2 `( l0 f+ H6 T1 H
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    # p: K) h+ z$ G2 n3 {) U7 C! C6 {
30.                 bsp_Idle();               
    
31.                
    * d" b4 T& T! y2 s9 I6 @( @
32.                 /* 判断定时器超时时间 */
    5 [: E7 h% h+ d. G  N) P" l* s
33.                 if (bsp_CheckTimer(0))        
    ; Z# I: j+ |; ?7 M) k) {; p  V
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    1 V6 F3 E: |( G8 s& j! l, m
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    1 j. E4 X, |$ U
39.                
    0 }9 I+ W7 {+ S+ j! H, k6 h  N$ k
40.                 /* 接收到的串口命令处理 */
    : G3 n, R" Q! E* K6 U" x
41.                 if (comGetChar(COM1, &read))
    4 C4 P9 W- Z9 Z9 {  U1 l
42.                 {
    $ ^9 j3 u% g/ }$ q
43.                         switch (read)
    - o$ G& _' a) }: g; h
44.                         {
    
45.                                 case '1':
    ' ^5 W  ^* ~8 y+ n  i, l( [
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    
48. 
    
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    " {0 v$ w1 v. U6 C! R
51.                                         break;
    
52. 
    
53.                                 case '3':
    5 O; i. |. F& B: b# X* u, {$ n
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    : I. o+ s* g' z5 ]. ~) w5 L
55.                                         break;
    4 }( D3 a: C( {' \; Y- P0 D
56. 
    8 z* P; C2 S( I( ?5 P9 K$ A( R- \
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    6 ]! f# j, `% A2 o& N5 C
59.                                         break;        
    ' l( D1 M0 F! h" s* l
60.                                 
    4 |1 p+ F" V2 M& ?
61.                                 default:
    4 [8 a3 f) p9 w$ m0 \5 K. c# B
62.                                         break;
    
63.                         }
    
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    / w) p" m5 Y/ G6 |# E) ^: q
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    ( t  W  \4 w+ h( O) S
69.                 {
    6 f6 g- ^% B6 f1 Q) Q% c9 k1 {
70.                         /* 有键按下 */
    # g( F' o$ ?1 w3 J: n/ y. O
71.                         switch (ucKeyCode)
      k; g$ N6 [, T2 N5 f5 f5 ]  J# W
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    - t# H7 `+ }4 P* F3 ~/ w+ @5 x: N
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
      N" X/ O( r: @( D/ Y7 V
77.                                 
    1 Z$ a- a# Z1 k3 P
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    5 B# Y2 d! ^0 `* O' g; z2 [/ l
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    6 H, Z. d5 Y+ w6 U6 J
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    # E; p% K6 Y' V9 Z" |& n3 T
84.                                         printf("按键K3按下\r\n");        
    $ D9 Q7 J" y" I5 z* L
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    3 w. p; C5 d3 k7 U' k) A
87.                                 
    
88.                                 default:
    
89.                                         break;
    5 [7 g+ L5 B3 [" i; I
90.                         }
    
91.                 }
    
92.         }
    1 @& W5 {. ?" a+ O6 c( h. J
93. }

复制代码

30.8 实验例程说明（IAR）
配套例子：
( J) m7 _2 y5 i4 y
: i3 \& W+ J8 ^$ `9 \V7-015_串口和PC机通信（驱动支持8串口FIFO）

实验目的：
) H4 Z6 E+ A: @  J2 i& U学习串口与PC通信。
: w: f1 r5 I3 i/ L6 J1 u, G, \
. U2 {6 J1 x7 s9 V5 a
* n( \9 A- |! F* z) h, V. J6 E实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
& x+ V) n! j& n( M4 {) n

实验操作：
! f4 h7 m. `/ X- i6 Q: h( N  U串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
% T5 O( v+ E: t- {( M串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
. g, \1 q# p7 R6 \. @' qK1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：

. p% a: Y% u* _9 K/ m5 T$ l波特率 115200，数据位 8，奇偶校验位无，停止位 1

% n) ~& H) D- m+ \7 x0 s# b程序设计：

; z9 W. `( G$ l   系统栈大小分配：
- S5 E1 e' V5 A$ T$ @3 @; p7 p
; n' i/ M: b/ [/ ]

   RAM空间用的DTCM：
* G- e& b. s6 g. {
9 Y9 r; u0 l, Q( x9 o

6 r( \) J; M1 }) o# f8 y  i; W
  硬件外设初始化

; H4 g1 \# V) v, M' \" Z  k/ Q硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   3 F1 C1 Z0 e9 ?! I8 q, ]* D" x
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % z1 u  O: l% g! V+ p6 l! @
5. *        形    参：无
   9 j0 |$ @/ j' j( f- e
6. *        返 回 值: 无
   * D6 f% b2 r5 F4 i# o6 {
7. *********************************************************************************************************
   % L( D; H; W, h) Z" T- U  Z
8. */
   0 E6 u1 C7 a9 C$ ?
9. void bsp_Init(void)
   
10. {
    6 ?2 ]' V+ H% {" D; R; w
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    ' }. f9 ]/ h! O0 c* G4 _/ ~" V
16. 
    
17.         /*
    3 H6 D/ J9 U& \+ x) P7 Q6 X: G  F+ g
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    2 ~; {4 a5 j5 \7 x9 m# U+ S) Z
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    * q- X8 c1 ~) h" n7 x0 s; W
26.        - 切换使用HSE。
    ' y$ F" W+ m  y# \$ F% w
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    # n" \0 |/ p  t
28.     */
      x5 K. F1 N" W# M( f0 O* ]
29.         SystemClock_Config();
    
30. 
    . _3 d0 D0 F  B6 A
31.         /*
    6 g) S" v2 N9 P
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    $ `9 Y' P9 Q( u% J; ?2 V0 K
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    " N9 q& J2 b: W/ s6 N' d
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    # T! G7 g! \& \+ s4 \/ z; J
44.         bsp_InitUart();        /* 初始化串口 */
    4 Q: ]6 w' g' E( P2 u8 Z
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    % q, U/ o/ X( t2 O' r$ A
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

, T7 f3 f1 n& [2 `, h; J  MPU配置和Cache配置：

$ Q3 n  n9 r! [% N" m! K/ Y数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
" a5 ~1 T& W; f+ w: u: L
/ m; r$ Q$ L8 x) k: F4 H

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   2 E5 Q0 t. i9 {2 r
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   : N, c8 s7 M- x& Q. L9 s* M0 C
9. static void MPU_Config( void )
   
10. {
    . N9 b4 c, \2 h3 ]
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    3 z  ?: O7 ]) _. c! H% o; v+ b
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 i3 e: a+ {  C2 m
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    $ a' `3 z: e# }  l2 M  G3 h
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    + j" V' l: ?1 [% N- p
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      x5 G7 l: k0 E# l" [
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    / y7 @& H+ L" S) ~" Z
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    4 y6 _' M9 w& N/ b& j
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    , z3 M6 r3 f' m8 T# m9 j/ ~
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    6 z/ R' a. |) ^: C
30.         
    1 t4 u9 E. `+ b6 |; j. G" }* l1 Q
31.         
    , |0 y$ s  X: F6 A
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    * n4 Z- z+ v; V9 k
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ( d. Z1 ^1 C7 M, \9 H6 E
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ! d8 A0 ]8 w& l* Q( k0 u% o
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    4 |5 i- l6 b* V
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ! v" H: U) M7 U3 y
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    * Q6 `# M+ ?" y4 X) J
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    6 ]- ^/ g1 {  p& T- A1 t7 p3 H+ i
52. *********************************************************************************************************
    / @8 [1 K* v. U9 n- C  w' L
53. *        函 数 名: CPU_CACHE_Enable
    1 B. K+ p* r8 u- a( M7 u
54. *        功能说明: 使能L1 Cache
    3 r9 @* d$ t$ {2 Z2 @
55. *        形    参: 无
    
56. *        返 回 值: 无
    ( K% x- `3 I* q" l( p; u8 v6 I
57. *********************************************************************************************************
    ! Z8 O, I: P) p8 M" f8 {
58. */
      |5 H+ R, g7 w# W6 |6 G
59. static void CPU_CACHE_Enable(void)
    4 P/ @+ t* i- o7 U, L3 C6 x
60. {
    ( K" O4 X9 i* ?- W
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    6 r; `! x6 ^9 s$ g, o' d8 p
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }
    1 n! S( k' H3 o& x$ W$ g+ n
67.   每10ms调用一次蜂鸣器处理：
    
68. 
    
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    
70. 
    
71. /*
    ' V2 O$ f) ^$ }/ ?. N' q% y4 t& U
72. *********************************************************************************************************
    6 m# B2 d8 k, t. D+ f3 c. F
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    
79. */
    
80. void bsp_RunPer10ms(void)
    
81. {
    9 T- |, m0 n. W1 @( e. U% ^
82.         bsp_KeyScan10ms();
    
83. }

复制代码

  主功能：

: h' c' v+ ^4 [3 x& U9 h主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
( q$ {' s: ?3 S7 A& K. a. M  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
2 k+ b. V1 L- o1 V+ n% O. X  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
1 b$ D7 Y( w5 K0 p  \5 w8 J, E0 n  [  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
. x, O: e8 C, B& b

1. /*
   ) c7 W$ h' m9 h
2. *********************************************************************************************************
   1 ^" A& W( @8 [5 D0 B2 P! ?; V
3. *        函 数 名: main
   * Q% b; f. n1 m6 i# e
4. *        功能说明: c程序入口
   - a5 O. N: m5 z
5. *        形    参: 无
   " X1 B& Q; }, {& ~
6. *        返 回 值: 错误代码(无需处理)
   / Z5 u. o  H4 U; R5 r
7. *********************************************************************************************************
   
8. */
   4 _7 o/ I/ G6 u& B* Y
9. int main(void)
   - L% F( r* @" d" R  i! G- h4 U
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    * C6 {) W0 U& ?/ f$ h# _! d
14.         const char buf2[] = "接收到串口命令2\r\n";
    5 Z; ?0 _6 O% {) B
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    % i1 ]$ E- J2 o& v
17.         
    . b1 i1 W) w8 O6 ^: h8 k+ \
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    # Z. `3 P" w1 D* E* H+ u
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    $ \0 X# r- S$ A6 A. {& A& k; L
22.         PrintfHelp();        /* 打印操作提示 */
    * z1 Q* C& W7 |8 ~% B
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    ! s: |& {# x5 o& }" T4 m5 I$ ~
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    
40.                 /* 接收到的串口命令处理 */
    ; L& y! p# n9 P' Q9 F
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    ) C( G$ e& K0 L( h
44.                         {
    
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    6 V, k' c/ P7 l2 u7 ~
47.                                         break;
    
48. 
    6 z6 J  @$ R! p" u
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    
52. 
    8 w: q5 T: F7 T. Z; `# w
53.                                 case '3':
    5 T/ B/ q" L9 h& i+ O
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    1 U+ E" S2 \* z, q* A: \
55.                                         break;
    
56. 
    , A) u! I) c7 ~
57.                                 case '4':
    , p( A, T: d/ j9 L8 p: Z' b) ^& R
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    # q8 R& H$ \, e/ j6 X: a
59.                                         break;        
    
60.                                 
    ; F+ }3 Z) k& v
61.                                 default:
    ) M' u6 v3 Z1 W- ~! O& k
62.                                         break;
    $ H' ^' B/ t9 a, }1 f" X
63.                         }
    1 u+ m7 O5 \) {' \
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    5 b5 K' g- y8 Y4 F$ {
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    9 r1 g+ P8 w! w7 T: E/ A
69.                 {
    & N' _% z# u! `. I3 x
70.                         /* 有键按下 */
      w8 V& e4 E" [, H9 D% R
71.                         switch (ucKeyCode)
    
72.                         {
    8 P  }' l6 X, W/ f8 p% y2 }
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    - Q0 v- J* X7 [* o* x
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    " c) \9 A" P! `8 r
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    : j+ R8 O; V. F5 |
86.                                         break;                                
    
87.                                 
    
88.                                 default:
    " ]3 B: l. M6 ~  K; D; \
89.                                         break;
    
90.                         }
    
91.                 }
    
92.         }
    
93. }

复制代码

+ ^' L- F+ d, C9 g! D+ `30.9 总结
本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
$ r( z* F6 j) y  O6 X: }
1 c1 N4 }, I5 k$ A' m! D+ I. L* O2 N
% m7 g5 S0 f+ W) ?4 y& l


                                                                                                                        
( d9 }9 x- x  c4 [