30.1 初学者重要提示
4 S0 D& O- G+ A学习本章节前，务必优先学习第29章。
串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
1 X1 S% r( m2 Q+ JCH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
) p/ l8 ~8 r/ k2 F6 S30.2 硬件设计
, c3 s4 ~" ~: z, dSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
1 R7 o$ q  a/ E
2 R0 G/ C" u5 D9 \$ ^* o串口USART1  TX = PA9，   RX = PA10
6 i  a2 _" c1 R5 N3 \' `
串口USART2  TX = PA2，   RX = PA3
! e  `5 h  h; T- B4 H! p
5 E: O' c7 \- x6 i  [串口USART3  TX = PB10，  RX = PB11
( x2 o! S6 l: f! y* o' \
- z0 T7 _' N) H: U- G串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

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

串口USART6  TX = PG14，  RX = PC7

/ A7 v. _$ E3 l$ s, s串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
4 g3 j- J$ t7 M5 Z! A! h
. z% z. F& U8 `4 q1 O串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
( c& p: X' v( l& ]! W
STM32-V7开发板使用了4个串口设备。

串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
串口2用于GPS
( t& |7 d9 I: ^5 u串口3用于RS485接口
/ q0 T7 H# e' t/ n3 \串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
0 @) Q" L  e6 m; p- ~

关于232的PHY芯片SP3232E要注意以下几个问题：

SP3232E的作用是TTL电平转RS232电平。
电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
4 R  ^, s, I% {8 l& R) K检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
6 q8 `9 m. w/ k. Z8 Y- _5 W

" E# \3 D, U# w* e+ H实际效果如下：
; _8 Y0 K+ ~# l8 m5 _: Z% B1 L- p

  C9 Z9 f1 a" {7 ]& h6 w* I& B通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
3 ?: a/ H+ i& u4 g
& P" g) J9 r( \由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
$ R, ~) C9 ^2 J0 E4 Q; l检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。

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

6 \1 y, u3 S: [$ L; b

) {4 f+ G2 J4 s  R
0 g! b* f& ~+ i; R第1阶段，初始化：
! d3 f2 F( @8 O8 p" |  _2 m) j
通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
5 U! B* W- [% I# h4 i" Z1 {% J' B第2阶段，串口中断服务程序：
7 Y- P3 [  W6 U( I# `7 E% r- x
& _1 j& n- Q3 E接收中断是一直开启的。
) C, P: j$ c+ G4 L6 H9 \7 ]4 O做了发送空中断和发送完成中断的消息处理。
第3阶段，串口数据的收发：

9 {' \$ I3 a# U2 ^串口发送函数会开启发送空中断。
# Y! U& x; A  w4 R* k串口接收中断接收到函数后，可以使用函数comGetChar获取数据。
" o0 |" R9 a' u1 q& T7 r; A
2 |7 U( X1 @3 F, n2 |- ]# a8 }: U30.3.2 串口FIFO之相关的变量定义
$ U9 [0 ^- h% A5 n# Q" r$ _4 a- }串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。
) M9 {& H+ b7 U( u5 M
这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。
+ P9 r5 X2 M& X# G: i
) H. H+ s* p; M8 i每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
' F6 ?2 M. _' X, E9 {2 A7 H# g. G
我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   1 Z, [/ w7 ^  C4 t  K# Z
2. #if UART1_FIFO_EN == 1
   $ F5 Z$ ]( A' w
3. #define UART1_BAUD                        115200
   
4. #define UART1_TX_BUF_SIZE        1*1024
   . P% e) v& h+ \& a/ b
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   + z0 C: _, ?0 p8 J
9. typedef struct
   $ n  x% ?# C5 l+ F, T: P3 ?
10. {
    , h' G0 D/ m) s
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    0 ^. t" A* M) @: m/ ?  ?  _: Q
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    ) n$ y; q9 g' R# @3 r$ G. {
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    5 L6 j7 C& B# z1 G# p
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    6 Y$ ?+ l$ A. N( X1 @6 {' F
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    7 ?# h  ^5 f  Q( n+ }& n
23. 
    
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    2 ?5 n6 u4 V  @: K  m1 t
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    + a8 g- `( E$ j* k( u$ M3 U
28. }UART_T;

复制代码

4 ^, S3 j8 V' I; L% Y4 qbsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。
' q% O( p) P3 Y5 r' K- k

1. /* 定义每个串口结构体变量 */
   
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   6 z/ E/ _: O' C0 m) e% U" ]
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   
6. #endif

复制代码

关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
2 a- w( n$ o, O  n2 s( b8 s
30.3.3 串口FIFO初始化
& j3 S# j* h8 k# k串口的初始化代码如下；

( t3 }4 B2 s- ~

1. /*
   4 w7 T6 w, G* d5 ?
2. 
   
3. ---
   
4. 
   
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   
7. * 形    参: 无
   " D  F- V: L. |3 ?0 U; ^7 V) {
8. * 返 回 值: 无
   
9. 
   : E& I3 k9 h. Y  [2 v
10. ---
    7 c" e( z# O% A; R# i+ L5 x
11. 
    
12. */
    ) x7 q' K2 J& r# @
13. void bsp_InitUart(void)
    
14. {
    
15. 
    
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    
17. 
    : \. u+ k( L( M# |: M2 K0 t6 b
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    ) J$ Y" D. M0 r! y
19. 
    
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    ( M; F" ]: B" s" {* ~& i( H
21. }
    

复制代码

下面将初始化代码实现的功能依次为大家做个说明。

: V- [* D3 t  ?$ k9 D( R9 E8 _函数UartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
2 Z$ t4 Z- d) q+ a2 `# Q+ h: ?5 i1 x! `
$ x$ T/ B& S# f7 S3 y. b$ T, x' _! A

1. /*
   : _% C* K4 T; ^" T2 `3 c
2. 
   
3. ---
   , u! l) T1 F  G' F* E- b5 h3 K2 c
4. 
   # }3 U% J: l6 y9 k
5. * 函 数 名: UartVarInit
   ; k" V1 j. T) h* j( \" i4 W( \
6. * 功能说明: 初始化串口相关的变量
   - x4 F" _5 J- q4 t% R$ H8 H
7. * 形    参: 无
   
8. * 返 回 值: 无
   
9. 
   
10. ---
    % D! Z8 }- p6 k! \# n3 [' v
11. 
    
12. */
    
13. static void UartVarInit(void)
    
14. {
    , r' _' S. b8 `) S) P/ H  ?
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    , \6 E4 _) D/ s3 A, J* B% ?
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    ) d. _& \4 J3 n9 W
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    # M$ r" F( e6 q. }4 W" K
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    0 }% p# e& t7 ^; T& ^
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    2 ^8 }4 R+ `! R+ F6 V
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    9 X+ f* {& d$ [
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    - g5 [4 u4 Z2 g, k7 R' d4 Y
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    2 k# r0 i2 |, G0 t
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    0 X! C. [; A! d- g9 C8 c
31. #endif
    ! ^. ?1 E2 ?' E
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

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

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   ' F: k( N: G4 V
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   , u; S. f1 ]( v" H" ^3 f
3. 3.        
   
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   " U1 U( j% R, Q' K* [& G
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   " y* Y. A+ e/ u) {" R1 O
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   
8. 8.        
   8 J. O: k6 D2 E7 i
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   # l7 R8 O' |2 b) N1 T! H, y/ `
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    8 U* e! }  i; F' M
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
      x9 l: T0 g8 @# m2 ~6 G
15. 15.        
    ! P2 n- J6 x* O% A
16. 16.        /*
    
17. 17.        ******************************************************************************************************
    ) C, E! `1 ?/ k1 B+ [" P
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    
20. 20.        *              发板
    / t/ D9 `% f3 _8 N& c# ~9 N
21. 21.        *        形    参: 无
    
22. 22.        *        返 回 值: 无
    * s. z4 e& D3 E/ j
23. 23.        ******************************************************************************************************
    
24. 24.        */
    
25. 25.        static void InitHardUart(void)
    - a0 ^# J& Z1 ~- J* ~
26. 26.        {
    ) F. u5 \+ @& ]1 P! s
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
      Q8 B9 d8 X& E- k" `/ G
29. 29.               
    
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    / S! i# a# l" |# q# J8 O
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    4 _# ^0 f- W2 _* g1 S/ A7 w1 ]5 x
34. 34.            */
    3 ?+ ]  Z6 U3 i$ ~/ }$ B7 x5 j
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    
38. 38.        
    0 |- e) ]3 s% w8 k3 _
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    9 h6 L- i# l. i: B
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    ' t- p; `2 W- o* m# @% t! U! n9 L) h
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    6 f( H! R, s1 K3 p4 T5 X
44. 44.                /* 使能 USARTx 时钟 */
    ; y0 U) h2 `1 W, c% ^( i) R# p
45. 45.                USART1_CLK_ENABLE();        
    / ^- y, ~+ T' X' H7 z/ r; L
46. 46.        
    
47. 47.                /* 配置TX引脚 */
    
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    - S) p# W+ y6 E  {+ p7 N
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    / M7 f9 S+ n. n8 O5 g
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    : r) ?- ^# e0 o; M2 i
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    ' }. H: r$ U1 o' y
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    ( X/ n- P2 c1 t2 A  I7 ~& P! V( O
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    % V+ @5 ?; E8 C) r' e
59. 59.        
    + s1 l! B( S: q5 S* _
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    
63. 63.         
    " c2 P' P- c9 c4 T
64. 64.                /* 配置波特率、奇偶校验 */
    
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    5 p( e5 w; @; a0 ?! f. m
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
    ! d1 t8 c" N2 M# A7 {
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
71. 71.        #endif
    3 v; s* r- h! v' t" |
72. 72.        /* 串口2-8的初始化省略未写 */
    / U0 c4 k) o2 s* D
73. 73.        }

复制代码

: M. D) k" ^. d第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
) ~2 K' ^( `6 q% D: l( C8 T第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
5 {* p6 Z/ o( q9 K' b1 ~第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
- q2 K$ o6 u& a' G- m第65行，配置串口的基本参数，具体配置在函数里面有注释。
0 q% m1 w, F& B, g7 C                                                                                                                                                
' q! `9 o, F; e/ K# x5 x: ~. g

1. /*
   % r# n/ ~  S0 E# y/ K, [; F
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_SetUartParam
   
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *        形    参: Instance   USART_TypeDef类型结构体
   8 ^/ o" G/ c! U) B) Y
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   # h9 s8 L- q+ M) J3 A" c" {2 J  ?
9. *        返 回 值: 无
   ) d6 E) D  ~/ Q2 @1 u, _( C) S0 e
10. *********************************************************************************************************
    
11. */
    
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    ; e( z) U* y, F5 X+ R: T6 d
14.         UART_HandleTypeDef UartHandle;        
    ( m2 }2 ]5 u* D
15.         
    $ ]8 V! p2 ~: I. }) j/ j" [
16.         /*##-1- 配置串口硬件参数 ######################################*/
    3 X( t4 Z* K5 K1 k: v" Z. A& a7 I
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
    & b3 c$ h8 U; Q" k& l3 b
21.           - 校验    = 参数Parity
    2 ]9 ~& Q# h/ |8 _7 O0 s
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    
25.         UartHandle.Instance        = Instance;
    
26. 
    5 h3 T& X+ b2 w( F& t
27.         UartHandle.Init.BaudRate   = BaudRate;
    9 C5 d1 \: i+ t( E# q
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    $ m* H6 e- B2 x9 `1 z/ u( v1 {
32.         UartHandle.Init.Mode       = Mode;
    
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
      d! H, S, {2 c! J
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
      H- z2 g' h5 _! k$ T7 p5 o
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    6 F$ [, K$ V& {
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    ( n& T4 ^- T4 P: o% c3 @
40.    
    
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    ! [. c) q1 U5 I6 v
42.         {
    4 S" \# J0 H, I# h1 K% ^
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    + C+ w, |8 R$ @+ k
45. }

复制代码

9 b: y5 [( E, ^: e5 z' ]- G! B
9 U: x0 d2 M" i9 U; @函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
6 e! N0 ~' J) t9 |
' q: Y: d9 D; p+ e% O7 p

1. /*
   2 }: u" G4 H8 A7 r# F$ q: }' O. K
2. *********************************************************************************************************
   
3. *        函 数 名: RS485_InitTXE
   6 B0 P4 e; V0 U! w/ {9 a
4. *        功能说明: 配置RS485发送使能口线 TXE
   2 B# _; J0 U) ]. ?" S
5. *        形    参: 无
   . G4 m! V# ~& T% n& z- J1 [8 C0 G
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   " C$ p- o% W' P& _+ ?5 M
9. void RS485_InitTXE(void)
   & P  Q: r# n' ]. B. a) r
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         
    9 ^, J! P. R% \- J
13.         /* 打开GPIO时钟 */
    
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    
15.         
    6 ~- n) F) f4 m% F6 l
16.         /* 配置引脚为推挽输出 */
    7 T, l4 b9 e3 s. l" ?
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    4 X2 w7 P( b! [* [( M
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    , J* {7 H! r1 F6 D" d
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    0 u) D6 [1 n  X* e3 l2 R
22. }

复制代码

30.3.4 串口中断服务程序工作流程
# x8 A* r. \  r9 u串口中断服务程序是最核心的部分，主要实现如下三个功能
  p5 s, s  ?; ]* g! _
8 _$ R, R# ?* z4 ~7 }& }收到新的数据后，会将数据压入RX_FIFO。
9 W! q6 P$ X, u" L4 \/ [检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

下面我们分析一下串口中断处理的完整过程。
3 c0 ^1 Q* S6 A当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
0 _+ u5 D# j1 ?$ p( A! ]
- b  P2 V& Y9 J* C5 R8 a9 `' u' T- s我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：

1. #if UART1_FIFO_EN == 1
   
2. void USART1_IRQHandler(void)
   ! F# J* u4 T3 d  I4 m
3. {
   : f$ {1 z5 f/ l# q9 W5 h2 l
4.         UartIRQ(&g_tUart1);
   ! e$ u& Q6 H* \2 a9 A
5. }
   : S3 y0 _% o/ _
6. #endif
   , M& q* W# O! l1 V2 B/ q, R( j
7. 
   % V3 C8 n% j$ p* }0 m
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   
10. {
    
11.         UartIRQ(&g_tUart2);
    
12. }
    
13. #endif
    : a6 t' e5 [5 T7 N; C5 Y2 S$ s
14. 
    . b1 e3 O7 u9 t4 q8 f& j$ l. B3 I
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    
17. {
    
18.         UartIRQ(&g_tUart3);
    & A* W( B7 l. J# f3 b) h! B! U+ t
19. }
    . k! H% c& @. P+ W  }3 }2 g
20. #endif
    * E" v) T- J" D5 y
21. 
    # ?* o/ u8 X4 r# E
22. #if UART4_FIFO_EN == 1
    & n5 b2 I9 w* T& U/ b
23. void UART4_IRQHandler(void)
    
24. {
    # X( y( ^) J& ^5 b8 D
25.         UartIRQ(&g_tUart4);
    8 u$ |7 |% r4 d4 i0 u
26. }
    
27. #endif
    + r" z4 w* w& C) X
28. 
    ' u' V( I. W$ X% b2 V0 K; d1 t. d
29. #if UART5_FIFO_EN == 1
    
30. void UART5_IRQHandler(void)
    : C! x) S, o5 q
31. {
    
32.         UartIRQ(&g_tUart5);
    
33. }
    
34. #endif
    5 U0 f3 i3 Z# J. i
35. 
    
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    
38. {
    ! n) M; L2 ?2 p  w* {2 @' y
39.         UartIRQ(&g_tUart6);
    2 o3 Q8 o# D! Z: x) w( X5 q
40. }
    5 V0 W( K0 a# a6 }6 p
41. #endif
    
42. 
    
43. #if UART7_FIFO_EN == 1
    / ~, @' B. I2 [2 q8 W* v7 g! E
44. void UART7_IRQHandler(void)
    9 ^+ {% @+ \5 I% k) R$ C( H1 a" A0 {; o- N
45. {
    / q8 j( p' s( \" T
46.         UartIRQ(&g_tUart7);
    " n  l  C) p# k5 c: h$ ~2 m  v
47. }
    
48. #endif
    
49. 
    
50. #if UART8_FIFO_EN == 1
    + n& n  T0 l" C, Y( d: i5 g
51. void UART8_IRQHandler(void)
    
52. {
    
53.         UartIRQ(&g_tUart8);
    # t8 C( [  [2 m
54. }
    , M5 ^( e0 y* V& K  ?0 {
55. #endif

复制代码

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

: Q2 \8 f& r: _# w& G& J下面，我们来看看UartIRQ函数的实现代码。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   8 O% w! J7 g1 I9 t: n
6. *        返 回 值: 无
   - q: @5 w. _) |" E$ p7 q( h
7. *********************************************************************************************************
   ; F$ A( e: e2 i
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   , H, Z+ `4 D- o9 p  h& z! N
10. {
    2 V0 b) |2 C' i" s  J
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    1 f: C4 `/ ~0 O9 o& N
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    5 }5 z9 C, T, j4 |) |$ z
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14.         
    
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    # l7 A1 r, y; S$ U. S
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    / Q8 B. c% ?/ n$ _
19.                 uint8_t ch;
    
20. 
    * m6 [! n4 ?% `/ F
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    / w/ b( i& n; K. j6 f
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    $ {' U4 t' N/ z. F
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.                 {
    : m9 d7 t+ e- X4 K* q% Q; p" k
29.                         _pUart->usRxCount++;
    
30.                 }
    
31. 
    - X7 h8 R& L0 M+ C$ y" J/ F
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    9 C) X1 g" c# ~$ P8 v9 J9 e# o: E
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    
36.                         if (_pUart->ReciveNew)
    ( g, r$ X1 |- U$ r2 x& }
37.                         {
    4 d2 l/ ~8 t/ k5 m6 b
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    
40.                 }
    
41.         }
    
42. 
    
43.         /* 处理发送缓冲区空中断 */
      s( d/ }6 W- i' x6 b, b
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    ' S. q" A& z! K. p
45.         {
    ! ]/ s! d  f3 g- O! F8 [  B# _
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.                 {
    4 D2 j/ D2 T! d  \+ k
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    7 K1 o0 R8 G9 {6 B
52. 
    : w- g  c# e' O8 L
53.                         /* 使能数据发送完毕中断 */
    
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    5 R* d# R, L$ R0 d% M% p: i8 e
56.                 }
    9 \  u6 r9 E8 q% P/ j9 ~9 ?! r
57.                 Else  /*　还有数据等待发送 */
    
58.                 {
    
59.                         _pUart->Sending = 1;
      L, T, H( R; ~1 I+ I) ~2 f4 s
60.                         
    - D, X) I% C, G& L
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    
66.                                 _pUart->usTxRead = 0;
    2 l! z# s0 R+ o) X# W  M$ ~
67.                         }
    
68.                         _pUart->usTxCount--;
    
69.                 }
    
70. 
    
71.         }
    / j0 W  Q2 @6 X6 n6 `3 \
72.         /* 数据bit位全部发送完毕的中断 */
    9 O& m& N- [1 F5 F+ d2 P1 @
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    : b0 r2 |  |4 f0 B7 Q1 P) e
76.                 if (_pUart->usTxCount == 0)
    5 _% E  [2 f: R/ h/ Y$ }# M6 V
77.                 {
    # w& {& {2 o" m9 n0 ]7 z7 O! J1 I% T" S
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    : z- D& u# e" x6 W! u
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    4 g, V" `# ], x0 f) d
81. 
    ! G: M% d; w" C: ?% c. n
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    ! L2 X% y- h! Y( U- L8 c3 Q6 ?
83.                         if (_pUart->SendOver)
    . {; W9 ?5 u- D5 u8 q
84.                         {
    
85.                                 _pUart->SendOver();
    % G& D# _, m, q9 l
86.                         }
    
87.                         
    " r6 H7 a4 H- W! j9 G
88.                         _pUart->Sending = 0;
    9 E! o$ Z- n% |/ Y9 N: P8 W
89.                 }
    
90.                 else
    5 H1 O5 X4 \$ k7 E
91.                 {
    
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.                         {
    2 z" Y% i, h' M% r
99.                                 _pUart->usTxRead = 0;
    4 z7 W0 p4 b0 Q7 d
100.                         }
     
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     4 |% J  f0 F6 V5 E. [6 \0 e( Q
104.         
     
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     ! i2 I! k% e) U5 O
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
       \* {. X* ]2 y
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     ' W5 v- y* X# e4 d2 ~: W
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。

( N2 q% m& a( a, D& s5 v% f6 c  接收数据处理
; L. F6 p- v/ C" x. j) N" H6 d接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
# T  D4 ?4 W4 z
$ _7 \: w! H+ [8 b  发送数据处理
' e6 ?+ A! m" Z, x发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
. r9 ?7 ^# z+ n9 a& C: M
30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：
3 B& a) ~- c/ P; @6 n4 ]' ~* u
: g+ V  B) D( b$ W3 X

1. /*
   5 t9 X- F. f, v( g, U; Y
2. *********************************************************************************************************
   5 r+ R  w6 D  I
3. *        函 数 名: comSendBuf
   
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   0 g: e6 C. ~" c6 z2 Q
7. *                          _usLen : 数据长度
   4 d" O* |* {1 N) O. \( P2 ?
8. *        返 回 值: 无
   2 }& s# I4 H3 a1 ]- O
9. *********************************************************************************************************
   
10. */
    # S# {/ U# C0 m7 ~1 E# _$ s9 B& D9 S) h2 N
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    0 O/ [: z( O+ J+ y
12. {
    3 E1 U* I5 J4 z( H1 x: V/ c* O0 \5 a
13.         UART_T *pUart;
    
14. 
    
15.         pUart = ComToUart(_ucPort);
    
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    ; }2 K. B: U% e8 a
19.         }
    - u; ^$ {8 N6 d0 V- f4 @& j
20. 
    
21.         if (pUart->SendBefor != 0)
    
22.         {
    
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.         }
    4 a! j# V& m) L2 V" D* t7 e* D
25. 
    ; D/ q" w! Z$ C& N$ l* e
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    8 k! W! ]$ t( O$ {  U
28. 
    $ e8 W% g  G6 x: C$ X
29. /*
    
30. *********************************************************************************************************
      F3 _8 @& i/ I* u$ t8 A% A6 O
31. *        函 数 名: comSendChar
    
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    6 e0 `, c, F. P% N, s
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    
36. *********************************************************************************************************
    
37. */
    
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
      @; s3 [/ r; z6 J! f) [9 [1 M
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    ' C. b& ?3 K- R6 |( M4 r3 y9 X2 y
42. /*
    
43. *********************************************************************************************************
    
44. *        函 数 名: UartSend
    - k; Y: ]  r8 ^% f9 K' q) c
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    
47. *        返 回 值: 无
    
48. *********************************************************************************************************
    
49. */
    ) ^4 s: z- Z5 ~4 d4 R& l! w
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    ) N4 b' }  X% g$ W9 U$ R# s2 z
51. {
    
52.         uint16_t i;
    $ r3 [9 o7 U; ?6 H6 m
53. 
    
54.         for (i = 0; i < _usLen; i++)
    
55.         {
    . u$ d# Q# N1 A2 i$ {
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    , i( S+ q- m, U0 v2 d
57.                 while (1)
    & s* }. s; W2 H  u5 P" q5 v8 L4 m
58.                 {
    ' X/ n! [  k% a4 u. K; ]# Y9 C
59.                         __IO uint16_t usCount;
    + C, o. |  }# r9 g! P; ?, d
60. 
    + v6 \5 S0 S7 v/ _( J
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    7 ?, u+ Q& H5 o2 M* b9 h8 f
63.                         ENABLE_INT();
    
64. 
    6 a6 N# @+ z, \8 {2 C8 K
65.                         if (usCount < _pUart->usTxBufSize)
    " F# H2 Q/ u; ^# ^
66.                         {
    * v" t$ }( t- k7 y
67.                                 break;
    
68.                         }
    ! ^9 r6 @5 S( M  E9 ~
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    0 q- p2 W& q9 U* |! j1 s# R4 j
70.                         {
    / v+ ?. ~$ P" @7 O" w
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    ( a0 c! E# {7 u* J2 S
72.                                 {
    
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
      a: j! j1 L$ a8 R. a8 G
74.                                 }  
    3 @8 E, p6 C- T; A- ?9 V5 }
75.                         }
    8 f$ v* J& q! o& K7 N( c1 y( a; u* r
76.                 }
    7 X+ N  O5 k0 v% r
77. 
    
78.                 /* 将新数据填入发送缓冲区 */
    
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    9 c% z; @, |5 W0 _7 N
80. 
    2 @: c+ {" E0 h
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    5 E' U! F8 F  s0 ?* ~
84.                         _pUart->usTxWrite = 0;
    
85.                 }
    7 [" m4 |, L; \+ k
86.                 _pUart->usTxCount++;
    ' Y- J# k0 N4 X4 Q7 u) n) W
87.                 ENABLE_INT();
    
88.         }
    
89. 
    
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    # }6 r4 K, \4 w; _- C4 h7 M7 t8 T: `
91. }

复制代码

' Q1 D5 I0 D7 K函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。
9 p; _$ ^; B& W  S8 j8 h
1 O; P; P  B% ?/ @1 T# `$ D4 b函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
6 U2 \  j3 a# c* I; X
  H6 Y  }9 E3 k6 O  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
4 B8 Q; k: s" n' b' ]4 g' v; n  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
( c: c5 {7 X3 b; q0 h4 h0 R
注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。
. L5 ?7 B8 j  m2 M- Y' d
  m& _2 ]8 I, k5 D: m) s( n8 I2 T5 V4 K函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

+ u* |9 }+ j4 o$ w8 f& e# B

1. /*
   % z, I9 V7 E) t! w& Z% ~0 X& t
2. *********************************************************************************************************
   
3. *        函 数 名: ComToUart
   
4. *        功能说明: 将COM端口号转换为UART指针
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   8 Y  W' Y7 o' C2 \$ }& o8 w
6. *        返 回 值: uart指针
   . u' V/ K! Y# @' \" z1 M+ b
7. *********************************************************************************************************
   ! N, \% k. @* p4 |6 |5 {* m
8. */
   ! c. Y* A" _7 j4 R+ i3 ^, n/ c
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   
10. {
    
11.         if (_ucPort == COM1)
    
12.         {
    
13.                 #if UART1_FIFO_EN == 1
    7 w$ G7 z3 O9 O/ l3 @, N" E
14.                         return &g_tUart1;
    
15.                 #else
    
16.                         return 0;
    . E* G7 w- r3 N& @, N/ y" c
17.                 #endif
    
18.         }
    " P) Z- O# z& w& R$ i
19.         else if (_ucPort == COM2)
    8 w) q  }/ h2 @! ^/ F8 F+ s/ q
20.         {
    
21.                 #if UART2_FIFO_EN == 1
    
22.                         return &g_tUart2;
    
23.                 #else
    
24.                         return 0;
    
25.                 #endif
    4 Y7 F) `) q, ?' C. n& c" z
26.         }
    
27.         else if (_ucPort == COM3)
    
28.         {
    
29.                 #if UART3_FIFO_EN == 1
    ( G0 Q6 x6 W( f3 w
30.                         return &g_tUart3;
    1 o7 C$ M  H8 W$ W4 N
31.                 #else
    1 q! R+ B; x- ?+ I
32.                         return 0;
    
33.                 #endif
    
34.         }
    4 d" p. H7 }) o( f& Q
35.         else if (_ucPort == COM4)
    
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    5 F# a$ Y% |3 z# c1 s7 G# {6 t# H) ^: J
38.                         return &g_tUart4;
    * D  j3 v$ P* @1 N
39.                 #else
    ! `0 B: n, q8 Q/ R- p* |1 ~% A& W0 |
40.                         return 0;
    
41.                 #endif
    - U+ b! H8 |7 [% L7 ]( f* \# F
42.         }
    
43.         else if (_ucPort == COM5)
    % E* ^1 R- F( G- n3 H) G3 u5 ^
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    # b( k- ?. N! I' `1 |! \  y: t
46.                         return &g_tUart5;
    5 Q- s- }6 p5 f5 J% A; ^: O
47.                 #else
    
48.                         return 0;
    : m; h1 b8 H; @0 {5 B2 i, S! ^
49.                 #endif
    
50.         }
    
51.         else if (_ucPort == COM6)
    
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    & [( e3 A! O( i8 Y& F$ D
54.                         return &g_tUart6;
    
55.                 #else
      j5 X$ D4 S9 u9 a5 b
56.                         return 0;
    
57.                 #endif
    
58.         }
    
59.         else if (_ucPort == COM7)
    
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    * y+ `$ c* y1 |
62.                         return &g_tUart7;
    2 N6 m2 m* M% h- R& f* f
63.                 #else
    5 j; g6 ^; p2 D( T( k3 C
64.                         return 0;
    ) L2 k) j; N8 {" T9 ~5 E
65.                 #endif
    
66.         }
    
67.         else if (_ucPort == COM8)
    
68.         {
    7 B1 _8 c8 w: ~+ p' J( o& k
69.                 #if UART8_FIFO_EN == 1
    ! i" M& D3 Q: o$ P. M# l# l5 |2 h# c# G
70.                         return &g_tUart8;
    
71.                 #else
    
72.                         return 0;
    : R1 L- U3 m/ l* e# }2 M' p7 C
73.                 #endif
    
74.         }        
    ( V. F: C/ l% v* F$ [- I5 s% h
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    
78.                 return 0;
    . \* T6 k) Q* j% V4 C& v9 N& Z  j1 a
79.         }
    
80. }

复制代码

2 f$ J" J& F: N3 O30.3.6 串口数据接收
下面我们再来看看接收的函数：

; i5 E9 W, F% a

1. /*
   ! p( i2 p$ Z( b; m( S+ n7 u7 S
2. *********************************************************************************************************
   . B, T) V( Y: Q* S, o0 H3 I$ ~
3. *        函 数 名: comGetChar
   / r: [  N# Z! s0 M
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   + m, n  F" S, c. S0 B5 S/ b
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   % O+ t1 z. A% i8 S4 R
6. *                          _pByte: 接收到的数据存放在这个地址
   , {! u. Q2 Z8 B/ S- c
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   * o8 Y0 T( r8 Y* q* R% n
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    ' V5 M4 i2 @/ F- x- j
12.         UART_T *pUart;
    # C3 H) Z8 ?. L7 B
13. 
    . |$ S1 `2 I8 i7 d+ ?" A# S+ ~
14.         pUart = ComToUart(_ucPort);
    
15.         if (pUart == 0)
    4 f- M, `  w2 ^$ y' G' w
16.         {
    
17.                 return 0;
    
18.         }
    * k/ Q7 C" K6 F; v. C) f
19. 
    0 a; p7 T: X3 H3 @% X" l
20.         return UartGetChar(pUart, _pByte);
    
21. }
    
22. 
    8 b) n/ Y; N0 O+ K7 I
23. /*
    
24. *********************************************************************************************************
    , q  B( N/ j  \# B1 A; e# X' \( l- q
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    3 H" W( X" ]5 q  ^
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    ( }7 n& [: ?& l5 Q
30. *********************************************************************************************************
    1 N3 q5 g: h! u7 Y" O0 F$ k) U& p8 J
31. */
    
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    8 V* n4 b6 f$ ^: U
33. {
    $ b. g; }9 [+ K* J
34.         uint16_t usCount;
    
35. 
    ) Z2 ]( N" R0 l9 j
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.         DISABLE_INT();
    1 w3 p! {* b, b) e! M: i0 V$ z4 f
38.         usCount = _pUart->usRxCount;
    
39.         ENABLE_INT();
    : O* K' p' [4 ^" l$ B/ i
40. 
    4 r! d' x$ j- i. ]; E% S% h2 P
41.         /* 如果读和写索引相同，则返回0 */
    
42.         //if (_pUart->usRxRead == usRxWrite)
    
43.         if (usCount == 0)        /* 已经没有数据 */
    ) s- z8 c% r3 A+ j4 m/ U% _
44.         {
    
45.                 return 0;
    
46.         }
    
47.         else
    ' w3 _+ q2 f6 b0 }/ z! C
48.         {
    
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    ! p  [, _( Y1 f1 ^5 X" T
50. 
    
51.                 /* 改写FIFO读索引 */
    
52.                 DISABLE_INT();
    
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    0 x- I1 u, V. [9 d9 _4 t8 r
55.                         _pUart->usRxRead = 0;
    # i( `$ t4 p: ]7 W$ o1 P* m/ I& P
56.                 }
    
57.                 _pUart->usRxCount--;
    % D) M2 x/ L$ Z
58.                 ENABLE_INT();
    
59.                 return 1;
    
60.         }
    
61. }

复制代码

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

0 l' g  r1 m" s2 e6 o0 e6 D8 F注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

30.3.7 串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
1 F/ G6 {# b6 O
; ~4 e/ O% h- P% d( q2 p/ f. v# ^为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
! D5 W$ d3 L$ J0 W/ B5 b
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。

1 i7 f: H9 U" o  _: I; \% U实现printf输出到串口，只需要在工程中添加两个函数：
1 f/ J4 B/ w9 ^4 M
& o0 B5 \; V% q3 `$ b

1. /*
   
2. *********************************************************************************************************
     {* m9 \* T5 o  ]
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   5 n' X* e# P# m
7. *********************************************************************************************************
   : M+ t  R" n. }: X; b( T+ Y" {
8. */
   + V) I  [; Q; ]8 w0 N( T" F' D
9. int fputc(int ch, FILE *f)
   7 h  V1 R! P3 z2 u) {
10. {
    ! d% m/ n: e0 e. ^# D  `# w
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.         comSendChar(COM1, ch);
    / i, Q: h0 Q; v" U
13.         
    ) a9 ~8 c5 U- l6 b
14.         return ch;
    
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.         /* 写一个字节到USART1 */
    ( }2 t# I0 P  D" l7 Q5 a
17.         USART1->TDR = ch;
    / z; `  H  a# R& ~5 {
18.         
    
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    
21.         {}
    7 x0 H+ X1 V; y! b# W, [; U
22.         
    ! H, P" ?4 }) @& K/ _4 G
23.         return ch;
    , C( R' _; |" @/ {" u- ~
24. #endif
    
25. }
    
26. 
    0 W1 w' e6 I' ?; E# X# k# {
27. /*
    
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    # _9 v. H/ K2 P- G" F1 }; @
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
      S/ N& f5 n/ d1 E( C9 s
35. int fgetc(FILE *f)
    ; `, @6 A2 E5 j, D2 X( _6 v' l: m
36. {
    $ V- Q0 f' A; k1 q9 u
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.         uint8_t ucData;
    
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    
42. 
    8 k7 p- R) o3 O. s
43.         return ucData;
    ! }, [, z" [) i4 c# \+ H0 W! {
44. #else
    # Z2 L9 q2 }) H8 g; R' ^5 {
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    # L5 F, u7 a- {- i1 D* e
47.         {}
    
48. 
    
49.         return (int)USART1->RDR;
    % E8 n5 J9 Y6 u" K7 {) e  y6 T
50. #endif
    3 o$ s, A, u& ]2 t' g
51. }

复制代码

printf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
5 }* Y8 y9 @% ^9 [: Q, r' [# C* x( e
30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
$ u# [, f1 R  q+ x/ h, Z串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

  bsp_InitUart
  comSendBuf
/ d3 K2 X# ?9 U8 w7 J  comSendChar
  comGetChar
$ L$ c; q8 m& K8 ]. U! [7 J30.4.1 函数bsp_InitUart
函数原型：
4 |, N. ^2 E8 S( Cvoid bsp_InitUart(void)

函数描述：
* s: e& \* O0 L# E! u6 E此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

- q# [& i8 G7 j! @- _% e使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

7 q* a; U& n% z30.4.2 函数comSendBuf
5 a' B; t/ W5 p8 e函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);


1 F& [. {: `! _函数描述：
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：
3 e8 m( ^: v* {- ^1 G  第1个参数_ucPort是端口号，范围COM1 - COM8。
* S( c" X9 j" a7 B; m9 K  第2个参数_ucaBuf是待发送的数据缓冲区地址。
: j! M$ V; N5 g6 |/ E. Y$ I/ D  第3个参数_usLen是要发送数据的字节数。

, q( L: }/ ^$ S# q) {' y
- X$ r$ \$ Z, s% R4 X. v注意事项：
  此函数的解读在本章30.3.5小节。
( k5 n5 J2 o3 W7 j: l  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
: e7 j  j8 u. ~' g: Y8 v
: V) ]9 w4 Q% H' [4 p" K: K  f
使用举例：
" j; b0 k5 D- w5 N' N" g调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

const char buf1[] = "接收到串口命令1\r\n";
# P& s& B$ B0 A$ D" e8 tcomSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
$ u' _3 ]; @8 @2 T. S

30.4.3 函数comSendChar
函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);


4 l! |7 {1 n, |; H" X: ~函数描述：
& ?. h& z5 q/ ~3 G; K! M9 z! A
6 S, I: g8 S$ ^; l此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
! K& c9 A$ y+ f! M" C
4 h8 `7 w9 v7 f" G) r  \$ F" z函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucByte是待发送的数据。


4 R; i- r) S" N6 C0 k注意事项：
" l9 a1 p5 G2 z3 O5 W  此函数的解读在本章30.3.2小节。


# p9 Q4 q4 O8 {# P使用举例：
- A( n# E2 Q- G' {+ A调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。
5 j/ k6 p* c) s0 c' n! y5 ~
  ?& s% Z# `; o% }# \, Q30.4.4 函数comGetChar
函数原型：
9 M  W2 D) c, I7 a! q9 ?uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)

3 B; C0 n; E, O
/ |" N/ \( J5 k  E2 g函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
" w. T+ f$ j/ U$ B
4 X* ]2 K/ d" g$ s! k! t
注意事项：
  此函数的解读在本章30.3.6小节。
! K0 ^# k& G$ K
% J7 o$ ^3 z( ]% H3 M
, n0 K8 x3 Z; q/ U1 ~8 \" s; F, S9 d使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
% ~: ]+ h0 m3 u4 C9 V. k6 ]( Z
( x) K& u8 X( }5 ]/ r* P: ~1 k比如从串口1读取一个字符就是：comGetChar(COM1, &read)。
" T' V# H8 t. j1 R2 t2 O
, U* ?- O( C3 V( y4 f30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：

  e- |) s1 P. R9 O  ^# G" o$ R  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
) v' P' b8 g; `3 f% u  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
1 [' M: X3 e- @2 z6 ^$ h5 s

1. #define        UART1_FIFO_EN        1
   : f8 d& I$ O. o: Q; z8 B
2. #define        UART2_FIFO_EN        0
   
3. #define        UART3_FIFO_EN        0
   & g5 L# i/ N' ^, M4 O
4. #define        UART4_FIFO_EN        0
   
5. #define        UART5_FIFO_EN        0
   $ j- @5 h8 [. Z9 g# B0 ?
6. #define        UART6_FIFO_EN        0
   * K' w- r2 _1 w3 J' Q" [
7. #define        UART7_FIFO_EN        0
   ) A. Q$ s+ V! u  |  y" j
8. #define        UART8_FIFO_EN        0
     A4 r; t& B' h1 e. \
9. 
   
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    ; S5 v3 {' M& k# D( f8 r5 I2 n" u
11. #if UART1_FIFO_EN == 1
    ' E- ^- U* n/ l' _3 G1 W$ I  q. Z
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    ' Y+ r0 ]5 L4 k% x# w4 C
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    4 b" y6 ?3 ]# c- q7 x
16. 
    
17. #if UART2_FIFO_EN == 1
    
18.         #define UART2_BAUD                        9600
    . l! a9 m$ [% G3 j, n
19.         #define UART2_TX_BUF_SIZE        10
    
20.         #define UART2_RX_BUF_SIZE        2*1024
    + Z4 z4 c4 @' Q
21. #endif
    
22. 
    $ G4 I/ |1 R3 t2 e3 S
23. #if UART3_FIFO_EN == 1
      E" L* ]1 `! `. ~* w
24.         #define UART3_BAUD                        9600
    $ ]* m3 o' N7 q) J. j. X9 G
25.         #define UART3_TX_BUF_SIZE        1*1024
    
26.         #define UART3_RX_BUF_SIZE        1*1024
    ' |$ T! Q5 D/ R/ n' c3 a
27. #endif
    
28. 
    
29. #if UART4_FIFO_EN == 1
    
30.         #define UART4_BAUD                        115200
    
31.         #define UART4_TX_BUF_SIZE        1*1024
    ; p5 A8 R8 c6 O- O" Q
32.         #define UART4_RX_BUF_SIZE        1*1024
    - t, s% O2 D; v2 l  R; n% e
33. #endif
    
34. 
    
35. #if UART5_FIFO_EN == 1
    1 M! l: c8 G& c- e" b
36.         #define UART5_BAUD                        115200
    
37.         #define UART5_TX_BUF_SIZE        1*1024
    . s2 [7 |3 d& M+ ]+ ]4 N2 }# P
38.         #define UART5_RX_BUF_SIZE        1*1024
    , d4 X6 X" G  i2 a! t, J
39. #endif
    0 B; A# s9 ~$ P! _/ w; q8 j" v
40. 
    9 F7 ^1 F+ K* \: d
41. #if UART6_FIFO_EN == 1
    
42.         #define UART6_BAUD                        115200
    $ b# y( u& a0 d
43.         #define UART6_TX_BUF_SIZE        1*1024
    
44.         #define UART6_RX_BUF_SIZE        1*1024
    , D- x& }$ j$ f* f; T' k
45. #endif
    & H: j" e% d! |" ^5 K+ ~
46. 
    8 H: ]+ O( g! K1 _* Y$ G
47. #if UART7_FIFO_EN == 1
    $ |$ f' }# |& l
48.         #define UART7_BAUD                        115200
    ! |' D. D, q8 _4 G
49.         #define UART7_TX_BUF_SIZE        1*1024
    
50.         #define UART7_RX_BUF_SIZE        1*1024
    
51. #endif
    ' o1 i! e) C8 r3 a, R7 f5 @
52. 
    
53. #if UART8_FIFO_EN == 1
    9 e- V! |3 S7 k- L+ w; n0 T; x7 y5 C
54.         #define UART8_BAUD                        115200
    
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    . p0 I- L7 Y7 X8 j. y) Z* ?% t
57. #endif
    

复制代码

& ]4 {8 v7 F  q% J1 ^& n  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
! E6 G& I" m; y- u  b2 P3 s# D# H  第4步，应用方法看本章节配套例子即可。

30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
8 `! U2 b/ y7 {  g8 |
, F7 Y' P4 Y" o0 b4 R  O! ?

  第1阶段，上电启动阶段：
6 L; B' |$ I$ c# U
这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
' M% i* N" {5 X1 O# x( E# j# v
  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
! ]' _  a, Q! s% R$ I  H) h  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

30.7 实验例程说明（MDK）
' v6 ?& _5 n. c" N配套例子：
; E: S, w: E0 z0 w' C5 g
4 I% ?' `4 ?" v' U& h  ]V7-015_串口和PC机通信（驱动支持8串口FIFO）

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


实验内容：
8 u5 ^% p+ b' T启动一个自动重装软件定时器，每100ms翻转一次LED2。

  |7 {( s' n$ q
实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
- q3 e( Q, k6 ~! a* F- c串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
* g% q2 F! r4 C; p& H9 q4 {K1按键按下，串口打印"按键K1按下"。
' I0 S: q5 I0 b" V5 y9 pK2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
1 I* S: K) ]( `上电后串口打印的信息：

8 c7 Z' g! r* v) S波特率 115200，数据位 8，奇偶校验位无，停止位 1
6 h8 x$ j  _5 G0 J: J( b
6 e# E6 T, ~5 y* [

2 G( T  s  \* U; M9 O( i程序设计：

  系统栈大小分配：
$ x5 q" g. w+ D+ j5 e9 K4 w
& ]' G: \% w+ Q8 h0 c) h) ]

: _6 ]4 C/ F6 |( d  j$ H6 W; Y8 c* a
  RAM空间用的DTCM：

; m1 D5 u6 o& ~% x$ Y2 m' g% u

7 u! [( E8 z2 `4 r: H6 {- Q$ i0 b  硬件外设初始化
$ L& J4 H4 P! U! r7 s) o
  w8 z* W! Z/ q硬件外设的初始化是在 bsp.c 文件实现：
# s9 Y7 b/ t& r& Q# ]
" b1 h4 E7 G4 @. S( [, w  W

1. /*
   - b! _" k7 x2 e( M& ~  P1 y( B
2. *********************************************************************************************************
   , a' ~9 K( D4 d6 _" a' A1 J# @9 q
3. *        函 数 名: bsp_Init
   % o& ^, _& X! G4 _
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   4 C; z( [+ ]0 g- o8 s0 A
5. *        形    参：无
   
6. *        返 回 值: 无
   # H4 b- w( R/ M" |, o, Y
7. *********************************************************************************************************
   9 a/ B! ~1 w1 j
8. */
   
9. void bsp_Init(void)
   % j' w. z  R6 e3 U. o
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    2 F* Q. B" u. B0 G0 f* f3 ]1 b
13.         
    ) M# c1 E7 N& E- F( ?
14.         /* 使能L1 Cache */
    5 |6 q/ t' _* s: f$ ?% I! R8 t
15.         CPU_CACHE_Enable();
    ! M& k1 x0 c/ @2 K. F
16. 
    9 S8 }1 U( S$ v7 T" p$ J
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    2 s+ ]2 i% S7 X  S
21.          */
    
22.         HAL_Init();
    3 r: I  y# j- K
23. 
    ) W# K8 x! E' D! x1 a: G
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    , w( K" @7 `! I1 s# M
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    % p. b# `% R5 H6 ?
29.         SystemClock_Config();
    3 g8 N* S% @" {3 a4 b
30. 
    ' l; K& _: |  ?8 |- d0 S; i- T" S: H- j
31.         /*
    . w; a( C6 T) C! y! d! ~  z
32.            Event Recorder：
    / g& T) s/ ?2 ~- C
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    / B4 s6 }- m+ {
35.         */        
    9 ?8 S0 }- B% M
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    ! P$ h8 @% k, u' U
41.         
    5 u# Q/ ^) R. D, u1 M8 S# D
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    & u6 J0 ~  {9 s7 U% Z
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    1 A: W: M. k3 y& D; F: c
47. }

复制代码

  MPU配置和Cache配置：
8 j6 G* G: d  C* v( Q4 Y- H
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

( B' `: _6 o2 @5 X1 _

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   7 z% C0 T/ X1 A% T" m0 p  s1 g
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   2 S( ^: k, G, A8 ~8 w8 ^% l- Q/ p
7. *********************************************************************************************************
   ; @' |3 U6 i& Q5 e) W( [
8. */
   
9. static void MPU_Config( void )
   . a5 m7 e0 v4 |
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    * c) c8 A  X% ]/ x1 l& p; U
12. 
    
13.         /* 禁止 MPU */
    # p, L5 v2 x' T6 g/ Y+ g
14.         HAL_MPU_Disable();
    4 [1 B0 o. D! o9 ?& I
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    + t' F9 `0 k1 f, f, L
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    $ `/ k" I9 o. l; j5 `  M
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' ~9 k# B: W$ n8 @( A
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    # |5 C9 X7 `0 K5 B- E. U5 X9 G9 G
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    4 G8 c, |% ?2 L+ u' w5 n
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    ( p. z5 i. v/ o0 r8 g2 N* ^" @
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    4 k9 P. \; y- e
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 n- c' i: {3 U  C9 F- k
30.         
    ; E' G" P7 z3 J, c" I( e) Z# i
31.         
    ( N) F* V9 _9 {0 c8 }* x
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    * S! j" \5 G. m! b$ l
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 m) v  v( I$ p
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;
    ; k3 D2 c& ?1 N$ c0 V
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    * L5 X1 C7 z% v# E0 E0 E# {
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ) A7 d& D* L8 r8 F% f7 G, t
44.         
    5 `! T7 v/ H3 u  ]' x. _
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 d9 b% J8 t$ j4 M& g( D
46. 
    
47.         /*使能 MPU */
    . J' y; f" M" q1 T
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    # Y# w- l4 P& T( K
49. }
    
50. 
    ! G+ ]5 J5 E* h: L0 v
51. /*
    $ t# F/ b  l8 K; B
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
      M. D' e  ^, x
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    ! ^. F- x, @* }
58. */
    # V* K% v) W1 I% \* W  Q3 u
59. static void CPU_CACHE_Enable(void)
    ) |% W% H; a7 I3 W  v" B6 v
60. {
    / |+ I& E  T* x; t
61.         /* 使能 I-Cache */
    7 p+ A' E0 d# W; T& q& E- o
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

, h# r3 a) v, ^$ U* F# l( K1 ~  每10ms调用一次蜂鸣器处理：
, L! ~0 T3 I) R* R
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
. w+ \7 z1 t5 R% y5 z2 X3 U- t
' [5 v: u3 p/ q+ ?7 h  H3 i* C

1. /*
   , u- }8 Q: h9 R# {1 Y; K% o% E
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
     O0 {$ p6 L' X( W6 X+ n" s6 E
6. *        形    参: 无
   : @) F/ N" X0 q4 E5 F0 d& X, e, s! l8 d
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    . ?0 f1 O% d1 p! {3 z- ~
11. {
    ( c6 B7 Z$ m$ c
12.         bsp_KeyScan10ms();
    2 k, g4 y( O5 z; Z1 B- ]
13. }

复制代码

$ x6 |4 r$ c; T; z. ~) v; i  主功能：
+ Q; T3 R4 d, B3 t2 r( z4 K/ [
+ U1 Q( B4 N/ K5 g( `/ @4 c6 b主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
: B6 M& W% X, E. I; r8 A  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
8 m  Q/ C0 U, a$ c4 w: h  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
3 V9 d. g/ i3 G9 g5 L  K2按键按下，串口打印"按键K2按下"。
. D9 V2 d8 L! R) n  K3按键按下，串口打印"按键K3按下"。
6 _: J; l5 e5 u/ \

1. /*
   5 N2 g. s; J/ D
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   9 n0 a& L& h) |+ \
5. *        形    参: 无
   7 }+ h$ a* F( M% _1 R# ~1 K
6. *        返 回 值: 错误代码(无需处理)
   " P) C9 H4 N) Z. M; ]+ N+ w4 x: m
7. *********************************************************************************************************
   ! ?$ F5 v4 m- T0 g9 X0 D# s
8. */
   ) I8 N: R1 U' f! O6 M
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;        
    3 Y1 ]7 t  B8 F( o% u
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    # z' ?# k, Q- f! R1 |1 t9 e
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    
18.         
    / D* R5 {/ f  p" V: R
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    # m( c8 E% }- r7 J
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    3 c  D+ [' q. @6 ^3 v  H
22.         PrintfHelp();        /* 打印操作提示 */
    6 b2 _9 ^  |' I3 J
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    2 w. m6 F( ?1 E' W8 y* J, B3 M
25.         
    3 i! X  i- P" z# y2 E% N$ F8 I, X
26.         /* 主程序大循环 */
    
27.         while (1)
    7 F3 c3 S) Y, K2 W" Z% _) D
28.         {
    + M' O- d+ l& m4 t6 H
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    ) F- K( p+ [& g
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    7 X* ]5 [6 E$ d3 m& T4 b, F
34.                 {
    4 ]! l* z$ D  y7 y/ ~+ X
35.                         /* 每隔100ms 进来一次 */
    * b7 E( B+ l! u+ G! w9 C
36.                         /* 翻转LED2的状态 */
    + ~9 q+ A" Z2 `8 j8 ?3 N" J- ]
37.                         bsp_LedToggle(2);        
    
38.                 }
    ) A6 k0 l/ e9 l3 v9 _' _
39.                
    
40.                 /* 接收到的串口命令处理 */
      m/ k3 q2 S" r) `: w% V/ {
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    . @, a- K3 b2 {
44.                         {
    ) s, Y% ~+ @" h2 z
45.                                 case '1':
    . b3 t, o- k3 ~
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    , z) f1 Q" u" w* c# P
47.                                         break;
    8 \5 e8 z, S6 y' T( u' x  v+ g+ B! w
48. 
    
49.                                 case '2':
    0 z) f+ L6 {4 |% c( P/ j
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    ' a) \: {' L* J
51.                                         break;
    / ]  U" K3 ~, M7 q
52. 
    
53.                                 case '3':
    # W6 v- p  x/ l! G
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    ' _/ a/ [7 H5 f6 N) r3 G4 B4 E3 ]
55.                                         break;
    . c" \8 J3 d6 [! |
56. 
      Q/ a$ z7 r) y8 V; I4 M( j
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    
60.                                 
    . i' E4 e1 g) [% Z+ q
61.                                 default:
    
62.                                         break;
    
63.                         }
    
64.                 }
    . z( x+ ^( l. v  r# y* x
65.                
    ) m5 F6 ~: u7 }  \6 u- G
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
    6 Y" x( l. X3 C/ u1 L, {( B3 _
68.                 if (ucKeyCode > 0)
    
69.                 {
    ! j& o7 g) y/ {' a) V6 M& Y
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    0 I3 K$ K+ W2 u8 \
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    ) w  k% ^" F/ J4 e# G+ I0 \, T2 F) }
75.                                         bsp_LedToggle(1);        
    2 m# T, C) ]. c
76.                                         break;               
    2 Q# P3 o2 y0 K) p% t6 t; V
77.                                 
    * E3 c, r6 S5 s
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    , X" Q) g6 U9 q+ [
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    " N' C8 j) Q. I+ |1 f; s% E3 F
81.                                         break;
    % l8 C6 O, X* ?0 C) K
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    ; S- Y' d! w* f: P, F; u: i
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    
87.                                 
    
88.                                 default:
    $ f' A. b( J' \9 C% b9 E9 r
89.                                         break;
    2 o. K3 s6 n4 T4 o
90.                         }
    
91.                 }
    
92.         }
    
93. }

复制代码

30.8 实验例程说明（IAR）
) u! v: U* l- F" g8 c配套例子：
/ f+ `" U& d: @. ?
0 e1 R% v) J5 F2 H  @V7-015_串口和PC机通信（驱动支持8串口FIFO）
; {# g/ I: m, q3 T+ ]* ^3 @
实验目的：
2 h# B6 r  E' `5 w; m+ J$ m  M学习串口与PC通信。
6 p$ D; |/ p, h& ]1 X) i2 s3 S, H
  y1 E4 m. x7 B# {. V) y
实验内容：
+ C# A  v1 P9 N5 I启动一个自动重装软件定时器，每100ms翻转一次LED2。
9 m7 Y; o6 A' J' ?( ^

实验操作：
/ j6 j- ?3 `8 d  L) g8 b串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
! f* a+ N7 e9 p上电后串口打印的信息：

% U4 w( {1 g+ Y+ @波特率 115200，数据位 8，奇偶校验位无，停止位 1

" W. O8 j. g- y2 k

程序设计：
) Y/ q6 m5 I. ], R& d
. R& f( e+ g8 Q1 b! _: l   系统栈大小分配：

) Z! z# m3 H' L

& S; T3 B2 W% j5 R0 X" K- l
   RAM空间用的DTCM：

4 l. b/ m" ]/ X, o& N0 h) X  硬件外设初始化

( }7 V. W% a. K' k  `硬件外设的初始化是在 bsp.c 文件实现：
; s2 I) u3 X  m# N. j4 f
' w: ^1 n4 H/ u$ L& G+ M5 N

1. /*
   2 B+ D, c0 @( {& X8 ^
2. *********************************************************************************************************
   9 x5 T. M$ ~3 w; r# G
3. *        函 数 名: bsp_Init
   8 D0 C; s- A+ ^" b. q* Q
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
     a$ x% c6 w3 w
5. *        形    参：无
   
6. *        返 回 值: 无
   # ?1 K8 k& G/ U) F7 _
7. *********************************************************************************************************
   : W$ G7 u: `$ q
8. */
   4 @% k6 J7 B; Q- k5 W
9. void bsp_Init(void)
   5 I; l4 i& ~1 d/ i7 M6 z( A
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    . `2 j) X+ t% U! y8 w2 ~) R. c
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    5 [' K5 ~$ c+ f# `. U2 U0 P# t
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    * K7 c8 A# P  q  B5 G/ ?+ ]
22.         HAL_Init();
    : G- F/ j( P' @/ v8 W6 b8 V
23. 
    $ |1 U" R0 T) w
24.         /*
    
25.        配置系统时钟到400MHz
    * A" y" I5 T7 i7 E
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    " S* V/ Q4 F& t9 o7 v! N& _
31.         /*
    
32.            Event Recorder：
    " i( ]1 E9 m& g2 e" x8 v5 \
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    ; P& L" L8 [$ M- M, Z1 F
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    ( w. g9 \  [# ~# a0 X$ H- t
39.         EventRecorderStart();
    * J$ }: D) |. O4 z  d1 `
40. #endif
    : Q; A9 D. o5 D: f7 B% l
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    + p7 o; _% W& A8 ?2 I: j# N# }2 m
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    + X6 T& r( e9 B" _
46.         bsp_InitLed();            /* 初始化LED */        
    + H' r' N9 m1 q; J- c% Q3 W' D
47. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   8 e0 z; B8 y0 B
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
     {; Z! M) ~& M3 ~- X4 h
8. */
   " b  L8 j  n* ?3 r& W" ?
9. static void MPU_Config( void )
   
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 */
    6 _/ U$ _7 e* @: E
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    % k0 |, M9 h2 z
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    $ Y( o1 }) S7 h" ~4 \" ]+ B6 Q2 T7 E
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % L" D6 r9 b, _1 y
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    7 A& C/ s' V. T! D6 z$ @: d4 [
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ; J; ~% |# g6 \" d: @$ q
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    9 h1 J3 _  e2 z- _0 ?1 h6 {
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : o  r* R- O' g. x; j. M& O6 m
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    & `$ v( {& R' i, l  F' y
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # g  K4 a$ G6 Z" C, a0 E0 u
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : D7 j+ \2 A$ w1 ]% j6 H
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    . A+ c- m) J9 L& T" @! Q$ b, d
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 A- R# O6 ?5 J' @! s
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    : B, x7 A: I5 p# o
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    8 X0 O' H9 L: u/ k& r4 l& a; V6 H" h
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # }5 R! ^) y+ I5 m  y4 @- _
46. 
    6 y0 v% s  J$ F& R
47.         /*使能 MPU */
    5 {! M" H& {  [% Z5 K# X
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    / m9 h; V5 C& Y8 r) g/ {% i
50. 
    
51. /*
    
52. *********************************************************************************************************
    5 s0 g! B1 T# e; K" Y. h, O
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    ; g- f2 |- h( e5 ]' H+ T9 T" e; }) k
55. *        形    参: 无
    / I# H6 Z0 ^7 m
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    7 j7 k( |( h* D* r( n; ^; L
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    & y4 p3 L% L# B( A0 }2 H
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    / H$ ?4 A+ D' i. y2 N9 g/ ~
64.         /* 使能 D-Cache */
    ' N2 e' o9 G% c! t6 @3 L
65.         SCB_EnableDCache();
    ( e% x4 A2 X1 w$ A/ r/ p
66. }
    
67.   每10ms调用一次蜂鸣器处理：
    
68. 
    ( |% _8 N1 }! y8 d- D% k
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    
70. 
    ' f* x' q0 o- v1 Q
71. /*
    
72. *********************************************************************************************************
    
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    9 c' n- W. k2 C0 c: w* O
76. *        形    参: 无
    
77. *        返 回 值: 无
    3 C0 [! M1 O* A) E: r5 A6 |: U
78. *********************************************************************************************************
    
79. */
    
80. void bsp_RunPer10ms(void)
      a  s7 t. m; f$ x6 j" P  w. H
81. {
    
82.         bsp_KeyScan10ms();
    2 o4 s+ t; w0 ]2 B  r' D- s# H
83. }

复制代码

  主功能：

主程序实现如下操作：
& f% L# e- r# @
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
+ W% o1 T% ]! W! R( o$ d* X  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
& a9 b% w, }6 |  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
. O) d+ y; m6 k( X5 n2 r  K3按键按下，串口打印"按键K3按下"。
2 y: J  e$ o7 w7 r; _& G2 q

1. /*
   
2. *********************************************************************************************************
     e. q" n! _' m
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   : D( [$ m0 U9 B2 Z7 G; d& Y
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   $ b9 u6 o* O, N9 H+ f
9. int main(void)
   
10. {
    7 ]! s+ O0 _; U, {+ `
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    & E, _, x, t3 Q# x) q- i! H; j# Y
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    , H1 F4 h) N: J! u& `$ x0 f
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    , E! G  \9 e5 Z% |+ r
25.         
    * E( C& E0 Y8 F# e
26.         /* 主程序大循环 */
    5 A& I+ E$ t" l, E$ {7 R6 z# d
27.         while (1)
    
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    4 c; v+ L+ f3 F# ~, t
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    ! V5 l5 }' ?/ S! ^# l5 s& \% k
34.                 {
    2 x, [6 X/ x& e0 _: I9 w
35.                         /* 每隔100ms 进来一次 */
    0 ?: J' a2 _/ }% K) N
36.                         /* 翻转LED2的状态 */
      q+ A' ]* t3 ]  H8 }. O9 L' V
37.                         bsp_LedToggle(2);        
    . s2 ~' _. \* j+ a
38.                 }
    
39.                
    
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    
44.                         {
    
45.                                 case '1':
    - \9 N3 N2 ~- g. M
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    9 i8 h/ s( a5 m1 D7 A
48. 
    1 h' j' y& O+ ~& E* Y
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    0 [& _0 ?: h: X8 ?3 V7 D
52. 
    
53.                                 case '3':
      J! Q+ I0 f: X
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    9 P( ^2 V0 Q) |, `
55.                                         break;
    
56. 
    
57.                                 case '4':
    & q$ k3 K  v& R( M* \
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    
60.                                 
    * d4 s& }5 F& h8 A6 q+ x' Z
61.                                 default:
    ) |8 ~1 z! e8 y; z% K- G+ r
62.                                         break;
    1 f6 v( x' c6 G! [
63.                         }
    
64.                 }
    
65.                
      u% b( ^  O; A( q
66.                 /* 处理按键事件 */
    + F6 I+ K3 j5 ]6 G/ B$ P
67.                 ucKeyCode = bsp_GetKey();
    + p4 V( k* b8 j8 l1 s* G" f
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    ' p8 f% A9 m4 K( C
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    ( F+ G! r' s7 Z% `4 {0 L( n
74.                                         printf("按键K1按下\r\n");
    7 n) ^* M# R- r! b4 s
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    : e2 [9 N2 u- x2 u; G) D) _
77.                                 
    5 P1 ?- R9 w: a9 t" ~( a8 y
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    ; F) T: ]7 B4 n' k
79.                                         printf("按键K2按下\r\n");
    * F+ g$ C* f/ [0 H' r) I3 Y5 v
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    : K( A: A  O7 {! p. f
84.                                         printf("按键K3按下\r\n");        
    ! ?) T. `, |% U+ e3 v! D) @
85.                                         bsp_LedToggle(4);        
    ) e# v, \) `- n5 O
86.                                         break;                                
    4 ~9 v0 \& m/ g/ C5 {
87.                                 
    
88.                                 default:
    9 o+ u. b! |. |, z2 k: I
89.                                         break;
    
90.                         }
    - e# R+ v& t/ `  g& ?- O  Z8 D% F
91.                 }
    : e2 I2 M# u2 i
92.         }
    . E8 m! z. O5 K- L) D. Y
93. }

复制代码

30.9 总结
本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。

$ e. c) T. V  W- D# K- ^/ {
, K# r2 c' ?% j

6 d6 N: H; `) ~