30.1 初学者重要提示
学习本章节前，务必优先学习第29章。
7 `& B  o; c& S6 z2 w  Z: @. p/ ^% K2 W串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
CH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
30.2 硬件设计
- e6 r! Y. ^0 s  p* G% Z1 O! z* mSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
* M6 v/ B8 ~. r0 k8 g4 }
* `7 X! f. a/ z串口USART1  TX = PA9，   RX = PA10
: C' t' A& a- ~* X
3 t' [! p0 e% C3 t6 B; Y串口USART2  TX = PA2，   RX = PA3
% T& W5 i* Z* x9 Y
/ P$ \5 H( H; I/ i, w串口USART3  TX = PB10，  RX = PB11

串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

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

7 S9 t- T4 g0 ~6 H- |. ~5 ?串口USART6  TX = PG14，  RX = PC7
- c1 J9 m  g; C  e
, o7 M) E0 U$ i. t& i; \  I# T串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

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

串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
; O! z2 b& ]  y6 ]2 _+ W5 Q串口2用于GPS
+ s: L  w/ Z; `2 ?; p7 ^串口3用于RS485接口
串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
- ^' q; F2 ]$ |* D1 e7 R& _, `

$ r. x1 m# p8 P0 E关于232的PHY芯片SP3232E要注意以下几个问题：

( J# W: v% b% T; s6 O7 e, ?& x' hSP3232E的作用是TTL电平转RS232电平。
! z# ~9 l, z( P# M9 h9 D电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
/ q# l& X" q/ c4 j+ s4 _检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

实际效果如下：

通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。

3 V9 i' g1 }5 \! P0 }由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
; p% {6 M6 h8 |( H1 T' {检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。

) N5 [) W1 C( S) F( u7 N! z9 Y" S9 A30.3 串口FIFO驱动设计
" h; _% A8 U" P* _30.3.1 串口FIFO框架
5 l( w" Y3 F) Z" {' O$ Q为了方便大家理解，先来看下串口FIFO的实现框图：
) q% d- |" q* p3 ]* x- w4 Y$ `
1 A1 A* n2 G' k. J4 {% ~4 g* |

第1阶段，初始化：
6 |& ^5 k) ^4 o- L+ m/ {! t8 c
通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
第2阶段，串口中断服务程序：
8 l7 r4 i3 j3 D8 f  ~
接收中断是一直开启的。
5 E# A. M% z# l; l8 n做了发送空中断和发送完成中断的消息处理。
第3阶段，串口数据的收发：
* x9 Q- [4 x4 H" _2 D5 z
串口发送函数会开启发送空中断。
串口接收中断接收到函数后，可以使用函数comGetChar获取数据。

0 O- f* ^1 D* I. s30.3.2 串口FIFO之相关的变量定义
2 g& X/ g7 H, H; q1 a( V串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。
& ?' |$ D$ Q% e/ r0 s- \$ e
- t) l  g6 e; `% d' ?每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

7 p7 j7 ~, H8 a, n- g8 v* ]我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

6 r! m8 V6 G! H' @

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if UART1_FIFO_EN == 1
   
3. #define UART1_BAUD                        115200
   
4. #define UART1_TX_BUF_SIZE        1*1024
   $ Y7 Q$ |6 m( }( Q
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   7 l0 z: N& A; Y' p
7. 
   
8. /* 串口设备结构体 */
   
9. typedef struct
   $ [6 U* h; K. J2 L5 t5 {3 x
10. {
    9 g. z9 e4 I2 D" b
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    1 M. m2 q( |- M0 o4 q
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    , U" R' }7 ]1 `+ D; k- U2 l
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    , J/ b; e% x7 n
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    $ h% d; t7 t1 H4 I. T
19. 
    2 b3 [$ r3 q; {* S0 @; Q
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    ( J5 {! ^2 a2 x: e/ n) E3 f0 W
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    9 i8 j- ?, ]5 ]. q7 K5 u4 g- z) `
23. 
    % @4 `% F/ ~; B& G4 U, _2 v
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    * y( F  V" H& F
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    
28. }UART_T;

复制代码

9 C) l0 F) @: D7 G$ z. m  ]2 |bsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。
: u( k  h9 G' ~  m/ }. b9 L8 z1 v/ `
) t8 e0 |" }- n7 U4 f* h

1. /* 定义每个串口结构体变量 */
   
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   : W) x$ N$ T7 |- f! k" R  ^- Z/ s' S
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   
6. #endif

复制代码

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

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

1. /*
   
2. 
   
3. ---
   
4. 
   
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   
7. * 形    参: 无
   
8. * 返 回 值: 无
   ) [0 w1 f$ L$ I7 T; u; R* R
9. 
   / Q3 p9 \. m) k; j/ V9 g
10. ---
    2 F- R8 t3 h% {2 \
11. 
    
12. */
    
13. void bsp_InitUart(void)
    
14. {
    $ X# H0 L; X3 o, ?4 b
15. 
    0 ~/ Q5 ^, x% v- O# F, \: ~
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    . l5 a, T& [3 u( X+ W
17. 
    " {& E) |, @& u: ^/ e% N* U; Y6 D2 J
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    ' h- j6 X; A7 ?/ d9 F" `1 F
19. 
    1 J9 J7 p$ I2 ~+ g5 M
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    6 \: i9 T- s5 K9 I+ X- r& o* W
21. }
    , a1 x( [" }$ b6 T3 j% }

复制代码

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

函数UartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

$ @1 A6 g6 N5 \- b3 p; O, W

1. /*
   
2. 
   5 \- l  {% o1 e3 H' h
3. ---
   5 l& i( b& H0 f2 D2 W% n) r" {
4. 
   
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   
7. * 形    参: 无
   1 [1 O7 a7 X2 |* _- B/ m5 K9 b7 E
8. * 返 回 值: 无
   2 \3 ~+ V! w' {  C4 ]
9. 
   
10. ---
    2 ^! u0 z. b5 N
11. 
    
12. */
    
13. static void UartVarInit(void)
    : @) l2 r# m4 z! p' X" E3 `
14. {
    6 I3 @. o, Y$ F$ f
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    3 \; {0 c+ p. O2 I1 o  _6 A
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    - U) C0 Y; q9 _4 V2 v; i( b: _$ q
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读索引 */
    " n0 S4 I6 {) H0 L% U6 i, V6 O
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    8 p; V1 K: i  z) h
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
      }. S6 ]3 o: n/ X8 t: Y
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    # @9 T! Y; @: ]6 P, h
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    
31. #endif
    
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

& w# x, \8 ~$ _& u2 o# e函数InitHardUart
此函数主要用于串口的GPIO，中断和相关参数的配置。

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   7 X8 D! n5 N: B2 K
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   $ j$ D1 e% q! o  O/ }5 R
3. 3.        
   ! W: P# _# O6 p" p9 C9 b  }
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   7 n2 ?/ \% o7 p( ^
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   - V/ w6 {3 \% i" Y9 W+ e' }
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   
8. 8.        
   
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   : Q5 V# C+ I. z' U  I3 j
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    $ F0 y3 W1 E4 E: O; c5 |3 {
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    
15. 15.        
    
16. 16.        /*
    1 ], {8 `8 L8 A' w8 B
17. 17.        ******************************************************************************************************
    5 q- L& F5 Y1 C4 W8 E/ O5 O2 q
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    
20. 20.        *              发板
    % F. g, d" d1 O' F+ q2 T" i) ^
21. 21.        *        形    参: 无
    . v: @/ {/ {( V+ {# f& H3 m( Y
22. 22.        *        返 回 值: 无
    5 G+ J% @9 n: A! M1 z
23. 23.        ******************************************************************************************************
    
24. 24.        */
    ; `( t4 k% a) b- [
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    / C9 U: S6 r+ b& `
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    ; X4 j4 p) n# L* k" a& t2 ]/ B
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
29. 29.               
    & N. M" R8 `' I% w
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    , L3 `- E5 q, f6 b% y9 g* j. j0 m
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    , f0 E- V8 c6 J: M+ Q6 g
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    ) I, H/ S, P1 @  M
38. 38.        
    6 N+ o5 G; I3 _0 M. q- L
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    5 n% U0 O2 G+ ]- l
44. 44.                /* 使能 USARTx 时钟 */
    
45. 45.                USART1_CLK_ENABLE();        
    
46. 46.        
    * [, A" H# C  t5 H& F" h: k
47. 47.                /* 配置TX引脚 */
    : \4 l3 P& X+ V" r. w$ Q) k
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;
    * @! W( o2 E' W* r6 P$ ^
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    9 ?" ~/ p- V& _2 e5 [$ N
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    - r1 R9 N' [9 k- s
59. 59.        
    
60. 60.                /* 配置NVIC the NVIC for UART */   
    4 o7 X; S2 v2 c) O: m+ ?- W
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    + h+ K+ }! ?* A6 B9 j
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    
63. 63.         
    / q7 ^9 D/ r- e; [
64. 64.                /* 配置波特率、奇偶校验 */
    $ r( q) ~" d/ N8 K& A. e7 G) i
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    / _1 ?  {6 U0 E/ c$ {/ i- D3 J
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    # [. Z& L& C+ ~! P
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
71. 71.        #endif
    
72. 72.        /* 串口2-8的初始化省略未写 */
    " F3 |; A1 m% B* m
73. 73.        }

复制代码

6 E! s. W2 C! E. }第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
4 }# Y; b$ d' K" g第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
                                                                                                                                                

1. /*
   # m  J' Y- k* ~# ^' y+ U, v
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_SetUartParam
   
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   6 i( Z. v2 D1 }( G$ x3 |
5. *        形    参: Instance   USART_TypeDef类型结构体
   / h: E* `3 N% ^+ z4 \
6. *             BaudRate   波特率
   9 C1 a% ?- m% N( o6 m- I( k# U5 y
7. *             Parity     校验类型，奇校验或者偶校验
   * I% \0 _7 u# Q4 Q
8. *             Mode       发送和接收模式使能
   " D) p5 E: d& L4 i. C4 L
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    . f6 f0 ]8 s: ?: U
11. */
    
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    % u" m# V2 a7 h/ k, J& x7 ?5 {( P
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    $ V+ U9 l, r: m$ E+ z
15.         
    ; x7 Q% Z; E* h" s+ R
16.         /*##-1- 配置串口硬件参数 ######################################*/
    7 a# T3 g" f- R. y/ ]0 E5 s
17.         /* 异步串口模式 (UART Mode) */
    4 D: K$ _& c* h7 z
18.         /* 配置如下:
    . w4 c- H- ?* d7 t0 O
19.           - 字长    = 8 位
    : `3 u" F5 J" Y! _
20.           - 停止位  = 1 个停止位
    & Y" T5 y' {* a7 s% ]) W$ P& R
21.           - 校验    = 参数Parity
    
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    
25.         UartHandle.Instance        = Instance;
    
26. 
    0 A5 f; u1 n5 V2 e7 N& ?
27.         UartHandle.Init.BaudRate   = BaudRate;
    
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    6 Z6 `! t' P: f9 c4 z  a+ H
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
32.         UartHandle.Init.Mode       = Mode;
    4 ?! ]# J0 k' Q8 M3 o
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    * P- k: t4 f# I7 f9 Y
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    5 z" _3 q1 N8 N  g  d- C8 ]" J
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    , ~# \3 T, U6 K8 ]% l+ O
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40.    
    + T  l% c1 h# `! ?( w
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
42.         {
    
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    * q; D/ P: _, Z' u; C. K
45. }

复制代码

4 _) }- c  L+ B! T
! r: t& \! S$ S8 P) z函数RS485_InitTXE
3 Y1 E8 e  @* M3 x5 G此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
9 ?3 P  J! b0 Z! ]% o6 ]+ J2 m

1. /*
   $ G7 W( D! e6 N: [
2. *********************************************************************************************************
   + n' m" Q7 c9 [! ]  w
3. *        函 数 名: RS485_InitTXE
   ( _; M2 b& ]! @1 P6 `! S9 |, O
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   9 r! B7 r. A) Y
7. *********************************************************************************************************
   ( j! r  q$ ?# O& f* _3 H6 p% P8 t5 K
8. */
   
9. void RS485_InitTXE(void)
   # r5 f1 Y1 M9 H+ {. B
10. {
    0 H; P: ?" n- p5 g
11.         GPIO_InitTypeDef gpio_init;
    
12.         
    - Y1 `* U+ [1 s2 T* B
13.         /* 打开GPIO时钟 */
    ) t# k% R& J5 \) u
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    
15.         
    
16.         /* 配置引脚为推挽输出 */
    * `# K- X; v+ G2 S
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    ) B. [( ]) v2 P6 N
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    2 i2 w0 \0 U& u4 A/ C. k
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    
22. }

复制代码

30.3.4 串口中断服务程序工作流程
; w% _! r; w0 w/ U1 o) D串口中断服务程序是最核心的部分，主要实现如下三个功能
) Y0 F& I% S' m% \7 n7 f
7 p$ H& f% a! R0 R. g收到新的数据后，会将数据压入RX_FIFO。
: R3 v. w# w% E2 o! V4 y3 m+ r5 j: ?* N检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
/ j2 [' P* q) u如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
) R; [# |" Q* `7 R% u) o
* P' O, Z6 o+ d. K; N1 J下面我们分析一下串口中断处理的完整过程。
3 S; i) O2 W8 T6 O' D% t6 ]* O/ @/ O当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
" J7 D" B3 a7 X; M2 \
我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：
+ O* b2 Z  n" f) z+ y

1. #if UART1_FIFO_EN == 1
     C$ }' `$ A9 o  O: p( A2 G. y3 U
2. void USART1_IRQHandler(void)
   
3. {
   , I% J  m/ h: i( g$ D
4.         UartIRQ(&g_tUart1);
   . C$ B* w2 \& W
5. }
   
6. #endif
   0 G0 L8 ^! i1 }* ?
7. 
   
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   
10. {
    
11.         UartIRQ(&g_tUart2);
    ( \$ P6 E3 J' B5 `7 c* G
12. }
    7 {/ r: r2 W/ {  m; P" E
13. #endif
    
14. 
    * ]% \, l! t3 y2 W6 U1 g6 e/ |
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    1 ^# c7 G% Z* G+ U
17. {
    * p) j6 e8 s/ s8 S
18.         UartIRQ(&g_tUart3);
    
19. }
    1 W2 K1 \8 K( \: w7 d& E# T
20. #endif
    ( {9 e0 }4 `+ ?) }
21. 
    / L+ ^& M+ U# S  h* [; p# ]: |9 G+ {
22. #if UART4_FIFO_EN == 1
      [, M, }8 H. {; N1 Z0 ~1 o
23. void UART4_IRQHandler(void)
    3 r7 q, x% K8 @/ @! M! A
24. {
    % j! X- n$ `, {9 e6 b: p9 K7 K7 G
25.         UartIRQ(&g_tUart4);
    , V, q$ T* M, ~' a1 n
26. }
      v0 }9 o6 C2 K  y; V) s! b) d
27. #endif
    7 i# J- i) y- V  T. b* u1 ~
28. 
    1 |0 x" d  h7 Y% Y5 ?
29. #if UART5_FIFO_EN == 1
    % C) Y- A5 x0 R' u6 Y  {
30. void UART5_IRQHandler(void)
    
31. {
    
32.         UartIRQ(&g_tUart5);
    * C7 J% c6 c9 D6 t' U" e
33. }
    
34. #endif
    
35. 
    
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    
38. {
    
39.         UartIRQ(&g_tUart6);
    ' m& t  @+ I  G7 k3 b
40. }
    3 N& G3 I( a; e
41. #endif
    # ?; l$ K, e( R# C4 j& G
42. 
    
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    
45. {
    " {) z' c8 z2 L0 |0 J
46.         UartIRQ(&g_tUart7);
    
47. }
    4 v  v! _2 V8 Z$ k" W8 ?5 k$ z
48. #endif
    
49. 
    ( ?1 H- h* Y' Z/ N' o  F* u
50. #if UART8_FIFO_EN == 1
    3 p, F3 {$ M* K% f- V
51. void UART8_IRQHandler(void)
    
52. {
    - c$ f, P# L! r" y" F
53.         UartIRQ(&g_tUart8);
    1 u! T- [, R& R! X
54. }
    
55. #endif

复制代码

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

下面，我们来看看UartIRQ函数的实现代码。

1. /*
   7 c7 e4 a# C! a+ z6 k
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   7 a4 u5 F8 T& |4 R2 c" F  Y: e5 L
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   % i2 O: N3 J2 R) g* T3 B
7. *********************************************************************************************************
   
8. */
   6 S- ~& I' O  ^/ w  H# Z
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
      h! y6 Q* J+ B4 s6 b4 W" O
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    + c7 H( j! I/ J9 b& l+ a) |7 t2 a
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    ! y& n  d/ o/ O0 h* G" U
14.         
    ! x3 H. U4 Q$ e  ~9 z) J
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    " k7 o, {3 B, y
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.                 uint8_t ch;
    7 F# \& V9 P8 U4 D/ ^5 X
20. 
    8 L! k$ {. B5 g
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    . f- K! C, M: e. K7 q1 I. M2 w: B
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    , u0 ?+ V+ t+ }
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    ; I) v5 W5 n) x5 h* t0 h: n  U
28.                 {
    
29.                         _pUart->usRxCount++;
    
30.                 }
    
31. 
      M/ ?! Z: m$ i
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    9 j  T) W1 n0 ~
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    ; b  a) p. p3 v  j" T+ d1 Q7 X; B
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    9 P7 n2 A! Y& C& {" c: ?4 ?. B
36.                         if (_pUart->ReciveNew)
    7 X% m) w+ b( R& }/ Q' r2 {2 m: {. X
37.                         {
    
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    3 C2 f) M+ D0 ~% {' L# l7 K
39.                         }
    
40.                 }
    4 E' o& H% t6 R+ @. P# G5 i# N2 A8 J) Y
41.         }
    
42. 
    0 j- g! P$ ]: _+ N" A
43.         /* 处理发送缓冲区空中断 */
    3 u5 B: g/ X# A! y& G
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    ! E9 {1 c9 |0 g) O
45.         {
    
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    5 z7 `1 Q9 u5 L: ^
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    / w: L/ r& Y' I+ B0 S5 B% C3 |
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    6 T* r" Z: L8 Z( U9 i( e9 H
52. 
    9 B& M9 e1 N- m: P: e3 _% C; w' E
53.                         /* 使能数据发送完毕中断 */
    0 X3 B' N4 m8 l6 W+ [
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    : J0 v" j8 C; E7 J
56.                 }
    
57.                 Else  /*　还有数据等待发送 */
    # A# q, V/ I# P) m
58.                 {
    $ u2 |) j9 N5 x/ u% E
59.                         _pUart->Sending = 1;
    1 U7 f; a7 |6 R4 i  [# u
60.                         
    9 h9 z6 G% O9 O- z$ O# ]# c
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    # o: e8 V) O: B% g: D
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    / L$ G4 N# F4 T7 S
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    
68.                         _pUart->usTxCount--;
    0 X& _( E9 v, o: F- k. |
69.                 }
    ) Q4 `; Q3 W0 H3 ]" w
70. 
    0 F2 g9 U0 _  s7 D8 b
71.         }
    ! h' f$ g2 v! ]' r) d4 ?9 a# S% |% f( o
72.         /* 数据bit位全部发送完毕的中断 */
    
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    0 K& s4 c# p8 n& j! a
74.         {
    * T6 s5 v; e& R3 X! ^
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    9 Y1 e; _+ r1 W+ w: w9 N  m
77.                 {
    " f; B. l4 s) b9 V
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    : Q3 m" h: F& B
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    - @  F; `$ r' K* X: v3 I1 }
81. 
    3 `$ f9 X- c0 d1 I: M8 i. ~
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.                         if (_pUart->SendOver)
    
84.                         {
    
85.                                 _pUart->SendOver();
    
86.                         }
    ) e, Q, ]; F, ^3 }% W( X6 v& s
87.                         
    
88.                         _pUart->Sending = 0;
    3 a  ]/ p( r  x$ `: s8 m  P2 u2 u
89.                 }
    
90.                 else
    
91.                 {
    
92.                         /* 正常情况下，不会进入此分支 */
    + E- B3 g1 M6 f# m( T+ N
93. 
    
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
      Z3 c- w, T7 H! T" h
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    4 s$ F, ^3 n0 G( H
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    * n0 n& D* ]: }
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.                         {
    
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     * c6 p: _' s# C6 K. m1 B: \
101.                         _pUart->usTxCount--;
     & \  I) @8 b; S/ @# V) U+ Z
102.                 }
     7 }3 J$ H) K, i5 Q
103.         }
     
104.         
     5 ~+ m) Q' i  @, g; g& T
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     3 Q5 K4 L) D! r5 ]  A& S: j
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     " ?. y) Y% U2 Q# P
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     ) z' b: _3 P$ A$ H/ w! E; N- K
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     # I, S: n: `; E
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     ; P9 {& U" p# h- R, U; A( Z) {9 f2 a
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     . e: O& A" n7 v* u$ Y
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     / O/ k; X) g8 e) U
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     , q4 e5 u5 X7 h% C' l
117. }

复制代码

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

1 \9 ?, t! N' _( [+ a* A/ `  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
' F8 K( `) G9 H: e+ `2 w特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

5 D9 U+ u4 {) T  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
- W5 J8 t2 W' ?; P* R# Q! D' ~4 s
30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：

0 _7 S8 s. h6 U( v/ e; l

1. /*
   # Z7 ?  ?% B: n1 E6 r2 u3 u  Q0 h: @0 T3 c
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
     I* E0 `2 h, z0 I
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   , N- e) x: L8 W: }( K( E
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   . q/ d+ P1 E* J8 I* q; Q
7. *                          _usLen : 数据长度
   
8. *        返 回 值: 无
   2 k4 H5 T& M7 b, X
9. *********************************************************************************************************
   
10. */
    
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    6 A$ @8 b: d5 O. d7 ]) g
12. {
    
13.         UART_T *pUart;
      U4 T" W/ H! [' J/ `. K# W
14. 
    
15.         pUart = ComToUart(_ucPort);
    - V4 E4 `/ [+ `, m# ]1 y. }
16.         if (pUart == 0)
    7 L6 R* D3 ]7 [2 k* ?# p
17.         {
    # D8 d  [. _# R
18.                 return;
    
19.         }
    ; _" d. z' N$ P+ f+ ]
20. 
    
21.         if (pUart->SendBefor != 0)
    - E! e: z5 Z9 b7 q5 [
22.         {
    ) e6 u% L1 V3 Y# ?
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    ) {! @# z; M! d
24.         }
    3 W. g1 o0 F" q. [% z
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    
28. 
    
29. /*
    5 y: R5 n3 i! l  p1 R7 [5 B0 k
30. *********************************************************************************************************
    
31. *        函 数 名: comSendChar
    
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    ) I) k' Z2 a) F& D8 }7 d. K6 P
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
      i3 B3 [: u; A1 a7 @
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    " d6 H& p8 O1 r
36. *********************************************************************************************************
    7 L; a, u- v! ~5 u
37. */
    ! y3 S% _, {+ }
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    6 O3 h+ t% ]" n' C. P8 u
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    1 O6 ]( {& H+ m' K0 ~
42. /*
    ' d! _! U# g8 ^
43. *********************************************************************************************************
    ! d6 c) N3 |5 u1 F+ ?
44. *        函 数 名: UartSend
    
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    0 H0 A" z, R4 m9 D- z) U; _
46. *        形    参: 无
    ) L3 n  i- r4 r* w1 |
47. *        返 回 值: 无
    
48. *********************************************************************************************************
    & s8 v% o# \$ Y# L$ u. z; Z& m% k# c
49. */
    
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    9 J; d4 c+ O1 [5 I% e
51. {
    
52.         uint16_t i;
    
53. 
    
54.         for (i = 0; i < _usLen; i++)
    ( C/ l2 k& D% O4 k. S
55.         {
    6 W8 ~' _+ f1 H7 L, U
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    ' G8 O9 ]. {6 d" p# a! f2 q& E+ }$ B
57.                 while (1)
    
58.                 {
    
59.                         __IO uint16_t usCount;
    ' n0 V4 C- R- g* |8 ^( n
60. 
    
61.                         DISABLE_INT();
    " P+ |! Z2 A" E  Q" B* s
62.                         usCount = _pUart->usTxCount;
    ; n. W( \" Y7 A" V
63.                         ENABLE_INT();
    + P( B. W, I  X6 [* V
64. 
    $ Z. p+ G# |2 C8 `0 k5 |/ L3 T
65.                         if (usCount < _pUart->usTxBufSize)
    # u: g  p2 |% ^$ f  R! [4 C3 [
66.                         {
    
67.                                 break;
    
68.                         }
    - b4 K6 C! k8 Z: n; ^- M
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
70.                         {
    & }) b( W+ [2 g; [: P& ]: S
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    , `0 t5 O+ E. c0 `
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    2 X' k( [6 k+ a
74.                                 }  
    1 X, t$ P/ O8 A, |/ i. ^8 n3 S) l
75.                         }
    7 W3 n7 w/ j0 L" }7 C9 I
76.                 }
    7 F' L/ |4 w$ G6 R8 q2 i- p
77. 
      I' ]; E: u5 W6 I9 Q
78.                 /* 将新数据填入发送缓冲区 */
    
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    
80. 
    1 H0 ?8 ?; L+ t8 {0 f  H3 K3 m
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    & S( b& h7 T8 e8 f8 B* k5 N4 W$ i
83.                 {
    
84.                         _pUart->usTxWrite = 0;
    
85.                 }
    8 M! v. h. y. ]
86.                 _pUart->usTxCount++;
    
87.                 ENABLE_INT();
    ( k# M/ M1 E8 w& P
88.         }
    ! W, \8 |! q% h* N! r1 x' U% `( T
89. 
    
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

  b1 P' L$ J  i" y" N3 o函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。
! ~! a& H2 F* z! E/ b. k9 c
函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

. d( Q8 I, T% T# R, h2 F( g注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。
( n: r" G8 U+ j7 A5 f( S6 J+ k: T( o: {; _
函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

1. /*
   
2. *********************************************************************************************************
   & T' s% b0 y  W% j$ R3 i
3. *        函 数 名: ComToUart
   , }. F  V2 c) |
4. *        功能说明: 将COM端口号转换为UART指针
   / k1 s8 J) y1 Z3 h, f& Q5 b2 W. R+ O7 {
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   " b( \  @) t* `. d3 I, }: T
6. *        返 回 值: uart指针
   
7. *********************************************************************************************************
   6 U# b5 d3 u* g! \* w3 v# b
8. */
   5 _6 z) G2 X% s  o9 c, A0 A- k
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   ! R. O5 |7 C5 L$ `; _
10. {
    
11.         if (_ucPort == COM1)
    
12.         {
    ! P" c5 z8 Y4 p
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    
15.                 #else
    
16.                         return 0;
    
17.                 #endif
    * d7 \$ @5 e0 C8 v" `
18.         }
    
19.         else if (_ucPort == COM2)
    ( `  D" G  e+ ?3 j0 e! V9 X
20.         {
    7 R% l! `3 k' g  v: J
21.                 #if UART2_FIFO_EN == 1
      k/ O0 K1 L: ~- `$ l: z4 X% U
22.                         return &g_tUart2;
    * ]" b. ~3 D8 M% p0 k
23.                 #else
    
24.                         return 0;
    % `# w4 m: m5 J! V1 J# N
25.                 #endif
    
26.         }
    
27.         else if (_ucPort == COM3)
    
28.         {
    
29.                 #if UART3_FIFO_EN == 1
    9 L. G8 y( Y! v+ |' f
30.                         return &g_tUart3;
    
31.                 #else
    * J( i6 h* }" v! Q, O' H2 d9 n
32.                         return 0;
    + O( D. U3 j9 _
33.                 #endif
    2 Q% u! Z2 b. [4 D( J4 |1 m
34.         }
    
35.         else if (_ucPort == COM4)
    
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    
38.                         return &g_tUart4;
    
39.                 #else
    2 r: e; O+ @$ N$ K
40.                         return 0;
    
41.                 #endif
    6 T( K( X9 G; x1 O8 s. P
42.         }
    
43.         else if (_ucPort == COM5)
    
44.         {
    & ^# `( q8 U. ?. `1 I; K2 o4 R) W
45.                 #if UART5_FIFO_EN == 1
    $ j1 _/ d) Q( {4 J. H5 h0 \- r
46.                         return &g_tUart5;
    
47.                 #else
    ; ^" T* a8 F1 z) @5 Z( k" B$ h; {& [
48.                         return 0;
    6 I' [7 @6 R% o
49.                 #endif
    
50.         }
    
51.         else if (_ucPort == COM6)
    
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    
54.                         return &g_tUart6;
    * d# U4 s" t- h' P) H" c4 x/ H% f3 V8 R
55.                 #else
    ! n" x. E! s& V' [% P  P' a
56.                         return 0;
    7 x$ S# Q' Q* {
57.                 #endif
    
58.         }
    
59.         else if (_ucPort == COM7)
    
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    " x! c+ D) h2 K- z
62.                         return &g_tUart7;
    7 w3 Q8 E: M/ s  D7 ?$ c! z  i7 d
63.                 #else
    
64.                         return 0;
    
65.                 #endif
    3 m" z9 `- i; T# Y
66.         }
    
67.         else if (_ucPort == COM8)
    ) _( w* {1 k- u) [, `" L
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    - [+ H. @6 T3 g
70.                         return &g_tUart8;
    
71.                 #else
    
72.                         return 0;
    + F3 D* \9 }4 D3 d% T; O9 u
73.                 #endif
    - X% O! ]& L; D, T5 |5 [2 B2 Y3 y! f% J
74.         }        
    ; }7 ?) \# X& y2 x
75.         else
    . X0 |* Y8 V" c$ F+ U0 M0 J
76.         {
    2 b+ F0 j* s# F! J8 E  V
77.                 Error_Handler(__FILE__, __LINE__);
    ( p- b- |+ V9 _$ l8 v0 r# v
78.                 return 0;
    % y$ _) d7 z3 t8 ^" |4 A+ w8 S
79.         }
    3 b3 n: T% c& Y: Y
80. }

复制代码

& I1 F- B; b4 Y" R$ b. ?) R& ~6 d( @30.3.6 串口数据接收
: R" ?. A6 x/ c下面我们再来看看接收的函数：

) _1 \/ K: ]5 t

1. /*
   4 B1 g  g: S  w3 r+ D$ j# L4 l
2. *********************************************************************************************************
   
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   7 C: D( O, Y2 k8 k  f; O, m  ^8 J4 |
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
     T) \5 n2 ^+ O
6. *                          _pByte: 接收到的数据存放在这个地址
   ' a# `. v: x5 \2 m" {0 I8 s/ F6 k
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   6 N  {4 s% N8 {( x% w: O/ v
9. */
   7 X6 ^. O+ N$ p( `1 ?7 @7 `2 R
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    3 w# y7 y  Y- o* u, b
12.         UART_T *pUart;
    
13. 
    / D# r6 ~- {6 w& A: v2 R4 U- M* Z9 i
14.         pUart = ComToUart(_ucPort);
    5 E8 a8 T6 q, s& g
15.         if (pUart == 0)
    7 i3 X9 |* w- Y: q& l
16.         {
    
17.                 return 0;
    
18.         }
    ' s1 T  b7 Z% l7 z' f) |0 h
19. 
    + L; c) H, b7 K5 U' J
20.         return UartGetChar(pUart, _pByte);
    
21. }
    
22. 
    
23. /*
    & c) G2 k0 K1 r, {+ d
24. *********************************************************************************************************
    / ]8 [6 w* |7 V& g- G  q$ F$ u( ?
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    % Q- M; H- l5 n& S1 [
30. *********************************************************************************************************
    8 Q/ X. S. r3 ~4 c: M
31. */
    ; w9 \. P% O; z' f  H/ V3 y
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    
33. {
    4 h( I) N! u8 ?; n4 e% z" B
34.         uint16_t usCount;
    " B- v  B; L9 X$ K0 K8 R& }. @$ D2 }
35. 
    
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.         DISABLE_INT();
      V5 \! E; H% s; m# O
38.         usCount = _pUart->usRxCount;
    ; P* n5 H) ~1 b
39.         ENABLE_INT();
    
40. 
    / s! [- L8 A. p; q% V
41.         /* 如果读和写索引相同，则返回0 */
    0 F/ L% l: z' T' N' `7 V0 k: E8 E3 `3 z
42.         //if (_pUart->usRxRead == usRxWrite)
    , Q4 B. o  a/ v8 V4 r3 F# N
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    
45.                 return 0;
    ) @3 p# O( m1 M5 c' }1 s, _
46.         }
    
47.         else
    ' X5 q  S" E8 h! o+ Y' G
48.         {
    4 p1 Z1 n7 L* }  b
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    
50. 
    
51.                 /* 改写FIFO读索引 */
    . K- j4 p- z! p% Q  r+ C
52.                 DISABLE_INT();
    
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    1 ?/ p+ x  V# f0 e$ D" C. ]
54.                 {
    
55.                         _pUart->usRxRead = 0;
    
56.                 }
    9 q' b& D0 V0 |/ D- ~
57.                 _pUart->usRxCount--;
    * s! ?$ F" z1 P  X  C
58.                 ENABLE_INT();
    * [7 U# ?# d4 o' `( f( d1 q0 L
59.                 return 1;
    
60.         }
    # {' q4 e  U% p* e; O5 J: @& Q' j
61. }

复制代码

6 s3 ~) y- P# d! [8 C( _! Z函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
- W) C2 m: p& O  |2 P, z' ~
, u) r/ e7 w$ _% O, _注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。
# E" ]6 K/ d8 J, a; H8 v" [; V
30.3.7 串口printf实现
1 Y' T7 h& q5 ]* Y, Xprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
; W8 o6 F8 }) ]  |; D% A
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。

实现printf输出到串口，只需要在工程中添加两个函数：
; w: C) y/ N. I  K0 S
3 z7 I; N& U, b$ e4 J5 M

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: fputc
   ' e8 E4 d% K) x
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   6 n9 Y2 {/ j+ y' R1 P! F
7. *********************************************************************************************************
   + k. |9 p0 D, [* i
8. */
   : W3 k6 m; B5 |) D! t, l
9. int fputc(int ch, FILE *f)
   
10. {
    
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.         comSendChar(COM1, ch);
    4 m4 Y2 M8 X4 G4 x
13.         
    
14.         return ch;
    * ~/ a1 M$ ^9 F5 }. i" B$ [
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    
18.         
    
19.         /* 等待发送结束 */
    1 M8 Y5 y5 K/ W
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    - F' L, f' }' N$ |
21.         {}
    ) A( m* [/ A2 b& T
22.         
    
23.         return ch;
    3 R( }1 J; L0 g  Q0 [+ w
24. #endif
    " @2 i; l6 w6 Q7 Y$ M/ u$ O
25. }
    3 N. z7 k3 f  a7 I9 i/ n) a, W5 b
26. 
    . C6 o: x0 h; w! Z, @1 ?9 C5 e: h
27. /*
    
28. *********************************************************************************************************
    4 r: x; j$ [& m
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    6 d# a4 ^, W8 h- y: `
32. *        返 回 值: 无
    . Z' p% O6 b+ D( ]% d
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    9 c9 x9 F9 {* V6 B- b$ J+ }6 m# a( G; A
39.         uint8_t ucData;
    8 P' `: a& h* j" b
40. 
    # \; y8 v, Y2 M* U" ~
41.         while(comGetChar(COM1, &ucData) == 0);
    # j* y  b  a8 C. w( t( F# I
42. 
    1 I( k7 f2 \  a: |4 a% _7 Q
43.         return ucData;
    
44. #else
    ! b7 G0 c5 j, d0 K
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    
48. 
    # D; }/ h3 G8 O4 C
49.         return (int)USART1->RDR;
    
50. #endif
    0 S; ?0 G! m( [5 ?
51. }

复制代码

" i0 m1 x# F% yprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
5 [/ @* Z/ q; N
9 t! X6 T8 p; V0 x' l" X/ M30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
. \$ [  C2 g* a, Q串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：
5 V; ]/ e. [' Y- g3 @; {  a5 ^
  bsp_InitUart
  comSendBuf
- e, o+ A0 _" U1 ^2 L  comSendChar
  comGetChar
30.4.1 函数bsp_InitUart
函数原型：
) \! L# ^9 `8 z% _/ Jvoid bsp_InitUart(void)

3 P" C8 |& F, _5 Q, w' z; S1 p函数描述：
此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
  |& l6 ]4 v$ J4 J- d% o/ Q. o2 e
使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
  S% O* `  [  w+ R( y1 }" U3 u
30.4.2 函数comSendBuf
' m9 v1 A; A: @函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

9 N/ ~, S, x4 q4 B
3 H0 e. W. u3 t2 v  w9 X, x" ~( g函数描述：
0 v6 o" @) d* G" {5 G此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
1 p$ _! h! F% y5 W% Z( @# R
/ ]3 @# Z% Y  z' R2 V函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
4 a. y7 B1 F6 W% p3 `0 u3 S  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。

) `3 ]  d' l9 k7 m/ I
注意事项：
  此函数的解读在本章30.3.5小节。
6 u; {$ `4 X9 n  m+ y* q  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。

/ g. O7 [" B! }& v3 b$ J
0 a3 G; A5 Z) H: T  a& W$ Q/ k4 }) W使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

const char buf1[] = "接收到串口命令1\r\n";
2 i5 f$ m! i. Y3 I3 l" T$ ecomSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));


30.4.3 函数comSendChar
- V$ y5 R9 K. ^  w  L4 C" |4 c函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);

8 E; [1 t4 M1 W2 w" r  x
函数描述：

, ]% v7 X8 T- ]4 f此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
8 f0 j3 s' t  q1 ~  W' h- X$ d
  _! t+ Q  a" a, n0 a! k9 F函数参数：
( [$ j+ e0 |/ L3 B4 s# V; f% t5 F  第1个参数_ucPort是端口号，范围COM1 - COM8。
3 L1 g' b$ d; ~( L& e8 J# G: C4 B  第2个参数_ucByte是待发送的数据。
. P6 f5 E* d9 P7 _

注意事项：
. p5 _' ^7 h3 R% H/ \  此函数的解读在本章30.3.2小节。


+ E3 E1 e2 g$ w9 c使用举例：
# `& ]4 {8 e& T; u" v, z* J调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。

/ N# L( k$ Q* k30.4.4 函数comGetChar
, m% C+ j1 {0 c  O函数原型：
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)


函数描述：
; w$ j( o/ J" B* [3 U9 T8 j此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
/ h% ^- T) h0 N$ K& {% K( }

5 {( H/ D: c) b* [* Z  I& B9 T7 b注意事项：
$ {$ `! q8 n- P: I" l( |  此函数的解读在本章30.3.6小节。


8 f: @+ K# M$ u使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
( e0 B" \8 ?3 a! i
. C8 C: s5 S( u& w1 Z比如从串口1读取一个字符就是：comGetChar(COM1, &read)。
- g- Y6 P4 x1 |% T: e
30.5 串口FIFO驱动移植和使用
5 z4 B- {. K8 p2 X6 X1 j( z串口FIFO移植步骤如下：

  G& j( a$ V: a" b1 k, j, S9 a' {7 f  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
, [. L0 l; F) G; p$ ^- n

1. #define        UART1_FIFO_EN        1
   
2. #define        UART2_FIFO_EN        0
   
3. #define        UART3_FIFO_EN        0
   
4. #define        UART4_FIFO_EN        0
   8 X  g# m0 w) }. m/ E5 ^
5. #define        UART5_FIFO_EN        0
   ! I" c. o. {+ ]/ O
6. #define        UART6_FIFO_EN        0
   ! ]  T4 u3 d8 ~) q( Q7 a
7. #define        UART7_FIFO_EN        0
   
8. #define        UART8_FIFO_EN        0
   9 E3 S5 T4 q$ t; N' R1 @
9. 
   # N% k% r% r& U- O. [
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    3 \# B2 n1 h' F. E
11. #if UART1_FIFO_EN == 1
    $ V7 Z: {9 f- G" @5 Y" h
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    
14.         #define UART1_RX_BUF_SIZE        1*1024
    / w! ]! S0 B6 O0 E
15. #endif
    
16. 
    ! J2 E5 T9 C" p2 X
17. #if UART2_FIFO_EN == 1
    ) r# b1 B7 `2 I( S1 W: K
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    
22. 
    ( T5 q& {; T7 h% ~7 \
23. #if UART3_FIFO_EN == 1
    
24.         #define UART3_BAUD                        9600
    # f8 h- N. j6 F% p9 o# u# c5 d
25.         #define UART3_TX_BUF_SIZE        1*1024
    ! |6 M- y  t! @# M0 O  z6 s# C
26.         #define UART3_RX_BUF_SIZE        1*1024
    4 K/ ^  I5 W/ ^
27. #endif
    % {/ T+ A2 F8 P0 h$ F- j/ n1 i
28. 
    6 l, ]- O+ {* ?0 ?. X5 g& O
29. #if UART4_FIFO_EN == 1
    % ~3 v* g/ t2 n; u( ~, y
30.         #define UART4_BAUD                        115200
    ) }9 B9 \$ Y# z* S6 V
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    , V1 i& c, z3 I) F4 x
33. #endif
    - T+ p6 L- j6 R0 j/ n! j
34. 
    - `: o" o3 G# z3 D: i: A8 V
35. #if UART5_FIFO_EN == 1
    # p7 E6 Z) F- R5 \
36.         #define UART5_BAUD                        115200
    
37.         #define UART5_TX_BUF_SIZE        1*1024
    
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    
40. 
    
41. #if UART6_FIFO_EN == 1
    + p. D% n" n/ I
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    2 u% g4 i& T1 z, d! w) Y
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    
46. 
    8 S4 ~6 w1 g& @. l, e
47. #if UART7_FIFO_EN == 1
    ! o0 C' [  }1 x
48.         #define UART7_BAUD                        115200
    % O- L; y  C1 o8 ^, c
49.         #define UART7_TX_BUF_SIZE        1*1024
    
50.         #define UART7_RX_BUF_SIZE        1*1024
    
51. #endif
    ! H) m: l# D8 E2 d* ?3 \- m
52. 
    8 c$ \0 t& Z* j" W! c$ b% H0 M) y: R
53. #if UART8_FIFO_EN == 1
    $ W5 ]1 N; ], p$ u' P3 H' `
54.         #define UART8_BAUD                        115200
    ; P9 N3 D+ i5 @  I
55.         #define UART8_TX_BUF_SIZE        1*1024
    , V3 n: w6 O# F3 G* Q
56.         #define UART8_RX_BUF_SIZE        1*1024
      [/ h+ r) w6 M$ j% \" z; X
57. #endif
    

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
, D9 E8 U# R5 F+ J; D. t1 J  第4步，应用方法看本章节配套例子即可。

$ J, |3 T6 h/ g! F( V9 F  d6 y0 U5 ]30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
0 ^. R9 q: j% }% F# t
  w. Q9 m. \4 t6 _" r

  第1阶段，上电启动阶段：
8 _8 M" M$ h$ t* I- n3 c% ?: j
这部分在第14章进行了详细说明。
. ~0 P* G1 h  P  第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
% c% I9 E' ?$ {" t, \) U  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。
* F4 @7 {- l  g9 n6 F5 u* H
30.7 实验例程说明（MDK）
* I+ B/ `) ~* z2 ?9 a配套例子：
" {  k. ~2 K. @6 j2 g1 E+ K1 C
V7-015_串口和PC机通信（驱动支持8串口FIFO）
( G& c. ~# W6 W3 n7 ^+ y
实验目的：
学习串口与PC通信。
* y/ t5 V' g- M8 g

# c3 \9 x; t; l实验内容：
0 b& y" t0 J& W. [' F& u启动一个自动重装软件定时器，每100ms翻转一次LED2。
' C6 X: v2 ]3 q- C

实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
7 P3 z: b& \# S3 ~串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
7 I6 V+ H. \0 @" j0 F7 H' \" f  d! B串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
3 G/ H! t  v  M1 T  R/ g0 j串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
5 o% ?& P, i) Z3 A3 R2 \: t, [+ o上电后串口打印的信息：

0 z9 N* y/ |3 m9 a波特率 115200，数据位 8，奇偶校验位无，停止位 1

# |3 f  y6 X0 R( g- t7 _1 v程序设计：

% X" v) a& }- T  |  系统栈大小分配：
+ y  Z8 C% O4 H( i* d
9 ^  d4 Y1 ?$ G5 W4 l0 C

  RAM空间用的DTCM：

# B  c" v( X5 N/ @& W) ~1 M  硬件外设初始化
; _4 c, j9 o- u2 w& ~  S
+ f/ d7 R" P9 c" q0 m: t3 {- n( `* i硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   " t) x" F0 l( W9 p) f) m
2. *********************************************************************************************************
   * G% y# F$ q* h5 F0 m* z- I' ^3 X
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   * @( e3 v8 y8 D& t- q. p8 Q* v
5. *        形    参：无
   7 o, P0 p1 K9 G. W# q8 w# q
6. *        返 回 值: 无
   5 r! U6 M2 G1 |/ Y7 A( C. A
7. *********************************************************************************************************
   % i6 V9 |5 m  a- V8 w. ?) ~9 C
8. */
   - B+ I- p9 l# R! y" |2 O" \
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    : i7 H; `4 w3 }9 W/ o2 ^% Z
13.         
    3 L' |' y! L" R3 T# B* K9 G1 t
14.         /* 使能L1 Cache */
    : j" x0 j, H0 m4 X' O
15.         CPU_CACHE_Enable();
    1 X5 ~9 G$ g* p# y$ k. b, N& o
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    8 y, V5 E2 [7 \% i/ \$ ~3 N
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
      o$ Q. `& h; m$ u- w% b% {& v
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    * |2 d3 D  Y# m+ B
25.        配置系统时钟到400MHz
    $ C6 b( t8 m6 E( J! [+ X
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ( v4 y. |3 j( U. N" Q. y
28.     */
    6 O6 B/ r' M* I+ o6 C
29.         SystemClock_Config();
    , P3 K% I+ v% ^- b" _3 e* h& P
30. 
    
31.         /*
    . f4 t5 t8 t$ q* g2 \
32.            Event Recorder：
    3 M5 m! L4 P9 o% z  q' [3 I
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ) L: X5 P" T" }  @; G1 N0 [
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ( \4 R+ L# \7 j! Q1 x# \2 e* `$ W
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    3 Z/ }3 i, P4 `: |: x, o
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    3 E2 R. Z1 s2 a. Z0 [3 Q7 L, d
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    7 u- r8 _, J4 {/ t' C
46.         bsp_InitLed();            /* 初始化LED */        
    0 K' W  b% a: ?- x$ [
47. }

复制代码

" q% F# ]" u! W* f/ Q: Y2 m: j, Y! x  MPU配置和Cache配置：

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

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   9 m/ H# {# U( C0 p) ~
4. *        功能说明: 配置MPU
   9 b6 S4 e5 L" U. |  M
5. *        形    参: 无
   5 ~7 i# n9 R) C& |
6. *        返 回 值: 无
   ; a# G* V- W( ~) a6 f
7. *********************************************************************************************************
   , V4 w, N- ]3 h: q3 u# T3 e# H
8. */
   
9. static void MPU_Config( void )
   
10. {
    ! g  [" ?( a: p0 R! w
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ; [; J5 O" N3 t9 D1 p) k+ M
12. 
    4 K: ~7 j3 V5 y+ Q0 S  C) d: @
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    3 g( h: T0 t0 I0 ]( J( {
15. 
    + F0 u$ ?  N) @1 K7 f
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;
    - p; t% D2 Z0 ~0 _9 }( I) _
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    8 X8 j% E7 k' S1 ]
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    # w$ b& [% }. m9 k
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    + M1 U- E( e9 R9 h/ p, Y$ d% {4 m
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! |- S  z" |) _; n+ {
30.         
    5 A6 v' K9 a* s& {- K9 x
31.         
    : z; q  F1 I8 ?) f
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    . |9 X  ~0 `! y
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    + `" }6 h9 [, M$ B! D
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 K4 y  B  F  L+ i3 y1 z- O6 A
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % D# l6 E7 _( U' B- R
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 }4 J# X# V+ g& s' p
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ) L' r) m# y3 k7 R7 y9 q& K- F
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ( C* [$ R8 H; c
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    " i' Y* `  u3 {" Z! X. B* ^% Q6 W& W
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    ) h) Q( H0 R- Z: t9 {$ R7 z
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    2 m" x) L0 @  d' @6 Q4 p
50. 
    
51. /*
    / |) L4 i* t: J) |, Y0 R$ E, P1 S. u
52. *********************************************************************************************************
    1 B( F  W+ F; |9 J
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    9 r" A/ B5 P0 t8 B  ?! n3 c
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    3 M6 W  S( I  E4 r
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    7 Q, @% X  N3 S; Q$ v: }
65.         SCB_EnableDCache();
    
66. }

复制代码

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

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

1. /*
   . N5 b! @* l+ u& T3 p8 F
2. *********************************************************************************************************
   ; x) ~- V: U& ?7 y4 _  w) s
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   + x& y: `, v& L; h+ E/ w8 W4 Z
7. *        返 回 值: 无
   ! R+ x& p" L9 H$ h: B
8. *********************************************************************************************************
   + k0 s! C9 N8 b6 V( K2 _
9. */
   
10. void bsp_RunPer10ms(void)
    ' N" A9 D, r) H! U" H  R/ c
11. {
    
12.         bsp_KeyScan10ms();
    + H, G8 h. G: F( \0 b4 X
13. }

复制代码

  主功能：
' H! F" N+ e4 b6 }: |8 i
5 ?+ @2 k: r0 y) F# M, m+ Z  O主程序实现如下操作：
4 Q$ {+ p" n; T# \: v  c
: u9 Z7 C& G. ^  F/ n, E( O  启动一个自动重装软件定时器，每100ms翻转一次LED2。
: F" G5 g, w6 X/ S; T( C7 E  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  b- x# T  I: h. q2 U7 U  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
0 `: _. Z7 B- Q- G3 D$ D  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
0 _- y! U/ V  i, z/ q0 r: b; U2 T  K3按键按下，串口打印"按键K3按下"。

1. /*
   
2. *********************************************************************************************************
   ' }4 }4 o% l, y7 A
3. *        函 数 名: main
   " W; q" N# x; d) {. V& D7 m8 n4 ^
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   2 q. z9 G; H+ t6 h' f
6. *        返 回 值: 错误代码(无需处理)
   $ P+ m% y2 [( q* u* s! @
7. *********************************************************************************************************
   . u4 ?4 z: k  w
8. */
   " @  c0 |- @& [; n
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;        
    , c- F/ a' n9 L/ Q' I  L
12.         uint8_t read;
    / n; v3 j3 |- i- y6 l$ o
13.         const char buf1[] = "接收到串口命令1\r\n";
    
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    + \3 S0 J) [) `0 Q# h
17.         
    
18.         
    " X1 C2 S: z6 [/ Y7 z
19.         bsp_Init();                /* 硬件初始化 */
    3 g' |8 y( |" m  V  W( S2 \
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    - q7 y, }& m- V$ w5 N  P
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    ) }4 W# n# T  S
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    : m- W7 n2 [& A6 Z$ F
30.                 bsp_Idle();               
    & i/ X. J; l$ A1 G# K$ R5 h3 T
31.                
    5 a+ a2 J: W) c6 Y: ]
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    * }0 P. f6 z6 ^, p5 m$ F
35.                         /* 每隔100ms 进来一次 */
    8 f" B  ~6 ?" _( D. Y
36.                         /* 翻转LED2的状态 */
    # h4 V! m( p  `* \. k9 K9 u6 W
37.                         bsp_LedToggle(2);        
    
38.                 }
    ) ~6 h# m: x0 K0 Q+ \
39.                
    
40.                 /* 接收到的串口命令处理 */
    - f( Z/ q" _  g4 P# O- i& P
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    ( L/ V4 d0 w' k' h0 ?
43.                         switch (read)
    
44.                         {
    
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    ' S( ^' a1 P# h+ w
48. 
    
49.                                 case '2':
    % H/ S! c4 d& O# c, Q  g7 v
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    # V: P4 r0 {5 x7 u+ D) ^6 c+ F
51.                                         break;
    
52. 
    
53.                                 case '3':
    ' x. S9 @1 ~! R4 F! j. P. N; D
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    
56. 
    
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    
60.                                 
    . Q  P, A" ?; P( x3 v& s: n
61.                                 default:
    7 H# [: x0 X" h1 c; Z- O! Y3 @
62.                                         break;
    
63.                         }
    
64.                 }
    8 U1 ^$ o" A2 U' Y
65.                
    
66.                 /* 处理按键事件 */
    ' m7 b6 [0 X2 H
67.                 ucKeyCode = bsp_GetKey();
    2 U$ T' |7 N! Q6 y0 j$ n# c$ `* j3 \
68.                 if (ucKeyCode > 0)
    7 q/ |7 y5 D% h2 V4 N- v% l
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    
72.                         {
    9 ]- A4 l8 X- p3 [: O
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    / B, S' j; f7 O" ^, q: i/ D0 F9 p' ?
75.                                         bsp_LedToggle(1);        
    6 I: N# U6 U! P% b
76.                                         break;               
    
77.                                 
    & V% ^' a$ t% b9 D
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    ( J" B& R# k, M9 L3 _  e5 W6 f* T4 ^
80.                                         bsp_LedToggle(3);                                       
    % t) [# x, \8 u1 F' S* g% X# E/ t/ h
81.                                         break;
    5 u3 }1 J+ r3 y
82. 
    1 ^9 \: x9 \$ n. ]) f
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    0 {2 v( y1 v8 p- u* p/ X: v
87.                                 
    
88.                                 default:
      ], r& |" R1 M! o( F
89.                                         break;
    7 p% K' l4 ]$ [# P
90.                         }
    
91.                 }
    
92.         }
    
93. }

复制代码

30.8 实验例程说明（IAR）
9 H8 S! e" l% b$ k& v! a0 Z4 Z配套例子：

' h2 s& e7 p2 M& G7 l' _0 r; ZV7-015_串口和PC机通信（驱动支持8串口FIFO）

实验目的：
9 o) s' y' I" x/ e9 x$ V% ]学习串口与PC通信。
/ f/ q! c9 E( b( f7 Y
, V7 |, l7 s- G& B2 N# E1 L
实验内容：
" v5 J; a3 A8 x+ O- ?, Z' u启动一个自动重装软件定时器，每100ms翻转一次LED2。
$ P* Y5 _) s$ N9 B  E, i
0 R% O8 H5 x  z9 v; |) @
! p- e  {7 x: i3 G0 a" \/ q1 u2 _实验操作：
; f$ p- Y& F! `0 B8 N串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
6 ]1 E; m+ c! h* \7 _: j2 O. s$ I串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
2 P8 v( b, R$ G8 Q& h% X串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
8 z; j- |, f  k8 ?' \串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
# A; A' z9 F& f+ B; O1 _" O" ^K2按键按下，串口打印"按键K2按下"。
9 [# a, p6 L" {+ E' GK3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

* q5 f+ V9 P; e1 h

$ g2 t" v& q# z程序设计：

   系统栈大小分配：

   RAM空间用的DTCM：

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

* r% h: H9 e. P

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

复制代码

  MPU配置和Cache配置：

6 d+ U/ X5 S( a2 o数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
! m) m) w( `  z5 m

1. /*
   
2. *********************************************************************************************************
   ; |9 e9 q2 m: E2 i0 w- O- c
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   # C* K8 \. r$ X; x7 ]# ^
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ' D( R9 G3 U% u1 s- j$ m7 c
8. */
   , i9 W2 Q0 T0 [$ x( Y" I/ U5 G
9. static void MPU_Config( void )
   7 x# q) @7 R: F- _* e
10. {
    $ Y% |# x: ?( b" e
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    ! Z+ p8 F9 ?. A# P* a
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    ! l* ~% D  b) ?" P$ z
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ! l* @6 f( u! {7 H1 J& _: [* Q" p
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;
    / I# C# h7 v& d$ V5 T7 H) u
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    2 F$ r9 r* [; }5 D; p
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    9 M3 O) D6 d4 V* s" D
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    " d0 V. f3 u, C0 }! T1 T  N" U; d
28. 
    ; w- g2 d( D/ L; y$ L4 z# b' m
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    ; [: Q4 T: T) U4 F! W  D3 N2 t
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    $ K- N2 U. ]0 p
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    7 _, Q4 {! o( k/ ^
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    2 {# ^& e3 P7 B8 }2 }7 t9 A
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    # L$ G. i/ P; @) ^& L8 Q! o2 j
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;
    ; ]2 }$ h3 y. K- v
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    ; M9 B  X% L$ @* p! {$ p
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    2 f, F- \+ D# _/ {# z# h
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 s1 p% t! X5 z; `! J# Z
46. 
    
47.         /*使能 MPU */
    + m+ E5 q5 H) V: z/ @! H' v
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    1 N* f% F9 M) d8 [9 H1 j7 W' E
49. }
    
50. 
    ' ?9 o! T3 c- N2 L: n& b0 ?3 c$ U
51. /*
    3 {+ q+ S3 X4 O" r, b2 f$ K
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    2 ]- u, i" f  p
54. *        功能说明: 使能L1 Cache
    . a) U, D+ Q5 p# E; N# H2 t/ t$ }
55. *        形    参: 无
    - q. W$ e: k2 q
56. *        返 回 值: 无
      J6 d7 D. i. ^" p) J
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    , W4 t5 ^/ `/ L% S0 k
60. {
    5 n0 z1 H+ u5 W) n7 l; _0 y
61.         /* 使能 I-Cache */
    . u8 I. V: b% d( _  b2 e1 @
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    5 z) H4 @# i' V9 m
66. }
    
67.   每10ms调用一次蜂鸣器处理：
    8 m& ]7 C, s) w
68. 
    * w  w9 p6 J! X% D1 ?1 x
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    
70. 
    . Q1 ~( f8 ?$ M$ Z% _1 w( ]
71. /*
    
72. *********************************************************************************************************
    9 o8 I# l: s! t. b
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
      q/ e& N& k7 w. V0 V9 ]  V; X
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    " D9 l# c: P  |5 s- j5 D" O# F
79. */
    0 A5 I7 f) ?( S8 D6 o: N  Z0 Q
80. void bsp_RunPer10ms(void)
    . X- C# x9 Q  `
81. {
    : p* L6 Y  F- F  P! I  ?3 p
82.         bsp_KeyScan10ms();
    
83. }

复制代码

: O. D% g- K. q9 o- d  主功能：

主程序实现如下操作：
1 v% j' U( G9 u$ j; m$ H( k
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
# z5 J# ~2 O7 T% @' @! p  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
+ f: x: D1 Z$ {) _% m( Q  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
: v* C! Z& e; H& u8 r, q% v

1. /*
   7 k2 n5 ~+ u6 Q" e, M
2. *********************************************************************************************************
   7 }, U! \8 ^3 S$ }: {; N7 ]
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   ; l0 f/ \/ `6 n4 G# h
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ; w, m7 c! t, ^* W
8. */
   
9. int main(void)
   & X# m) E0 Q+ n( ^; @3 p
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    $ i% `( w' W/ V: c; m
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    . Z8 W2 _9 @$ t+ N4 @
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
      Y4 v  p0 t" ^) Y1 Q
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    # k8 R% S' J0 |# Q: l$ ^
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    
28.         {
    1 x& e( k6 ?& S) j4 L& c' E
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    ! t7 f, x5 I5 m6 `
31.                
    
32.                 /* 判断定时器超时时间 */
    9 J( |; S; a" \) a& s7 ~/ d
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    9 |( r/ U+ }7 ~6 T+ @- W
35.                         /* 每隔100ms 进来一次 */
    + C0 r& l# g7 A+ ]  q! S
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    8 O) E) l# ~# c* ~) M, @" @
38.                 }
    
39.                
    # b: ^- P7 [6 R
40.                 /* 接收到的串口命令处理 */
    ; z3 |: b5 q" j) D, f, }* q; d
41.                 if (comGetChar(COM1, &read))
    5 D5 n* V( r% J$ C
42.                 {
    8 R1 A+ y+ a6 l" Z% V2 j
43.                         switch (read)
    
44.                         {
    0 |, D& I% T+ p
45.                                 case '1':
    " W' J1 |6 `6 |8 d# x/ D
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    + a+ h" q. K' E" u) N1 G8 {) ^
47.                                         break;
    * S9 H. J3 F8 M3 o/ E
48. 
    * |8 L7 F. d" t" T+ U
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    * T& X7 F7 ?6 R- h- {: h
52. 
    
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    / c$ b$ I% q' y. s8 G
55.                                         break;
    0 x! a- ]/ a3 ~" o6 h
56. 
    0 a, p  F9 R7 O) Z6 b$ ?( X
57.                                 case '4':
    1 L; n; U% j3 _% c
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    ' I' @& |8 y4 u* y
60.                                 
    . s) o) f% j* C* W
61.                                 default:
    5 P* z3 i9 Y) }  [$ m2 L
62.                                         break;
    - z& c- b$ @3 s" u0 x
63.                         }
    
64.                 }
    
65.                
    2 {# c7 T4 h1 _; b( b! V! i$ w
66.                 /* 处理按键事件 */
    9 ~; u; e3 q) h2 J; D6 Z
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    : G- \# j+ a( y8 Z# ^
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    : t9 H/ ~- C0 a% }
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    9 z+ F. D0 G" ~5 y3 @& b/ ]
76.                                         break;               
      I$ w( D7 f5 n* l3 _$ [1 @3 {
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    ) F' J( X2 \$ i
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    4 c3 g2 y5 Z$ G
81.                                         break;
    ! l! L* z7 a( F4 l2 R- |; Y; _% I
82. 
    / {( G- B) a% t* O7 B
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    4 R2 f' P0 e' u2 P7 i* X9 e
86.                                         break;                                
    2 y/ J7 ^/ h8 W" G1 {3 s- V
87.                                 
    0 A3 Q7 H4 s6 B2 {- ~
88.                                 default:
    
89.                                         break;
    
90.                         }
    ) w% K. g& @. l+ T, ~8 H: \: m
91.                 }
    1 C4 ~( E5 `  G
92.         }
    0 ]  w; K* P: {0 M4 Q9 r6 y; q+ g
93. }

复制代码

. i( O1 v4 }  k$ j3 b6 P" @30.9 总结
1 [( _  D9 _  s1 E) q本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。

5 s# w$ M" `5 C% d; Z9 |! s
" K( y8 {6 L+ I5 p& \

; T7 D: R6 e) X4 ^# {7 U8 e! q
, y' C0 H3 W: n/ T9 t