30.1 初学者重要提示
学习本章节前，务必优先学习第29章。
串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
$ c  p9 {0 G$ H1 |. P: F. q  ]本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
1 X- n# ?" V1 e9 ]- w  `大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
3 `! H( a6 F5 ?. E4 Y2 T4 ECH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
2 c* k8 N1 E# J30.2 硬件设计
9 S3 v! m+ s- h% m5 w, p  I+ YSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
, w0 v4 [* O5 w) X5 m/ Q
6 @5 A6 e( q3 M) a9 `* d9 p串口USART1  TX = PA9，   RX = PA10

' W/ h7 M; E' i0 B串口USART2  TX = PA2，   RX = PA3
4 w* S+ m) |" ]" a
' g4 p9 T# g6 q* J5 }$ `+ ~( l. E串口USART3  TX = PB10，  RX = PB11
4 v9 f6 @, m6 m2 t
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
* w+ c0 R+ X9 B. D' f2 X( I
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
* j+ B1 H) b2 k8 ?* |8 R
: Y9 E+ n0 K2 O+ u0 J4 i串口USART6  TX = PG14，  RX = PC7
% W# L7 e) K* V; ]/ z; `
串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
' X/ o: U  O6 v
串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

/ S4 Q) M1 S! a  r4 [: J% V  [. sSTM32-V7开发板使用了4个串口设备。

  d9 L' w: e( @4 e1 R  g串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
串口2用于GPS
, |+ \7 _% L  c, r6 t5 G2 b串口3用于RS485接口
串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

1 S" h% q  ^  a+ X. `7 ]
关于232的PHY芯片SP3232E要注意以下几个问题：
1 M2 k1 I! M9 I( W
SP3232E的作用是TTL电平转RS232电平。
& h8 [- i* m$ R3 W: F/ T4 Q9 y电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
. Q# I0 K: a+ L9 W% i) D检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

; h0 g: X) V  w! ^$ F/ D5 A

4 t5 V, d4 e6 b
实际效果如下：

; u, w# S4 }0 A  j: G通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
2 X  D1 D: v! h( R& Y. c
: b0 v8 O8 X3 [# G由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
% p3 F: f9 D; g, M2 s检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
' f! @) q" O) k. \
/ W- p1 D) L) ?: {30.3 串口FIFO驱动设计
3 l, a, `, T4 z30.3.1 串口FIFO框架
% ~- }# T9 T8 N! W6 z6 g为了方便大家理解，先来看下串口FIFO的实现框图：
" F( w; g4 a, h, V4 I) M* G9 p: V

! @& a9 |% U' I1 Y第1阶段，初始化：

; Y# R0 ~- ~4 T# D9 a! [3 E* x通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
, a* l, u  e* z# ?% e5 k第2阶段，串口中断服务程序：

接收中断是一直开启的。
$ w# G. X+ ^9 l做了发送空中断和发送完成中断的消息处理。
第3阶段，串口数据的收发：

5 \* m+ W9 l' C: Y0 n( o串口发送函数会开启发送空中断。
9 }7 K% Y# @( J6 k6 [串口接收中断接收到函数后，可以使用函数comGetChar获取数据。
0 T2 i- n9 A# r/ U  J# X2 B5 p
30.3.2 串口FIFO之相关的变量定义
, ]9 j5 @+ ?4 P8 {7 r/ @串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。
/ D5 J. v6 I7 B& |2 b! h
7 p, o# H+ D3 U5 D4 T+ T% u这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。
/ j. ]/ r) o8 @$ c& F8 v
每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
& c0 P5 y( z& R& i9 T* M
我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

' z9 Z+ w" a' c

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   . w7 [" W6 N# H1 T! B$ A; I
2. #if UART1_FIFO_EN == 1
   & E( H' W( Y5 d+ y
3. #define UART1_BAUD                        115200
   ) l7 _7 m; i( \# C0 e
4. #define UART1_TX_BUF_SIZE        1*1024
   
5. #define UART1_RX_BUF_SIZE        1*1024
   * z$ c0 X% ]/ S, W; S3 [0 b
6. #endif
   8 G4 J2 Q( G5 O3 X
7. 
   
8. /* 串口设备结构体 */
   $ a# H( M/ _4 b
9. typedef struct
   
10. {
    ) r  H1 x9 {" V6 r5 `1 y. I
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    + j9 R; N. @0 N2 i( d2 K7 T
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    7 B, V+ v2 y2 v4 }
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    4 O# U! A4 m3 L2 `- s- e3 _4 e
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    
23. 
    1 X+ o# ~! M3 n. {6 \0 H
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    * [. K, J5 H# _
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    $ c# [- m7 Y' b1 _1 o7 F
27. uint8_t Sending;                        /* 正在发送中 */
    6 b: M7 O2 A1 n5 {5 \6 q0 y- z
28. }UART_T;

复制代码

% s' v/ T5 K5 @; K( W" Rbsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。
1 k# h3 g8 K, B  p: M! O6 P
) W3 c  p* g) y4 Y6 f  V

1. /* 定义每个串口结构体变量 */
   6 x: @* j+ m7 D
2. #if UART1_FIFO_EN == 1
   . s8 k9 Y. s: f
3. static UART_T g_tUart1;
   8 ?" b, [% p( N( O% B( H0 W
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   7 w) f" N$ k2 l; V% X$ f5 F
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   . E- v" o1 B  l! @$ S
6. #endif

复制代码

关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
# H. H- f& @& k
4 P+ _9 H$ x! \5 E( ~( N30.3.3 串口FIFO初始化
; d! |4 g- z0 m- m  N% M) s3 |9 B串口的初始化代码如下；

1. /*
   
2. 
   * i$ N- N! [. l, n
3. ---
   & {% Z, R2 k9 ^- s: [
4. 
   
5. * 函 数 名: bsp_InitUart
   ) @" o$ o3 d1 e4 ?6 R: b" @
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   
7. * 形    参: 无
   6 Q: C& [2 K2 _: O+ C
8. * 返 回 值: 无
   
9. 
   
10. ---
    5 }3 n2 q, I4 Q  c" R# F1 ?
11. 
    
12. */
    
13. void bsp_InitUart(void)
    
14. {
    
15. 
    
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
19. 
    
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    ) @$ h$ Q. C3 h: c% F" `# B7 J8 v$ Q
21. }
    

复制代码

# M1 L; V, l1 z. c. w# s7 ?下面将初始化代码实现的功能依次为大家做个说明。

函数UartVarInit
& v6 L1 s' e) K! \' B这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
/ m& K3 `5 z4 s* _- B0 Q! @- B
- |3 P: n6 G) T! D9 J/ `

1. /*
   . }' I' a  I* `/ l' a5 m1 z3 p
2. 
   
3. ---
   7 j7 c  P9 Q+ ~( o6 x6 O& C7 }
4. 
   ( H0 L9 R! Z) h: B: Z1 F
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   # A, n: W( l9 ~# ?
7. * 形    参: 无
   
8. * 返 回 值: 无
   7 ^  I$ U- O  S6 H5 C8 R
9. 
   . a6 `  S; ~5 Q: e0 E6 [
10. ---
    
11. 
    * ^# b- A5 Y- Z, b6 U
12. */
    ( u& {7 d; a4 g3 H! K5 X
13. static void UartVarInit(void)
    
14. {
    ! v+ ~  m7 ~( _5 L& R: p  x% ~
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    * b, l# S; T0 @3 [4 S. c
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    2 P; g0 P1 s* u7 V+ Q1 U; A+ h
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    + s& g. l" G( u% u% i! @. |
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    / F# f' a+ H) w7 W; H
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    ! _  o% S6 _8 F9 @( ^, K
31. #endif
    2 V) V; P& d. A( b
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

. h5 m2 H8 J1 |  e2 }函数InitHardUart
! Z# `+ D# Y# e% f- Q' r此函数主要用于串口的GPIO，中断和相关参数的配置。

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   8 o/ B$ l9 h9 r7 }% }3 Y; Y
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   # R$ q5 y. M5 Q$ v( U" h
3. 3.        
   
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   ' W) v) D. B3 _6 ~: d: ?
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   8 l7 y& O: u- l& ]$ f
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   / @+ M% F: z1 `( h! N( u
8. 8.        
   
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    5 L$ l5 _! a4 K6 V- d( f
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    ; g0 P5 W% R+ K9 A: A  d
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    ( r5 j% N4 N6 D& g1 u2 y
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    
15. 15.        
    
16. 16.        /*
    7 s3 R4 e4 v0 ^- j
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    
20. 20.        *              发板
    
21. 21.        *        形    参: 无
    # i. Z3 j% i+ W  S/ p4 D/ k
22. 22.        *        返 回 值: 无
    
23. 23.        ******************************************************************************************************
    
24. 24.        */
    ) n6 z9 Q1 _0 u% _
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    ; ~5 T6 ?# ]5 f# U5 J
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
29. 29.               
    
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    , j  r  n8 _! }% ]* o/ j! N
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    1 @+ [" n) V  u
34. 34.            */
    
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    " U! O/ k  r9 J6 n$ S0 m# ]* Y, t6 b
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    
38. 38.        
    
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    / z. S& E& _5 v, g( v
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    + _% e9 f4 q" Y% x& `
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    
44. 44.                /* 使能 USARTx 时钟 */
    
45. 45.                USART1_CLK_ENABLE();        
    6 U; L/ B4 |* ]! B4 A- [
46. 46.        
    
47. 47.                /* 配置TX引脚 */
    
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    " F  \8 D4 q2 j6 }6 G( h8 [7 X
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    9 ?0 e0 \) B* l" _0 q/ r
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    # T; I  A4 l( ]: z5 ^  [5 v8 v, T5 ^8 A5 o
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    * r/ U1 e8 d* Z3 H: ^
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    : M9 n( s2 ]. v0 M1 X, s# U( c
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    3 j  g- @3 j2 ]2 L* @# v
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
59. 59.        
    ) M9 ?( Z4 r$ x$ l( W
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    4 U& v; M1 Y4 ^6 g
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    3 p1 c( T$ }  [$ }% y
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
66. 66.        
    6 o8 ]. D! u) D
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    : {9 E3 X3 G) G4 q) r9 t+ r
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
71. 71.        #endif
    $ J1 T6 t4 T! w* i7 E
72. 72.        /* 串口2-8的初始化省略未写 */
    
73. 73.        }

复制代码

0 n% t% {* s8 r% ^0 u( ?' H第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
. p  J3 U" N2 f& d+ n第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
1 V  h1 ]6 ^$ f$ Z4 u& F$ b; b第65行，配置串口的基本参数，具体配置在函数里面有注释。
7 D" ~5 \3 j& f9 Z                                                                                                                                                

1. /*
     A/ n6 T) X9 W
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_SetUartParam
   ! S* B7 Y9 o3 f2 E
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   6 E' Q6 ^% w% ]9 l9 I0 a' F# L/ f
5. *        形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   ' U7 N- ~( M4 X& |
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    5 }  w2 n: J1 |, ]' Q& j6 a- X
15.         
    3 k" }5 h* t! ]0 }# X# U
16.         /*##-1- 配置串口硬件参数 ######################################*/
    / ?) _6 z. E1 Z7 T/ u  U
17.         /* 异步串口模式 (UART Mode) */
    9 r7 A% R9 m* o) U) V2 u6 ~7 `
18.         /* 配置如下:
    & y+ w  u5 C  H' ^/ V
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
    
21.           - 校验    = 参数Parity
    & e! P1 m) N+ ?( S' C. f0 L0 L
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    8 u/ S$ h  B4 ^4 L
24. 
    / J, g: C' U$ T" H
25.         UartHandle.Instance        = Instance;
    
26. 
    
27.         UartHandle.Init.BaudRate   = BaudRate;
    6 e$ Z7 D6 f3 S1 A7 v
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
30.         UartHandle.Init.Parity     = Parity;
    : l5 H. k, r$ ]
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
32.         UartHandle.Init.Mode       = Mode;
    
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    8 {: y3 j' k5 R5 G& m. ^
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    , J0 K5 h; ^0 G9 K9 e' z
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.    
    * K2 [, _2 {* r
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
42.         {
    
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    
45. }

复制代码

+ n2 K) U/ b+ @. \: P2 R: Y" P% U7 p
+ M8 C5 U4 r. O. o函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
# b8 J5 q; p6 `8 Z0 j* s" D
& y2 z( {/ U& P" _4 H  @. k  h

1. /*
   . y- ?, P. a2 o3 I  `+ V
2. *********************************************************************************************************
   % ^' Y* J3 g4 R) q' G: |/ B
3. *        函 数 名: RS485_InitTXE
   , E; Y" N8 r2 e1 X$ B
4. *        功能说明: 配置RS485发送使能口线 TXE
   2 {. o; k: z+ j2 x
5. *        形    参: 无
   3 l4 H( o- v( H
6. *        返 回 值: 无
   % ?% `, G$ @( X' u" `- @
7. *********************************************************************************************************
   
8. */
   - X; {' T. q/ G2 m, p4 w
9. void RS485_InitTXE(void)
   / T, N! ~  \1 P6 r1 Y7 o& y
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    & f( ^6 C! b; I+ ~2 {
12.         
    
13.         /* 打开GPIO时钟 */
    
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    1 G2 a* z/ [8 C! Q' z
15.         
    " I# }1 g+ t0 R1 y) u5 p
16.         /* 配置引脚为推挽输出 */
    - C1 @! d7 L' Y1 m8 P$ r- o
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    + K- n& o( `6 }8 N* s/ `7 z; \
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    ) Y+ E( T- Y0 q# Q* b) ?
22. }

复制代码

30.3.4 串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能

5 Q. V- ^$ q+ R& w5 N0 v1 L5 Q收到新的数据后，会将数据压入RX_FIFO。
检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
8 h0 u8 W' d- f" z; t
6 l0 ~$ M# ?7 |1 i下面我们分析一下串口中断处理的完整过程。
3 S) f6 G) D& J4 J- }3 J% R当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：
* p& k6 U/ t2 `& j
/ ]- ]+ e3 p8 o8 [  |7 b6 y

1. #if UART1_FIFO_EN == 1
   " {8 Z/ O( Y7 a( Z; P
2. void USART1_IRQHandler(void)
   
3. {
   + }0 s- @4 H5 `( a; t
4.         UartIRQ(&g_tUart1);
   
5. }
   
6. #endif
   ( A) \' V$ \( Q- Q
7. 
   
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   % S( N/ H# E! t$ Q: u' v
10. {
    
11.         UartIRQ(&g_tUart2);
    4 ^& O& D: l  M  m% c
12. }
    
13. #endif
    
14. 
    
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    
17. {
    ) M, x( I0 e; o# ~
18.         UartIRQ(&g_tUart3);
    ( Z% ?/ h+ K* j) O# E% Z6 x
19. }
    
20. #endif
    
21. 
    3 P& K% G% H! P& w5 Q6 X
22. #if UART4_FIFO_EN == 1
    9 j. w/ {! S/ `& k5 ?
23. void UART4_IRQHandler(void)
    3 |+ C. ~9 i) n8 _
24. {
    3 E& s# N# I* Y6 x3 S3 F$ @1 [5 B
25.         UartIRQ(&g_tUart4);
    
26. }
    
27. #endif
    0 a" L; `# s9 f" I4 c
28. 
    ) Y" J( S$ F' U' ~$ V
29. #if UART5_FIFO_EN == 1
    
30. void UART5_IRQHandler(void)
    * w! @: L3 }8 }. E$ v
31. {
    
32.         UartIRQ(&g_tUart5);
    
33. }
    
34. #endif
    , l; ?; l. f% ^: X* Y) H! }4 G
35. 
    7 T9 r7 h  ?& k; z7 F
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    
38. {
    
39.         UartIRQ(&g_tUart6);
    
40. }
    
41. #endif
    7 B# p, [$ _4 l4 l& t5 G' M8 X0 ]
42. 
      [5 d4 u' F, Z0 P
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    3 W/ e/ _, `  y0 z& k  n0 e
45. {
    
46.         UartIRQ(&g_tUart7);
    7 B; B2 r, W  Z( f
47. }
    
48. #endif
    
49. 
    4 J- K; e0 Z* Q+ M
50. #if UART8_FIFO_EN == 1
    * l8 B" m# `; k3 Z4 c* y- c. l
51. void UART8_IRQHandler(void)
    * o8 E/ y3 ?! {3 H
52. {
    " g; N1 r  K( |7 U+ R% h9 g- @
53.         UartIRQ(&g_tUart8);
    
54. }
    
55. #endif

复制代码

大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。
- m4 P  d8 W; b& ^
下面，我们来看看UartIRQ函数的实现代码。

2 {2 R4 R# k: ~  \$ n4 B% E3 @/ ?" B/ w

1. /*
   
2. *********************************************************************************************************
     o6 D4 G' s( y
3. *        函 数 名: UartIRQ
   : r2 f5 |; T1 V9 f. T8 e/ g1 h
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   - b9 {) g& p& k7 f! Q) K$ R
7. *********************************************************************************************************
   
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   ! z! U* W, o0 o( D3 X3 _
10. {
    , z4 j0 e$ @9 K" Z
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    8 y6 h+ g! f% ?6 \( W6 `
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    & o) F( k+ r# I9 R% H" Q; c
14.         
    
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.                 uint8_t ch;
    
20. 
    
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    * M+ Z; H4 `2 r) X1 `/ |
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    5 F+ S- B, }# U, k0 l
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    9 T% [) V4 W' V, n$ W% F( N
26.                 }
    4 b4 {3 o0 k# k5 U; o
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    # M: r; K7 s! d! s3 G5 W7 R" Z
28.                 {
    
29.                         _pUart->usRxCount++;
      w4 Q. {; k: v8 `2 U1 k6 y
30.                 }
    
31. 
    8 M6 Y- G5 @. d0 O0 l
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    8 i& }4 [0 b3 v7 e
35.                 {
    
36.                         if (_pUart->ReciveNew)
    4 j$ s) d, b/ m7 o3 A' o( R  Z
37.                         {
    * `7 r" P' g. K, v, k* D! A
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    : M+ p* x8 P' N
39.                         }
      T+ V9 W! g& M: l
40.                 }
    : y! g5 H/ o- l( c/ o
41.         }
    ( V# [* u# b% A4 A" F$ |  f- I* ~# B
42. 
    2 k( L. m4 K# f7 q- Q
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    - x. @6 R  ?* V
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    1 Z% @( [; S" b; q6 o9 L
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    & F% g3 l) V9 h: K4 Q( Z
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    # P0 H; }1 l  G; _$ W8 I6 P
52. 
    
53.                         /* 使能数据发送完毕中断 */
    
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    . G" |3 \$ a) c6 Z9 K/ @
56.                 }
    0 M' X& H, l0 l" \% m: f: g& {
57.                 Else  /*　还有数据等待发送 */
    - M9 p, }( c% }! }
58.                 {
    
59.                         _pUart->Sending = 1;
    
60.                         
    " c7 P) y6 Q1 h) Q8 B* C, t( J
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    8 s" X) I1 A* U
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    ) z, x' c, [% U
66.                                 _pUart->usTxRead = 0;
    ! B$ u1 H& Q2 L: H$ I
67.                         }
    
68.                         _pUart->usTxCount--;
    
69.                 }
    5 K0 V% a% u; f4 Q9 F) w9 {
70. 
    
71.         }
    
72.         /* 数据bit位全部发送完毕的中断 */
    
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    7 j. ?' w( G5 v$ r& g9 i
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    
77.                 {
    7 q5 W/ l( a! E3 D- p8 T  V2 _
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    2 O) M( P1 }! D- G0 Z
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    " D( K+ b/ T, l* Q( d* J* b5 V/ r
81. 
    ; D8 C6 @/ }" L8 r
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    . c( E! E' ]4 _1 ?  y% r
83.                         if (_pUart->SendOver)
    % V0 Z% O5 ^: f, C* T
84.                         {
    ( L1 g; v0 q# N" R8 A
85.                                 _pUart->SendOver();
    
86.                         }
    
87.                         
    
88.                         _pUart->Sending = 0;
    # d' y; d* r. e) l
89.                 }
    1 `: `6 e2 Z9 n
90.                 else
    & c( C8 Y; U; q9 Y. z
91.                 {
    ( T3 `6 U2 m. S' L9 E- T
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    5 k0 G( n5 ~+ k2 R/ Q* M
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    : }+ h% |- R) Q2 h/ ]8 E
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    9 I$ \! i8 g8 B# {
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    % M$ b- n$ R% |% @) v/ l" X0 j
98.                         {
    # W) {  o2 D1 W+ @: w
99.                                 _pUart->usTxRead = 0;
    / m5 B3 L7 G* t* [9 V+ U5 x5 \
100.                         }
     / y. b! `5 s) X4 i+ n1 H
101.                         _pUart->usTxCount--;
       ]+ o/ U* }3 N' H- ?& H
102.                 }
     
103.         }
     - r2 E2 H1 w; R8 o4 \
104.         
     : N/ L+ l( r6 g& |$ B: B
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     3 [: [8 h6 f# ^5 {$ \' t! i& s
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     . ~3 a% H; C6 \# }) X$ T1 s9 M
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     6 F$ c, \, O% v! \/ E
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     . |: G: K+ I/ K" i5 t, [
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
' ~5 h8 m6 g4 Q
& t# J# a" X- |# X" e# ]  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
) C3 @& z) o2 ~9 H特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

/ d4 y# _# d9 N/ A' X9 _. P, e& h  发送数据处理
2 G3 y; H% P6 N3 U1 p- B发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
; {+ ^# ]; X4 q' v0 ~" X5 \
30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：

1. /*
   6 }' ~0 U8 a3 m# I2 X& Z4 V8 w
2. *********************************************************************************************************
   % G' E( M5 {9 Y
3. *        函 数 名: comSendBuf
   
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   7 @# j/ m3 g6 _: p3 @
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   6 q. Z; w6 i7 M# U% q; k7 i$ j8 F3 a; o
7. *                          _usLen : 数据长度
   ) ^/ V$ x/ D/ _) s" K
8. *        返 回 值: 无
   7 T+ l0 f; L0 K, u4 V3 b( H# \' {4 \
9. *********************************************************************************************************
   
10. */
    ) I' l9 S+ ?( ~1 T; t9 o
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    . G) _) Y6 i# B& b* J1 U1 \$ L# _
12. {
    
13.         UART_T *pUart;
    
14. 
    
15.         pUart = ComToUart(_ucPort);
    + n8 n; c9 C9 [6 m' V6 g
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    $ J' a8 Z- k4 i. E
19.         }
    
20. 
    
21.         if (pUart->SendBefor != 0)
    4 G) I& b& X/ S4 x& d/ y8 L
22.         {
    % w( z: L6 {5 E, n) H" C9 M5 G5 m5 L
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.         }
    
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    , U4 x- B% v: r2 t
27. }
    - w3 W; G4 E4 ~' |: M) u# k
28. 
    % B6 v. |8 {5 U! ^
29. /*
    . R3 I2 q1 w2 {
30. *********************************************************************************************************
    
31. *        函 数 名: comSendChar
    
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    ! `* v7 h' `" T
34. *                          _ucByte: 待发送的数据
    / s3 x8 b" _- |8 P+ M9 _' s
35. *        返 回 值: 无
    
36. *********************************************************************************************************
    & G% c+ `) j9 Z1 |
37. */
    - P  f2 O1 k" B! [* i
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    9 f! ]7 d# i1 S5 F3 N
41. }
    ' \; L8 L; _: d* o# k# m9 q5 ?
42. /*
    9 y4 Z1 E- [6 t8 h; W
43. *********************************************************************************************************
    ) q* d1 P. e6 ~% ?1 c! d5 y( b  i
44. *        函 数 名: UartSend
    
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    
47. *        返 回 值: 无
    
48. *********************************************************************************************************
    ) u+ m* V) o, t0 E- U
49. */
    3 ]+ x% }; K) {* S7 Y) U1 L
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    " ~9 u' I( H( p; M' a
51. {
    ! p: _% }0 V& Q" B' _/ j# j7 R
52.         uint16_t i;
    
53. 
    
54.         for (i = 0; i < _usLen; i++)
    
55.         {
    , Q) R# h! V0 l3 y* ]9 }2 u4 h6 R! T
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    7 |: |& m! y6 l
57.                 while (1)
    
58.                 {
      \$ G' Z2 P7 d# @0 q& [+ e
59.                         __IO uint16_t usCount;
    
60. 
    
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    : G' J# X0 a5 [* ^5 z7 R  a
63.                         ENABLE_INT();
    
64. 
    & u& {% x/ s! E/ H. h
65.                         if (usCount < _pUart->usTxBufSize)
    
66.                         {
    ( \7 p* {+ i) E
67.                                 break;
    
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    3 n1 Y) _( |& I4 S2 G( P+ {
70.                         {
    ; A. V; v, I) H4 \7 `( f  m2 g" k
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    % ]; n0 f8 y9 [- W2 U# ]
72.                                 {
    1 {* G* P. }$ z3 T
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
74.                                 }  
    
75.                         }
    5 d8 q* X# \4 Q
76.                 }
    
77. 
    6 I8 J) a9 f$ s' W& [4 h
78.                 /* 将新数据填入发送缓冲区 */
    / z- l# O$ A7 h: O* a% L$ w) s. O
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    4 z  s& m, L" I+ y9 e# y
80. 
    % b! V/ q2 P4 h  Z5 o' c5 `
81.                 DISABLE_INT();
    2 d' m& j" A" G7 n
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    9 V8 t0 \6 k0 R* o# Q
84.                         _pUart->usTxWrite = 0;
    
85.                 }
    
86.                 _pUart->usTxCount++;
    1 e" E; `& r' `1 g* T
87.                 ENABLE_INT();
    1 ^; W$ X. r% D) r; M: n: h2 m
88.         }
    2 b1 }1 w5 `4 C- R7 L
89. 
    9 V( u5 l! e  u; a* i$ r. f( j
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    & q/ ~6 X6 x9 \6 C
91. }

复制代码

! k* C7 \* f" w/ N& S函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
8 b# d) u: k2 e8 f6 A
  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
: A- d8 D) B% x/ {$ ]& N9 P5 ~+ J
注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。
$ i5 f$ L3 Z+ }
函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: ComToUart
     f& s. F8 \7 z3 ^3 X
4. *        功能说明: 将COM端口号转换为UART指针
   / i! b: g5 E7 v& H* x+ X
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *        返 回 值: uart指针
   , k+ `" [, h! L1 W1 |
7. *********************************************************************************************************
   * V3 i% M5 |& \/ N$ `( ?+ Q
8. */
   . g) S; L- J5 L
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   ) O/ T) B/ b1 o2 l" j
10. {
    # M  w6 H3 U8 i
11.         if (_ucPort == COM1)
    1 m3 _8 U( w+ b! W3 H  t
12.         {
    
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    # g7 Z7 g$ h# R4 }# T4 w1 G
15.                 #else
    - x6 P5 U* H' H1 W' O# P: E
16.                         return 0;
    
17.                 #endif
    ! H* n% b# r" G. {  c% ]
18.         }
    
19.         else if (_ucPort == COM2)
    
20.         {
    * u( p" N( e7 A) Q- y; r
21.                 #if UART2_FIFO_EN == 1
    
22.                         return &g_tUart2;
    ( X; o, a8 ^" N$ w. J1 X
23.                 #else
    
24.                         return 0;
    
25.                 #endif
    ) V+ N4 n1 H$ K
26.         }
    ! h2 f2 M, ~$ `" W1 }' b2 o9 l
27.         else if (_ucPort == COM3)
    
28.         {
    
29.                 #if UART3_FIFO_EN == 1
    ( s" u7 q% Z& d1 O" Z5 S) P
30.                         return &g_tUart3;
    $ S# a& ]- N/ o; d6 R
31.                 #else
    
32.                         return 0;
    
33.                 #endif
    6 M. o, Z  E8 A0 j3 e7 J/ T
34.         }
    
35.         else if (_ucPort == COM4)
    $ C9 ]2 E" }  v0 Z5 ^
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    ! Z; H5 J0 Z1 L; L' d
38.                         return &g_tUart4;
    ! u# M2 \' q) y( E) {
39.                 #else
    
40.                         return 0;
    ' ], \, C3 U- S% Z4 \7 v) d: J
41.                 #endif
    4 Z# g& W$ u2 o
42.         }
    5 q  ^5 w/ s( s* ?. \6 G6 _
43.         else if (_ucPort == COM5)
    9 W$ ^1 s/ u3 @. Y
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    
46.                         return &g_tUart5;
    
47.                 #else
    
48.                         return 0;
      b3 j* X2 i$ D  P* R
49.                 #endif
    . O3 N7 i: j% E2 T
50.         }
    
51.         else if (_ucPort == COM6)
    8 r8 \0 F' p8 U1 w
52.         {
    9 z& V: v6 @1 h/ j
53.                 #if UART6_FIFO_EN == 1
    
54.                         return &g_tUart6;
    # G; q' X- }- Z) Z! _  |( [/ C& v8 G
55.                 #else
    
56.                         return 0;
    
57.                 #endif
    - D5 f6 Q3 b" N
58.         }
    5 B/ l( Q/ H9 C; |( K* w
59.         else if (_ucPort == COM7)
    + r1 a$ R1 e! N/ x! L  ^
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    3 b3 Q3 G4 w/ o; i* q( ^
62.                         return &g_tUart7;
    6 M+ o# n! a5 Q
63.                 #else
    
64.                         return 0;
    9 t& }0 L# g) f, r  H
65.                 #endif
    
66.         }
    
67.         else if (_ucPort == COM8)
    * u5 S; H; O; T: e3 F% u
68.         {
    ( \* i2 E; Z* X( d& H
69.                 #if UART8_FIFO_EN == 1
    
70.                         return &g_tUart8;
    
71.                 #else
      [  v4 I: o6 v, N8 q5 O' K
72.                         return 0;
    * G- Z6 z/ }/ q( N' d% j( ]
73.                 #endif
    * _1 f" @) B4 i' ]* M" b
74.         }        
    ( l6 P5 }  p1 }& ?
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    + l3 e+ m' k3 w
78.                 return 0;
      t% J8 ?) j  Q% g4 Z8 X
79.         }
    
80. }

复制代码

30.3.6 串口数据接收
下面我们再来看看接收的函数：
# d- X) W# e3 f9 ~  y% \7 p

1. /*
   
2. *********************************************************************************************************
   ! x5 B+ V' `: Y" }6 ]2 t
3. *        函 数 名: comGetChar
   ) f2 r" a, E) y# i- K: B! z7 N
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   & L0 s! U: [1 d3 ?2 |
6. *                          _pByte: 接收到的数据存放在这个地址
   % Q0 ?& g. s: B. @2 o3 F! }/ I
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   * ^: M% m+ ]5 W' c  y
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    - @' L# N8 F' y8 ^, m( q5 R
11. {
    
12.         UART_T *pUart;
    ) Z- ]5 m3 X( W( k
13. 
    ! W) A. x, N$ O: Y4 T
14.         pUart = ComToUart(_ucPort);
    
15.         if (pUart == 0)
    
16.         {
    
17.                 return 0;
    
18.         }
    5 ]1 I, o+ B$ E& J
19. 
    & t7 u/ k. p3 i6 c
20.         return UartGetChar(pUart, _pByte);
    9 S0 M: p. w* ?4 Q  q
21. }
    
22. 
    ' b. d& ]8 x& k% G
23. /*
    7 C+ p. c4 X5 O' }/ F# r
24. *********************************************************************************************************
    
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    7 [  I" q0 P7 @
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    3 ?' k0 j3 E' q
30. *********************************************************************************************************
    ! K) X  {* P8 R  ^# E) B  |! ~
31. */
    
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    6 c1 v) j, D0 Z5 F% V
33. {
    & {2 g) ~  B; Q) }
34.         uint16_t usCount;
    
35. 
    
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.         DISABLE_INT();
    # m) G: }5 d1 P! x! h1 F4 s  Z
38.         usCount = _pUart->usRxCount;
    
39.         ENABLE_INT();
    8 Q$ o. g9 F& O
40. 
    / Y/ [. f4 T1 }
41.         /* 如果读和写索引相同，则返回0 */
    & I& y6 m  T8 T! [7 `. d
42.         //if (_pUart->usRxRead == usRxWrite)
    8 M. R' R5 h2 Y( `& ~
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    
45.                 return 0;
    ( p  K1 H, ]) _- O) p+ P9 L
46.         }
    . c* K- x2 t" r* O
47.         else
    # C. W2 {6 H6 ]" N
48.         {
    
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    ( F# U; y: o! r2 d( ?; `9 x
50. 
    
51.                 /* 改写FIFO读索引 */
    
52.                 DISABLE_INT();
    9 U, E/ e2 ]3 ^6 I; h( A! k' D4 r
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    * W2 `, g# w) g' c) [
55.                         _pUart->usRxRead = 0;
    
56.                 }
    
57.                 _pUart->usRxCount--;
    : {# L  V% R/ T1 H
58.                 ENABLE_INT();
    
59.                 return 1;
    
60.         }
    
61. }

复制代码

! {0 t8 F, A/ z. l5 _' Y# R* [函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
: H% \& z; U2 e6 z
- q) b8 O% I0 \, l' f3 ?注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

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

) r: k9 W. n7 N" T' F' A为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
: g6 j2 f6 c, p+ f2 o1 e% t
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。

/ `& d$ B6 K6 z实现printf输出到串口，只需要在工程中添加两个函数：
# q0 W9 B( C7 R/ O0 L$ t5 d

1. /*
   6 z& K: d9 ~& [
2. *********************************************************************************************************
   ( B: o( |" W6 O8 t7 C- E  Z
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   3 W6 L9 ~* P3 p; k
5. *        形    参: 无
   # e: ?: r' S! J/ [( U
6. *        返 回 值: 无
   ! e& F$ a! x+ [4 v
7. *********************************************************************************************************
   
8. */
     {+ H; E1 U* ^6 Z. Q" D
9. int fputc(int ch, FILE *f)
   
10. {
    
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    3 o3 b2 J8 Y1 P* r! x
12.         comSendChar(COM1, ch);
    0 O% r9 G' c4 `- V, j7 C& b
13.         
    1 z. M  K# ?3 H& _2 ?$ `3 ^! @
14.         return ch;
    8 Z' ?9 |( l2 }% |; l! I
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    7 v* @4 V" T5 `/ `4 c$ b5 O" w# ^
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    # y* [: R6 I1 ?* G' A/ g2 k
18.         
    
19.         /* 等待发送结束 */
    ( i/ c# N! a+ u
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    . }3 p' d7 r$ _" ~. p* t
21.         {}
    : ~/ e; b& q  U3 X
22.         
    - X$ p- L1 V% C4 M+ c
23.         return ch;
    . _7 D: t3 D* w+ K
24. #endif
    
25. }
    
26. 
    0 {0 v: g$ X) F! P
27. /*
    
28. *********************************************************************************************************
    # @1 G+ N8 Z( |& u* A  t
29. *        函 数 名: fgetc
    2 ?) N' A/ c" H6 z/ F1 D! |6 j  H
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    3 O: w  h  [5 q
32. *        返 回 值: 无
    : P! z% P1 i7 X# j7 L4 }- o
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.         uint8_t ucData;
    
40. 
      F) f9 v/ Q5 M* z: W& j
41.         while(comGetChar(COM1, &ucData) == 0);
    0 O( N) c/ o  j, g4 F* W* K4 b6 G
42. 
    
43.         return ucData;
    
44. #else
    
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    2 q, D4 A* ~  S% v' A. I5 w
48. 
    1 }- x7 T, M- A; b
49.         return (int)USART1->RDR;
    $ r# F5 ^% s5 H4 ?- x; \$ f! g7 I
50. #endif
    
51. }

复制代码

printf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
5 q! L4 I+ O. r5 e! g
30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

# F' [: ^1 X* V) q. H9 [% h; N  bsp_InitUart
  comSendBuf
  comSendChar
1 ~- d) d9 P3 L3 p( M  r- L* L  comGetChar
30.4.1 函数bsp_InitUart
- J' T; U6 N1 M: b9 y9 M( ]' z/ a函数原型：
void bsp_InitUart(void)
8 }' W/ j( x. W
函数描述：
% d, s( `4 G- N' x: s# W! r此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

- L* Z7 A. m6 M7 B! U4 O, z1 n7 p( ~使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
  _0 @* W9 F; `) e) i- I
/ `* g' x5 C. p* d( D  r2 y30.4.2 函数comSendBuf
函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
+ \4 o/ F7 P# r4 Q! S. q4 P  t- r

函数描述：
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
* i4 }3 x2 Y8 h8 f
- R# v1 G6 W( K函数参数：
3 X) S3 m7 f) s: E  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
2 _7 c4 w2 L2 |2 I5 k7 [7 G  第3个参数_usLen是要发送数据的字节数。
& Y1 C+ N. r. y4 n% H6 z1 V
# e# z+ y/ k  v5 A7 L
注意事项：
5 M) W' u0 T3 x  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。


- N4 _0 P% G+ n( g使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

const char buf1[] = "接收到串口命令1\r\n";
comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));


5 `/ e. {+ z8 V! W) A% o30.4.3 函数comSendChar
函数原型：
' u' n4 [: ~* H5 ^* S* O- d8 dvoid comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);

0 B+ o9 t) X, a/ q
' m9 w9 c! [2 A7 V8 d) L# @; S6 \) X函数描述：

此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
$ M( w. a/ K; w8 R& p  第2个参数_ucByte是待发送的数据。
9 w9 f. A; T3 z: {, X4 H
& h( O( `- k3 x' }9 |2 ]" m
. v1 z4 U; J/ B5 c" T- x. ?注意事项：
$ P$ j% g' R+ v) ]6 G3 n+ _6 J  此函数的解读在本章30.3.2小节。
; O, P% r+ Z. t: o9 q* T7 j3 N

( m/ l4 _  s5 g) B4 P  w7 m1 R使用举例：
. D: w  t5 o5 T  p+ c9 ?调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。
+ K# p+ W) q; G* z4 j: b/ H
2 W% \  e) v+ t  I. u$ \30.4.4 函数comGetChar
函数原型：
* e1 e* f( ?' M3 z- h5 ~& Iuint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)

+ i$ V/ j4 d- k3 \. C; D
函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：
' U6 \  ?* a6 n/ [- k( I4 i& k  第1个参数_ucPort是端口号，范围COM1 - COM8。
; a9 [0 S/ h" m0 s2 F0 F* ^  第2个参数_pByte用于存放接收到的数据。
$ u7 ~# a6 P& S7 N& D  f  返回值，返回0表示无数据, 1 表示读取到有效字节。
: O5 u0 C( a8 A3 e" `

) v- U  S7 L) p, e; f( f注意事项：
0 }' v8 X" P+ E) I0 z4 O: J2 X  此函数的解读在本章30.3.6小节。

7 p" I/ J/ t6 ]1 M, f" y
使用举例：
) q4 m# ^, M6 D+ Q9 I- j. K调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

比如从串口1读取一个字符就是：comGetChar(COM1, &read)。
4 T7 R8 i# W: a2 t- R
/ Z$ i5 w! {$ Z: z4 j$ @30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：
4 \- C- r/ m- ~1 S8 r: z
9 w$ n( V3 S  v, M. ?5 S6 Y  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
/ E* J( Y# U: U1 e- d  y' n

1. #define        UART1_FIFO_EN        1
   ) s2 y  Z1 b) g8 F4 m  q0 S
2. #define        UART2_FIFO_EN        0
   
3. #define        UART3_FIFO_EN        0
   
4. #define        UART4_FIFO_EN        0
   & S1 x  B, ?/ W5 n9 e
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   # b. O* a8 i; H! _4 ]
7. #define        UART7_FIFO_EN        0
   $ y. H9 G) O. J9 ?
8. #define        UART8_FIFO_EN        0
   3 \2 u! S. M5 h* ?
9. 
     D) Z( S. t% L5 M
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    
11. #if UART1_FIFO_EN == 1
    0 n* e% f6 e$ N2 o4 d
12.         #define UART1_BAUD                        115200
    7 p$ @# G6 E9 f/ c2 s0 r
13.         #define UART1_TX_BUF_SIZE        1*1024
    
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    3 k$ Z" @! u9 }) U, s+ ]
16. 
    
17. #if UART2_FIFO_EN == 1
    
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    
20.         #define UART2_RX_BUF_SIZE        2*1024
    " ?7 }* H/ P6 r# d( `# T, Y& _
21. #endif
    
22. 
    
23. #if UART3_FIFO_EN == 1
    , E; `7 G( A2 o2 |" b1 D% s& @; o
24.         #define UART3_BAUD                        9600
    . ]3 E. V. v* G) V0 \% ]
25.         #define UART3_TX_BUF_SIZE        1*1024
    + v, C$ T" _# a! G% Y) }, |
26.         #define UART3_RX_BUF_SIZE        1*1024
    
27. #endif
    
28. 
    
29. #if UART4_FIFO_EN == 1
    ' K  f' C5 @& X/ W  C6 q  P
30.         #define UART4_BAUD                        115200
    ! l2 K- z/ \4 E- h; H  F
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    
33. #endif
    
34. 
    
35. #if UART5_FIFO_EN == 1
    9 w! C& r7 m) H  w4 }% a
36.         #define UART5_BAUD                        115200
    " W& \9 A8 n5 |$ u, ~# N8 k" j
37.         #define UART5_TX_BUF_SIZE        1*1024
    8 J9 U8 \1 H3 S
38.         #define UART5_RX_BUF_SIZE        1*1024
    2 L/ a: p5 X( s* B
39. #endif
    
40. 
    ( M) i& `3 }) k
41. #if UART6_FIFO_EN == 1
    # @9 k( [6 r& B+ x+ {
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    
44.         #define UART6_RX_BUF_SIZE        1*1024
    ' w/ b( {) k% c1 J% Q1 Q
45. #endif
    8 |7 P$ n' ~7 W. K# C* S& T
46. 
    
47. #if UART7_FIFO_EN == 1
      T+ y  t& E6 {6 X! R' z  G' \
48.         #define UART7_BAUD                        115200
    + N. X. E! q$ R$ M1 S# L
49.         #define UART7_TX_BUF_SIZE        1*1024
    
50.         #define UART7_RX_BUF_SIZE        1*1024
    5 c0 ^+ r2 _; C; Q
51. #endif
    
52. 
    8 V' u- {- N* p" w* Q
53. #if UART8_FIFO_EN == 1
    
54.         #define UART8_BAUD                        115200
    / M5 K! Y% A# L& ^0 M- ]1 I
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    
57. #endif
    

复制代码

/ Z7 M9 l2 m' x# V' y9 C6 R
. Z. {  |/ [# `& ~- P# [1 u! O! j  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。

30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

7 x& D- F3 Z+ z) k$ F: `6 E

1 a6 o# T! b( B. \3 F! z+ k
  第1阶段，上电启动阶段：

& a3 c9 ?. \2 i4 D# v& I这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
$ X9 s( D' ]6 H' S
  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
$ m8 R+ Z- X1 {1 a9 m/ q* c7 f( ?; x  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

30.7 实验例程说明（MDK）
( s6 S& L* a; V0 j4 K* [1 `5 H配套例子：
# u) c- ?7 W2 N$ K
: J* {4 q- p, YV7-015_串口和PC机通信（驱动支持8串口FIFO）
) v- ?, P. w! W8 ?% r3 p: s
1 v; E+ R9 q9 {$ M/ O实验目的：
, C1 b. w+ L# d3 c7 o) w& ?学习串口与PC通信。


, {' r: }' [0 w实验内容：
2 g! C; X# K% `' a$ s* J启动一个自动重装软件定时器，每100ms翻转一次LED2。


实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
% m+ z, r: G: Y* ?( @7 V串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
2 F' T% \3 M! u5 ^- |串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
4 f+ \, F3 Y; y# Z( q5 `; W串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
# s2 I' b3 X% iK1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：
3 j& H; ]/ b+ \3 Y  t3 I; K
波特率 115200，数据位 8，奇偶校验位无，停止位 1
0 m& ^! m) y: N0 I
6 e7 n9 z2 R4 k* v

, e. R; A+ }" w4 [& {  F$ x
程序设计：
, u: j8 E, m1 W2 M  a3 g8 t, S
  系统栈大小分配：
4 n$ N4 o: ?+ r1 q

# R' [  P; g, j2 d; ]3 |4 [
  RAM空间用的DTCM：
$ S) M! y, y9 z9 C4 L3 ^; Q
0 {5 j8 b! W6 `  E% N$ D

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
1 @* W2 G$ \7 ]- p4 }% K

1. /*
   
2. *********************************************************************************************************
   & g" {0 U5 Q5 k$ v( r
3. *        函 数 名: bsp_Init
   * y* E# e' G1 ^* I3 j+ S6 l
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   + |+ ]* _: C' q- s
5. *        形    参：无
   7 D( d5 K+ T" x9 q
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    ( }" J, p& \% g- J" L1 E
16. 
    4 |# e/ W' K3 n1 g5 }0 @2 [
17.         /*
    3 L6 c" N2 O! x5 O3 ?
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    + `, a8 I/ x6 R& ~
22.         HAL_Init();
    ; V* S0 d' b% R. k2 Y( f
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    " a+ a. A7 k0 X: |9 U
30. 
    ) m) j8 B# u3 x1 r
31.         /*
    
32.            Event Recorder：
    0 S  l9 C3 [0 l& f5 E; `5 S# J
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    : @: `$ M: G/ U8 s; q* C. B
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    - C9 L2 p3 h9 H8 ^+ ?: z0 k
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    : ^/ \" Y' `1 |: h$ K& d6 o
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    + \: M' \, @0 X. [5 D+ d: Z6 a
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    / [& p! `. `5 ]8 ^' t
44.         bsp_InitUart();        /* 初始化串口 */
    ) |4 i+ ]2 y! Y$ D8 \
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    $ P3 ~1 [1 j" o: b6 r
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

( Q, G( p% I; Y) F2 p8 N  MPU配置和Cache配置：
* e' i! ~  v6 v8 p) Y' v  S
1 a) O8 {9 I3 I$ t- \' M5 R. w数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   % e$ N2 J, `+ ~( R7 r; d/ s
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   4 t& F' z/ i+ w, i2 a
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   & b/ ]6 H/ [: Y/ {7 Z
7. *********************************************************************************************************
   # ^1 P1 @9 @% T
8. */
   
9. static void MPU_Config( void )
   + a7 b: q/ L5 b, Y4 B
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ! J* A$ W$ i7 G0 X: {6 F0 L2 C
12. 
    
13.         /* 禁止 MPU */
    , u+ Y1 [( w; \( Z
14.         HAL_MPU_Disable();
    ! V0 {* q9 e) u6 q& H& @
15. 
    2 D7 c- @. H9 l$ ~, w, [
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    - `2 v9 x: p9 Y7 K/ F
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    : n3 v8 }# D7 ~5 Y( u" \$ n
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    - P5 z% t0 Q3 @: e$ ]
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    & C& |0 L1 m( D& m; Q1 ]( C
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 B* \$ j' B# y5 I( W2 W
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    3 u& t9 M; k6 f9 G) A2 R6 @8 {9 q
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    # D$ Q+ ~/ C' O1 I  Z' N
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    / G' w' H' i8 G/ v2 v
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    . c! j! W. {8 U. u% T5 b( b& P7 ~' H
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    7 h- @3 t6 }  ?
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ( f- Q: `! D. e' E' U' e- V
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ! Z" u- e. S. _$ b' _
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 R+ F) `0 u& l- A7 ^2 V. B7 b7 K
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    # `9 u6 v3 d2 G% S3 J& ?
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ) n- r5 Y0 S: M3 t2 @
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    - C- S" x3 m  [' D7 z
47.         /*使能 MPU */
    & c2 Z1 `% h" E
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    8 `$ Y8 r; {7 |  a' [% N* `
51. /*
    * G  X& G6 k0 f  x
52. *********************************************************************************************************
    6 H7 `6 t, R8 T7 x, |7 P* |
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    / u1 f6 |% F4 G) f/ t8 s
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    5 X7 ]. Y: s9 P& c3 u
58. */
      `% X5 ]  Z3 w) S  L
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    7 E2 d+ v2 t! g+ z% v
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    ( d/ A1 w$ ^) n. w8 {7 d
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次蜂鸣器处理：

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

1. /*
   
2. *********************************************************************************************************
   8 z( p/ T! d. \7 K
3. *        函 数 名: bsp_RunPer10ms
   : [# o! ^( b, ^' l; _3 L
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   # H' t& L1 O  Z
7. *        返 回 值: 无
   7 o/ p1 o, [0 G0 c' T2 l0 Y
8. *********************************************************************************************************
   9 N% X; p) H: u- i6 J  i% S$ ]
9. */
   
10. void bsp_RunPer10ms(void)
    5 C6 q5 ^& N& G1 k& z
11. {
    , S4 Z! R1 E  S+ {3 K) A% D2 J- T
12.         bsp_KeyScan10ms();
    7 ^' I0 P/ [$ S
13. }

复制代码

  主功能：

7 l. {- C# a7 X+ t9 O# R* {4 t主程序实现如下操作：
0 q& N1 E4 C  a5 ~; _5 I- o4 o
6 i' r- v, X; K9 A! [  启动一个自动重装软件定时器，每100ms翻转一次LED2。
/ E3 H0 N% a  }! i0 R0 Q) N' u  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
- f. A. f+ L7 G+ [0 E/ m1 G. q& P5 @  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
) r% ^" z/ Y$ U5 K5 r5 q  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
( H4 W* p9 g/ [4 k9 C3 W* n" f, ^  K1按键按下，串口打印"按键K1按下"。
2 H5 c/ c7 t+ `$ Q" c4 K2 d5 o  K2按键按下，串口打印"按键K2按下"。
% ~: |' X: T7 K0 r: s  K3按键按下，串口打印"按键K3按下"。
. t1 F, V: Y4 ~5 |2 K

1. /*
   8 Z: t8 B; ^. c2 a6 V
2. *********************************************************************************************************
   5 Y3 P# O# f- G
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   * H7 C) a# K8 p. n* D& _
9. int main(void)
   
10. {
    . }9 S5 A+ u% q
11.         uint8_t ucKeyCode;        
    7 o  F  D+ N% f
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    8 c' i6 p9 t, w- ~/ A7 t. I
14.         const char buf2[] = "接收到串口命令2\r\n";
    6 [  Y& u$ U; g' ]0 }& j0 K! f
15.         const char buf3[] = "接收到串口命令3\r\n";
    2 V$ D4 u1 D! R: d: c6 I( X
16.         const char buf4[] = "接收到串口命令4\r\n";
    , O9 l  t4 }' m! W' \  ?- a
17.         
    ! q1 w; g$ n5 R$ s& j6 I
18.         
    5 E6 X! E1 g; p6 u: @
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    - Q2 W. O- X: V
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    & ?- O2 \3 q3 V* U
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    + `  A3 ?# R4 \) P& F0 _
26.         /* 主程序大循环 */
    , Y/ A5 Y( z7 ?
27.         while (1)
    9 T- ^) ?& g$ `, H4 W
28.         {
    3 g! y" l1 O1 `9 x) ]+ w+ P
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    
31.                
    7 C1 V' n+ J, I& X! i) H, S
32.                 /* 判断定时器超时时间 */
    . Z7 u3 N% M" e8 z
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    7 b1 G# V% g, ~4 h; h) |! Z
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    ( v/ A" _0 F7 X! R
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    ) |% k% T$ v: |3 O/ Z2 w! c
42.                 {
    
43.                         switch (read)
    8 y5 X4 \* M" h+ x# X) j  f; |" z7 d
44.                         {
    & U; q2 e: {" ?/ [
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    6 X: Q7 i) m  Z+ a
47.                                         break;
    
48. 
    6 R9 Z4 {. Q- e8 q: w; J  m0 V3 u
49.                                 case '2':
    : n# W8 ~1 H. m  H3 r* E( r
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    
52. 
    7 {  J* x- W7 }3 b' g$ M6 a. \
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    
56. 
    + j( ]. i; t: ~) V3 r8 {' I' _' N
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    3 U  r3 @7 F' [) v& r
59.                                         break;        
    + w) `% ~$ I" u2 P
60.                                 
    , x8 ^; t& }4 H' \) c5 Y, t/ C9 ]
61.                                 default:
    # d" K+ O0 v/ `/ `9 U
62.                                         break;
    2 y7 M# J' i+ X5 s" e2 W, u3 q
63.                         }
    $ D% n. ^$ o! t9 o9 y( f
64.                 }
    1 s. p6 h4 ^3 v3 q. s) s4 [6 _  C
65.                
    
66.                 /* 处理按键事件 */
    - K' i* h, N3 W8 Z- D+ u( o
67.                 ucKeyCode = bsp_GetKey();
    : H4 k* }& d9 C; a' @; u) @
68.                 if (ucKeyCode > 0)
    
69.                 {
    3 N9 ?$ K$ d% r2 d& O  u5 B
70.                         /* 有键按下 */
    2 B* ]" y4 S( \
71.                         switch (ucKeyCode)
    
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    ( [0 C( g  R1 q' V5 ^! X, k/ t
74.                                         printf("按键K1按下\r\n");
    " B- c8 c' K$ Y8 z0 G
75.                                         bsp_LedToggle(1);        
    ( a# b; T% w" ]3 X
76.                                         break;               
    3 M" j0 L' J( n9 Z2 o
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    5 ~3 b: B# o0 E3 w6 T, N2 s. @
81.                                         break;
    
82. 
    ; N: D& F5 ?. i4 o  W
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    ; L- e4 L/ H2 y* ?
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    
87.                                 
    & p, v$ @1 ~1 T
88.                                 default:
    
89.                                         break;
    
90.                         }
    
91.                 }
    ; y  t7 n9 R6 y! t
92.         }
    0 k( E0 D1 l0 C3 ^1 v
93. }

复制代码

30.8 实验例程说明（IAR）
( i+ _3 v4 S( A# v' M$ n! a9 n& F+ h配套例子：
" h+ N6 v( Z- Z: h" }& p2 V. _) z
7 T# l! ^) L1 z! l6 T9 iV7-015_串口和PC机通信（驱动支持8串口FIFO）

实验目的：
# \+ J) b- ~' T* ^% n) |学习串口与PC通信。
1 Y# o, d1 y1 [
5 J; M& T' P: b# q, ^0 T0 C
实验内容：
! q7 T& x8 g. n1 s启动一个自动重装软件定时器，每100ms翻转一次LED2。


$ T  c- E; c9 L实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
3 e# m3 o( Y5 c7 }/ F1 s串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
, D  K2 P, F, |# }) o上电后串口打印的信息：
: q6 e& [$ N7 i. t  `+ n
波特率 115200，数据位 8，奇偶校验位无，停止位 1
2 P5 M! T& B- D0 M

6 w/ T# ^* H' H# }8 c0 W
% \2 f) n; P; O7 c% M7 A+ S4 @4 B程序设计：
& R5 R1 H1 d! X1 {
   系统栈大小分配：

0 W) u# A# e* S0 c5 X! T) u7 f! B
   RAM空间用的DTCM：
7 j5 \9 [/ d4 z. I4 r

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
! g4 Q" z" p2 w, A7 d$ t$ k3 e7 H
" S! i* I9 B9 ~4 w" P/ r5 l

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   % y& j0 ?- b6 n
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
     a: @% W  G' [' z* }
6. *        返 回 值: 无
   ; O5 e" }3 t+ Z
7. *********************************************************************************************************
   ) X+ e: V' a9 s+ L
8. */
     B7 m% a9 t* V) g3 ^
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    - z# q* O) E% \6 F- A. O8 Z
12.         MPU_Config();
    % ^8 @) x) ^: q( @9 {: A7 H( |; S$ e
13.         
    $ W. D0 m6 ^, `5 V; D; w
14.         /* 使能L1 Cache */
    ! u. N# {1 O" C, I" |
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    . b( S' |/ A% ~; L
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    0 b' z* c( Q) |. `2 d( e- e
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    ) _, F+ ]+ x" u9 h2 n% ]. M
23. 
    
24.         /*
    : v' ]2 C5 u% z: m( _! e$ o4 Y
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    / Q5 B! P  V2 i& W/ o3 m
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    3 }& a5 O) _4 _8 G% T& g4 e
30. 
    
31.         /*
    & Q" j2 g1 e3 y7 \2 e2 s
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    2 E8 A/ z* i* _* Q. x$ g& c- h, w* i
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    0 t- O. k# B! X& ?
38.         EventRecorderInitialize(EventRecordAll, 1U);
    3 \7 w5 X& D/ a! K
39.         EventRecorderStart();
    1 Y, H6 P# m) O1 b+ G
40. #endif
    - b3 {. R/ H& }( R: ]# q% r
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    " U' O" W0 z) l  W& C; V  I
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    . D2 `! M" Y" ?7 H, N
46.         bsp_InitLed();            /* 初始化LED */        
    ) y- h% A  s+ o6 C! p" [# i
47. }

复制代码

  MPU配置和Cache配置：
% d1 E( e  g/ u7 v3 N
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

; _4 ]) {7 b2 i; D0 A: S

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   8 v% F( L: z* `! L$ W  V
7. *********************************************************************************************************
   
8. */
     W. q" j" A7 i3 m
9. static void MPU_Config( void )
   
10. {
    2 Z+ k  i4 ]3 e7 M- N8 _# R. D2 J& ?
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    2 N$ ]6 u" N  N/ e- g' n
12. 
    
13.         /* 禁止 MPU */
    $ X$ R! O* T7 m9 D
14.         HAL_MPU_Disable();
    . f  r* r7 f2 i  V
15. 
    $ [: F. }: X. q& k' u2 G
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
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;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    7 O* T) ]* `0 |' g& w; G
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : k" l  i# u8 L- |) E4 f1 j6 b
28. 
      G% R, _$ Y  M9 ^- [% t
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 p6 H0 d5 G  p3 |. p" n
30.         
    & S+ X- U2 Z; h" f: B/ l) m& L
31.         
    3 F0 G" W& X- v! `. Q% U
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;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 U' ]. L5 b0 T% b! R
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    + L! e; r8 D; g- Q; x: C, i
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    9 O% P# _2 B. ^& `
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ! K5 ~: i* z& f6 |( i( F
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    1 [* Z$ ~4 m: N9 p
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ H" k$ M% z* ^2 }
44.         
    : e( f  ?3 ^$ _
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 w) p+ ?& y0 ?" J3 }) L; y% q! `
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    ) L' k+ \/ @& y4 N1 \8 R8 V
50. 
    / I; L* d& @6 z2 u  I2 R- _
51. /*
    6 o2 e3 D, z' v
52. *********************************************************************************************************
    - u% ?6 y- j  D  j5 K
53. *        函 数 名: CPU_CACHE_Enable
    $ o: j  L' j0 y' I* G( _6 {  |% j( Q
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    + c! R% Z  a6 B7 F
57. *********************************************************************************************************
    
58. */
    $ I% C7 |2 u# F$ ~3 Q
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    ' g$ f2 m, V( }$ M( S0 [
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }
    
67.   每10ms调用一次蜂鸣器处理：
    
68. 
    
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    & I+ c! P2 _! I4 H2 ~- l$ P
70. 
    
71. /*
    9 _* D& ]; {9 ]8 l+ I. E
72. *********************************************************************************************************
    
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    , {  O% M, i% F$ P0 v, r  U
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    
79. */
    ; ~, Z5 `- G- K
80. void bsp_RunPer10ms(void)
    
81. {
    
82.         bsp_KeyScan10ms();
    6 }9 k. s) E5 R% Z! |
83. }

复制代码

5 b9 n  A( _4 I$ r" A( c  主功能：

主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
( g6 S+ t; r) Y' S0 u3 M  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
" g$ E( A7 A. V* w7 z( t  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
6 z1 K$ U# a9 S  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
, q0 R6 \0 k6 W! l$ r# V/ D( L  K2按键按下，串口打印"按键K2按下"。
: u  f0 z- k: a# E" W* x" k  K3按键按下，串口打印"按键K3按下"。

1. /*
   
2. *********************************************************************************************************
   2 Z0 \: f% }( j
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   : T( j, w  n3 V( u* P, W
5. *        形    参: 无
   , ^' r/ i8 @7 L7 v/ G- c
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   2 m1 W8 J* j% @& [- N! D
9. int main(void)
   & a1 y0 T& {0 z! P! {
10. {
    3 Z& i9 L( W; Q2 U* g5 g
11.         uint8_t ucKeyCode;        
    + _: w9 y6 |" _' w
12.         uint8_t read;
    * g) K. D1 Q  \9 _1 d7 [7 n
13.         const char buf1[] = "接收到串口命令1\r\n";
    * N  \/ W; X' V% \8 g' q
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    , G  P' U, Z& T
16.         const char buf4[] = "接收到串口命令4\r\n";
    4 S* Z$ b' L! Z1 [4 a+ w( g) R
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    $ `* }9 y5 @8 }) d! h# n
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    & l1 r4 ^* V/ `4 o* u/ G( g( ^0 o4 }
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    , L" z! \6 R- q. o
27.         while (1)
    
28.         {
    ( i; O$ J4 x8 X, N7 T1 U( A
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    $ w( J! T6 f$ i/ H7 \6 r- X
30.                 bsp_Idle();               
    # j1 R$ n0 [5 n- d
31.                
    6 O' q* P3 U0 u! T9 c
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    & x. C- j. b: B- ^% {1 W
39.                
    : n! |/ H2 `( Q, ]3 e6 t! S' K* U& M
40.                 /* 接收到的串口命令处理 */
    . ?7 Z; D8 ]# \9 |/ e! T! x
41.                 if (comGetChar(COM1, &read))
    $ g2 B/ K0 d1 j
42.                 {
    
43.                         switch (read)
    
44.                         {
    ' J/ ]* B0 [6 h& w
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    0 }5 F5 g4 X& V" f, g' h! F
47.                                         break;
    " r7 p' |2 C' F% a
48. 
      f" H4 @' q2 G1 C$ h9 c& H. n
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    * x, _5 R# A- o1 b9 _' M6 Q
51.                                         break;
    $ }$ P" Z) H$ \
52. 
    
53.                                 case '3':
    ; q% B# ^  J8 n0 w7 g
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    - ]! e9 C, _. y4 E+ E
55.                                         break;
    
56. 
    / r# \- L% B' A9 K# h1 E0 z! s
57.                                 case '4':
    - v7 |% J) q/ s1 k# l. |8 m9 p
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    ' j) z- |! ^9 S. v2 Y; g2 ]
59.                                         break;        
    # P( E2 S' r  y( m+ J: r
60.                                 
    
61.                                 default:
    
62.                                         break;
    
63.                         }
    
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    7 {( A4 V0 X& k3 L/ I" z$ A
67.                 ucKeyCode = bsp_GetKey();
    , M! \6 |9 X5 h0 k- E4 s
68.                 if (ucKeyCode > 0)
    0 X9 X+ C& s8 O1 V5 x
69.                 {
    ! \$ O+ q/ J1 b: k
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    1 O9 S% U" d* Q& w4 o) _
72.                         {
    # ?$ B1 [2 B4 ^3 o- N6 p" \
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    " s5 }" `' J  u+ w& x8 \
74.                                         printf("按键K1按下\r\n");
    " R" @- z7 c9 v9 Z' S+ X0 n
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    % c5 w1 n  b9 W5 O5 O
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    " u4 Z0 h/ T9 ?  A# P( Q& }$ S$ {) s
84.                                         printf("按键K3按下\r\n");        
    8 |0 W1 o3 s# Z# }
85.                                         bsp_LedToggle(4);        
    # _# O0 ?3 A3 b1 `
86.                                         break;                                
    8 t' g# y5 l" f- v" N# h# D3 X. V
87.                                 
    : i1 Y7 J4 q% @4 i* r  V% ^
88.                                 default:
    * d" n+ E8 ~; S( Q) T! e
89.                                         break;
    
90.                         }
    
91.                 }
    * v% Q+ u0 j' M, w! Z
92.         }
    
93. }

复制代码

8 n" c  E) b  Z$ G30.9 总结
8 U' |. j- E6 J! R" }. ~本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
3 p' u# I; A, N; {! F; P
1 U! p6 T: q2 [& u7 Y$ j" w

' x+ N2 [: A* }/ `: M

0 v2 g  E! ]& |+ m" {  {