30.1 初学者重要提示
$ m4 b* Y- Q: s4 f6 y& g学习本章节前，务必优先学习第29章。
5 p6 q% `, U9 n4 K6 O, p1 g! k串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
4 x: d  c& \/ p" K8 _' C+ o' \CH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
# v2 P) M$ ?4 q30.2 硬件设计
! H( }9 R* x: KSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
  E% t+ p2 g$ |, h( ]0 z
  }. W/ f% w  |% s/ I- g串口USART1  TX = PA9，   RX = PA10

% P$ W% n0 x& Z' c6 \- x串口USART2  TX = PA2，   RX = PA3
% |3 V6 @. b; O4 e4 }0 |: \
串口USART3  TX = PB10，  RX = PB11
1 _: U8 P/ C2 X! v9 q: U  d
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

! j/ }5 W& x% c# ?6 v串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

串口USART6  TX = PG14，  RX = PC7

串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
% ~7 ?, u3 l9 s. R& Z+ P, N
串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
! c: s5 e7 z$ S: Y% e
STM32-V7开发板使用了4个串口设备。
5 f0 J# t/ G, V2 j
+ f6 p7 l5 m9 m: ^5 m' \串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
1 J. B- `5 A! p; J) p串口2用于GPS
# j" B  B; w! _5 ]3 m串口3用于RS485接口
串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
$ x& z9 Z) U2 H9 n8 q: y下面是RS232的原理图：

9 p7 M9 }$ p6 [2 h0 y7 R4 E

关于232的PHY芯片SP3232E要注意以下几个问题：
, h8 g  u1 C+ J; I! A+ E. t
SP3232E的作用是TTL电平转RS232电平。
; [8 M% m+ s! r* q' M' m$ C" {" r+ U电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
( q6 {5 P+ |; k; C' o/ K
) i  O) B6 W: [* e  y7 l7 Y

$ K1 r$ [7 [( o1 u" u
实际效果如下：

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

4 W5 S" Q. h6 B- {% P+ X2 t/ ^4 `由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。

30.3 串口FIFO驱动设计
9 P& K) \: \( U! a, z30.3.1 串口FIFO框架
为了方便大家理解，先来看下串口FIFO的实现框图：
& {" `& C9 N5 u; f7 y9 K) q

- C( P% {) W- p
第1阶段，初始化：

通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
( E) Q4 O+ Z$ e4 d# r( V第2阶段，串口中断服务程序：

接收中断是一直开启的。
: d- G, L/ j. W  Y5 T% X8 H做了发送空中断和发送完成中断的消息处理。
第3阶段，串口数据的收发：

  i2 U9 Z2 t) _3 B9 z; ^6 L, p. B串口发送函数会开启发送空中断。
串口接收中断接收到函数后，可以使用函数comGetChar获取数据。

30.3.2 串口FIFO之相关的变量定义
串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。
: k6 Q) S- w4 }2 t
9 [4 ]5 {' I& I" Q0 G) i7 i9 m每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
8 x5 D$ P: G1 c9 s+ ~! ~
我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。
2 V& ^$ A& P6 N3 f
% O( L: I$ v) S' `) C7 B

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   
2. #if UART1_FIFO_EN == 1
   * e3 o( J. g' K' r* U; |  o( o5 _
3. #define UART1_BAUD                        115200
   
4. #define UART1_TX_BUF_SIZE        1*1024
   
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   
9. typedef struct
   
10. {
    
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    5 H" b; u) q% i7 t4 p# {0 H" O
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    : D0 k& m4 o# z4 v
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    - p! Z, P; ~. i7 {, F+ c
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    , V, ?6 W( K1 J9 C/ `
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    $ ~1 A7 r2 F' I- W, \4 C; V( h5 g  n$ E! l6 K
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    
23. 
    
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    1 a& T5 E. {% _, D0 L+ X
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    
28. }UART_T;

复制代码

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

) P5 ^( V- D9 @$ i+ c5 |7 H$ r

1. /* 定义每个串口结构体变量 */
   1 W7 Z/ E5 L6 Z, ]) |) ]
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   / Z7 U% p2 R/ @' ]
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
     Q1 V( b, K$ d
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   $ `& I% Z$ T9 b! _: P
6. #endif

复制代码

& F5 z, `; a* y+ _2 J7 g$ z# w/ t+ a关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
5 [9 P1 K# Q* i* i3 ]
+ |6 ?* ~* R8 Z4 g1 w30.3.3 串口FIFO初始化
串口的初始化代码如下；
0 D$ A4 M/ l: T' c

1. /*
   
2. 
   
3. ---
   2 ^  v4 I5 p/ D
4. 
   
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   
7. * 形    参: 无
   
8. * 返 回 值: 无
   ! q+ _7 \( T9 I3 ]7 a
9. 
   
10. ---
    ! ~2 @' `7 Q$ x0 o3 k4 _$ b
11. 
    * g$ N( Y- K# x$ H
12. */
    8 ~# ^/ X: ]- s* H7 ~5 e
13. void bsp_InitUart(void)
    
14. {
    
15. 
    9 w  f+ v7 P* I3 c( @4 X' P4 G: t
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    2 [# E  l* v1 |' L
17. 
    6 T$ p, F& n0 q8 Q2 j
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
19. 
    
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    3 F0 t+ M; g- O1 }9 ?
21. }
    & m, b9 O2 y: I7 }, D

复制代码

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

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

1. /*
   
2. 
   2 l3 k. E- p( v( X+ p
3. ---
   
4. 
   
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   " j2 E. C- a2 t
7. * 形    参: 无
   
8. * 返 回 值: 无
   
9. 
   1 z3 s1 U0 b. r4 M/ z0 b  {8 |7 }
10. ---
    
11. 
    - h. K0 N6 U5 d, n* g. ?
12. */
    & A% W  r5 O; s( G/ e. R; N4 Q) O
13. static void UartVarInit(void)
    
14. {
    ( H. O( B2 `# w. {5 Q
15. #if UART1_FIFO_EN == 1
    + |: g, V+ }) h' [$ ?+ q# i8 W
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    * v4 G5 }2 N& g# r7 [
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    5 R1 w- ]% R9 s7 v2 e& ^
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    # s' J: b  _( K8 w- C3 W
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    . i: M* Z, _- G: S! f+ H
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    2 s* g/ N/ C8 |7 G
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    ! f# J4 D  P9 x+ m$ f9 P8 c: N
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    
31. #endif
    , T! H6 [/ K( P! j+ W0 k
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

函数InitHardUart
* w* Y# e$ r$ F# `6 g此函数主要用于串口的GPIO，中断和相关参数的配置。

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   ! ?* k) j8 t. n4 `/ D  i- y
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   ; T# r6 O; A/ {4 S( W6 T, }
3. 3.        
   ' h# c5 {4 \. M
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   ) L9 K( h4 [: D0 u4 W4 P
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   . \' T* q6 ]) O: l
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   ! n: k: g0 B9 T5 d, t2 O
8. 8.        
   0 {- t4 o8 C6 _, l2 d
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    ; w7 U+ \3 L0 I# E" S5 L: {9 S
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    5 z5 S6 V; ?5 C1 r
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    5 e- d9 S6 q! t! ^2 C4 S
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    2 H& U  P9 t0 k; ]; B
15. 15.        
    
16. 16.        /*
    6 s# e# \6 c( I# ~6 V% H; E3 x
17. 17.        ******************************************************************************************************
    / Z" P" p- F6 ^7 T* L' f$ _; {
18. 18.        *        函 数 名: InitHardUart
    % w8 L0 ~- r2 B2 Y- `% t
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    7 [! l1 V# n9 V
20. 20.        *              发板
    ; g: K6 {5 X3 H' K5 A0 O
21. 21.        *        形    参: 无
    ! f: v4 M$ L$ a2 V5 F3 |
22. 22.        *        返 回 值: 无
    
23. 23.        ******************************************************************************************************
    
24. 24.        */
    , {4 u) g3 t3 ~! x, O5 I
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    1 ^3 J7 p. k1 B' [. J5 k( b3 ]
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
29. 29.               
    & w" D- C9 k3 N. e1 i) L/ o% i1 ^' L! W  O
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
      V: j8 Y9 i& T/ I& |! h
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    4 r% ^3 F( U5 T) D5 L. r
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    + O9 [* z! G7 ~3 X+ v
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    
38. 38.        
    
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    . A1 B7 O3 C  Y( D# ]
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    ' h2 R" L0 p8 Q2 B  [% i; ~4 c
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    
44. 44.                /* 使能 USARTx 时钟 */
    5 H& S( w" k& N/ O
45. 45.                USART1_CLK_ENABLE();        
    3 |; P. ]7 w6 }+ i6 m6 Y
46. 46.        
    
47. 47.                /* 配置TX引脚 */
    " b8 {& D- o2 G; t: v
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    3 F+ |1 v- q2 \9 a$ f# f
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    & _0 D  o. F3 J
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    
54. 54.               
    6 x' g+ J+ Y, m2 H6 n
55. 55.                /* 配置RX引脚 */
    
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    / }3 e% B+ b) k5 Y  y' j2 g6 y
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    
59. 59.        
    0 ~$ {$ }& V2 s- n9 U$ d
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    + \8 j7 a6 A$ e0 }6 b0 C$ |
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    , P. V/ ~" a: B# A+ @% ]% m' `/ s
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    1 x) ]. K$ G, G' D, T
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    8 M' ]- t: C$ B/ Q( ~; o& c
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    # X0 f+ K% n) W! P, r; M
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    : F4 z& I6 W# @' t$ L* A
71. 71.        #endif
    ( O/ y& L2 l* e# x
72. 72.        /* 串口2-8的初始化省略未写 */
    
73. 73.        }

复制代码

6 Y' i& N" _, z: j! n0 F第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
0 z& ?+ |0 o- Q6 ^7 j# e) Y% ?第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
7 |& B% x3 D7 f- ^, T                                                                                                                                                
2 |( z7 |2 v0 n

1. /*
   
2. *********************************************************************************************************
   . I) g* r  j/ r
3. *        函 数 名: bsp_SetUartParam
   
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   
5. *        形    参: Instance   USART_TypeDef类型结构体
   8 H9 k" n1 H) x. r/ Q+ o- K/ G4 W
6. *             BaudRate   波特率
   ! J* Z! D9 P, O- @( P: f" F
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    / _$ T+ _4 C4 {! D
11. */
    1 ]9 M* i% ]5 `5 h
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    7 |  X# P1 W: m* d* C; F/ m
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    4 J  f# Y6 T/ e3 W2 h( F' @9 ~
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    * Y# |5 i# b2 A/ {- y! w
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
    % z, c4 j  d* Q, ]1 z
21.           - 校验    = 参数Parity
    2 c& O& n) {$ g% ]- K" N  n
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    + z) g' t  {3 Z
25.         UartHandle.Instance        = Instance;
    
26. 
    
27.         UartHandle.Init.BaudRate   = BaudRate;
    & l9 i; E! [9 p" y/ y
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    5 ?9 y; e' t0 S- j) B( T3 _5 s
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    " m6 S2 B4 z/ U4 ?+ S9 q+ y
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    5 u  C1 x7 ~# \0 x" n# i
32.         UartHandle.Init.Mode       = Mode;
    # D3 z7 Q6 ?* ], q4 x# t
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    # ~# ~  R. u* K3 f5 n
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    % Q2 _/ F6 ^4 S  {. R* t$ T
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    8 d+ W- P" R/ L& p: R0 F& d
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40.    
    
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    : d" n+ Y' `% F! ~% b$ Q+ m4 f" A: D
42.         {
    
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    
45. }

复制代码

函数RS485_InitTXE
! ?' o6 a8 f/ ^7 k  V7 M此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：

1. /*
   7 F) I, H2 T3 d
2. *********************************************************************************************************
   $ {2 ~+ f( g: ^% Z* [
3. *        函 数 名: RS485_InitTXE
   7 B' \4 s* u  G8 J2 U9 r) ^
4. *        功能说明: 配置RS485发送使能口线 TXE
   7 M. x( W! _: O0 `& E; v8 h
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void RS485_InitTXE(void)
   / _  x: C. I/ m  w2 x" o
10. {
    ; J9 P+ t' z9 [2 ?4 P4 e& w
11.         GPIO_InitTypeDef gpio_init;
    " p0 k( ]0 q3 P- d6 y4 t0 d* g
12.         
    & ]3 N& O( M' e7 }8 I8 z1 I
13.         /* 打开GPIO时钟 */
    / \: ~  r+ y+ e% A
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    . f5 f1 w6 |! v7 O# H( c' k
15.         
    
16.         /* 配置引脚为推挽输出 */
    
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    + F9 N& W" j: @0 H/ Y  [
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    - c9 E/ C2 N8 I& Y
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    6 e; b0 x1 d; U4 d$ S
22. }

复制代码

30.3.4 串口中断服务程序工作流程
串口中断服务程序是最核心的部分，主要实现如下三个功能
4 `' x8 a) Q% l! h7 B' U7 O
收到新的数据后，会将数据压入RX_FIFO。
检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

  Q5 H" {. Y+ j+ @9 p; B下面我们分析一下串口中断处理的完整过程。
- }9 P% |0 _0 E3 O& [+ S当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

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

& \1 \- `+ q2 u6 e* ~2 y, w  ?. G

1. #if UART1_FIFO_EN == 1
   
2. void USART1_IRQHandler(void)
   : N# q3 A. @, _0 m
3. {
   - ^9 i4 e) V* m" Z" P! E
4.         UartIRQ(&g_tUart1);
   
5. }
   
6. #endif
   2 z, K0 l5 [' {8 {  t, @5 o
7. 
   
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   2 Z7 e' _4 E# I; R
10. {
    " D' x, u1 g: f! Z. l2 L
11.         UartIRQ(&g_tUart2);
    
12. }
    
13. #endif
    5 U. B6 r. R) g; t# P* |% }
14. 
    $ j: g+ o7 q' W% [3 W
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    * f( ~$ v6 s* G4 R
17. {
    
18.         UartIRQ(&g_tUart3);
    / b( N( L  W- q. I! D2 O) H" D
19. }
    * G/ m: ~( A1 A8 I1 x  L( q
20. #endif
    
21. 
    2 u# a2 R" m) M4 f3 R
22. #if UART4_FIFO_EN == 1
    1 R. _$ V( k, y. C1 A9 h. I- C: x
23. void UART4_IRQHandler(void)
    # }4 z! w+ D! O8 N+ `
24. {
    
25.         UartIRQ(&g_tUart4);
    7 L9 ^2 w, L2 Z6 q9 ~
26. }
    2 ]6 R5 Y  x' A- k1 w7 `
27. #endif
    4 N  v% `) e! p$ h& `
28. 
    " u  ?. h' }7 ^8 P$ I% m. X
29. #if UART5_FIFO_EN == 1
    9 X! t1 |/ C8 f3 _! n& x% X4 B
30. void UART5_IRQHandler(void)
      d! P1 c1 Z( _; q5 {/ M' I  C
31. {
    % ]- f7 Q" c. b  f. \+ G/ G1 [
32.         UartIRQ(&g_tUart5);
    
33. }
    9 m! r( E% n- |/ v2 R4 Z
34. #endif
    
35. 
    9 |4 ]6 \3 b: R4 [: k
36. #if UART6_FIFO_EN == 1
    ) y! _$ j( R) x2 p1 F5 S7 ?. t( y
37. void USART6_IRQHandler(void)
    
38. {
    
39.         UartIRQ(&g_tUart6);
    
40. }
    9 l: f. q( b; a! Z
41. #endif
    
42. 
    
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    7 l. j# J! {8 t; e  K
45. {
    
46.         UartIRQ(&g_tUart7);
    6 c9 M/ h% f% y4 p4 R
47. }
    
48. #endif
    
49. 
    
50. #if UART8_FIFO_EN == 1
    
51. void UART8_IRQHandler(void)
    
52. {
    
53.         UartIRQ(&g_tUart8);
    
54. }
    
55. #endif

复制代码

大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。
, f. W/ C  P- v6 Y3 G6 g# U. v
下面，我们来看看UartIRQ函数的实现代码。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   & y" ^9 U( a8 r3 ]1 ^6 t; ?; i9 x, Y8 E
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    ) s  a1 J9 ]" I" Q' X# m6 s
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    ' f  E: p% o4 F2 e: s! ]0 M
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14.         
    $ M' I# k3 L6 _2 p* Y; _' O
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    / Q' V: Q( }, _& p$ l: s
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    
19.                 uint8_t ch;
    
20. 
    
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    9 B& k+ e: R% z+ y' l* o2 r
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    $ @" @2 ]* t8 V# C
24.                 {
    + j/ P# `( |& O8 {* f
25.                         _pUart->usRxWrite = 0;
    % L+ K# @  N+ a5 b
26.                 }
    / `5 \5 v+ p" Y( O4 f$ |! V
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.                 {
    6 a, u4 @2 B* x" n' ^$ z6 o
29.                         _pUart->usRxCount++;
    0 G& d  k6 y1 B) T
30.                 }
    
31. 
    
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    5 Y( s* h, g6 O: p" q
34.                 //if (_pUart->usRxCount == 1)
    9 R2 Z4 w& n! V/ Z4 _$ Q) N
35.                 {
    
36.                         if (_pUart->ReciveNew)
    ) u  K- c7 }  r# I* r$ T
37.                         {
    6 F0 E& V1 i* y! [, a
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    
40.                 }
    
41.         }
    
42. 
    
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    0 b% G% e, o' T8 F# V- o" _
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    , g* {3 }) R) J$ a& N$ Q! Y
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    " L& H* g6 _6 F) p
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    - ~) ^+ n3 Z0 {( y5 l: ?
52. 
    
53.                         /* 使能数据发送完毕中断 */
    9 k2 |% N; @- u
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    / {' {8 H  E. l. o3 B
56.                 }
    2 F- R8 J1 R: j2 {' _9 R
57.                 Else  /*　还有数据等待发送 */
    # E" ^" p. h" t* ~# ~
58.                 {
    
59.                         _pUart->Sending = 1;
    7 C  j) S5 K; S+ M8 Y0 X1 [) K
60.                         
    
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    5 ~; ]3 @3 ^; l* i' M
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    : a2 |5 l  z& L4 C
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    , r+ Q/ y" {2 O/ l* U
65.                         {
    . N6 l% l: L) D; D8 N. Y4 z* G/ B
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    
68.                         _pUart->usTxCount--;
    2 Z3 w: k+ E. k' l6 b* _: U
69.                 }
    
70. 
    / g4 `5 V2 h4 g; v+ y6 n4 |4 q
71.         }
    
72.         /* 数据bit位全部发送完毕的中断 */
    ' @5 d  s6 l1 a8 J# v* J
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    ( {2 T; E, \4 g2 d% U! t' Q
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    ' Y" W* o; B& ^2 Z- \6 S- U5 C
77.                 {
    
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    ' F7 H. A6 [, h5 N. i* h+ E* A
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.                         if (_pUart->SendOver)
    ' q+ k7 B, o* i* m. N5 `
84.                         {
    
85.                                 _pUart->SendOver();
    3 X8 i# y) I# F# Z7 g1 H! q
86.                         }
    ' Q3 g& k- s3 U6 p+ t
87.                         
    + k8 z: Q) y; u: S6 z( c) ]& A" v
88.                         _pUart->Sending = 0;
    $ n" T: J5 ^$ Y. L. `/ b  W
89.                 }
    # r$ r; a. S- ]
90.                 else
    $ q* ?& J5 k, |2 l2 @
91.                 {
    ' W8 n+ p6 P  u. T  i3 y
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    , q0 \* W$ W. Q) N, y
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
      r, E" }0 S- ?" u# p8 c
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    ; z* `6 |+ t% c$ u0 z! ]
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    " M! ~0 i7 }& O$ j$ h7 G% K, q* S+ r( o1 [
98.                         {
    & t8 X& E: j1 m
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     8 A8 t6 _" _( L+ Y8 ?: @8 ^! M
104.         
     
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     ! K1 f8 y3 _; a) j, }
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     5 K$ j' k" V: F! L7 [
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     - E8 }& ^* ?' Q9 X
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);
     5 Q9 r6 K+ E. E
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     ! |" p; M7 }  Y: p
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
! K- J% s* `. }  G) S* G
- [. ?" Q' c3 F  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
% I! b, M5 c$ B( ~
& A2 a' c$ H, ?# p6 R8 T  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。
% j  @9 O1 I. M# s: Y) e2 i
30.3.5 串口数据发送
( q3 U2 c% X, s3 e$ [% x串口数据的发送主要涉及到下面三个函数：

1. /*
   ; C$ O8 O) e& \. G$ f: n% g7 x
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   - y' W( k* u, j" P2 l
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   
7. *                          _usLen : 数据长度
   
8. *        返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    & r2 Q, r! _: t8 G- G9 P
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    
13.         UART_T *pUart;
    ' o# e6 g) U# B7 \* [8 F
14. 
    
15.         pUart = ComToUart(_ucPort);
    0 [* S! G9 h& Q+ V  e1 k) @( e+ k
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    * c0 W7 B8 d/ I9 B6 u
19.         }
    
20. 
    
21.         if (pUart->SendBefor != 0)
    7 K# u% l" [, e
22.         {
    
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    + F) i( j3 L7 @+ W5 D7 W: m/ }. ?) \
24.         }
    
25. 
    8 Z. E6 ?- }/ i$ y
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    2 U; Y8 `: P- X" U5 B; P& x
28. 
    ! y8 O2 O$ v8 n' i* I. m
29. /*
    + g. T4 u3 H' T' q/ Y$ ~5 i
30. *********************************************************************************************************
    , o) b: y3 e1 w' j7 F5 F  \" ^
31. *        函 数 名: comSendChar
    7 c- u+ @; ?6 g, p
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    ; N# s+ U; C& g% g8 o5 h* |% t
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    7 |" K. Q/ X0 d9 }, Q* |
36. *********************************************************************************************************
    
37. */
    1 w- I6 ]4 m# \* B% q3 n' V  X* B
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    # J3 K' ?4 g( e$ F: {" p
42. /*
    4 G2 M# \7 N/ W: ?
43. *********************************************************************************************************
    4 p/ a) F+ ~, h8 h
44. *        函 数 名: UartSend
    
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    8 k4 E3 o# C2 q8 k
47. *        返 回 值: 无
    
48. *********************************************************************************************************
    6 G- ?6 ^- e, g$ ]' v- h7 T
49. */
    7 `/ ?1 u2 M! c0 ]( u/ `
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
51. {
    
52.         uint16_t i;
    
53. 
    * L/ ~+ H, R* _" v% c
54.         for (i = 0; i < _usLen; i++)
    
55.         {
    
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    " n  c8 a! \! q
57.                 while (1)
    & B$ i' z. s/ ?: K
58.                 {
    % a  ?# Y9 h( M/ c) l7 A0 e
59.                         __IO uint16_t usCount;
    3 R/ \$ k6 p1 B; n( \5 {! M
60. 
      e2 k. V* r# y' y9 [
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    & s! h2 k* I- e7 G3 H: B
63.                         ENABLE_INT();
    
64. 
    
65.                         if (usCount < _pUart->usTxBufSize)
    $ E' S% j. a: Y
66.                         {
    6 Z) q8 N- u& }8 o0 J7 I8 K5 L$ J
67.                                 break;
    4 o& i- l( Q8 p5 f/ }
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
70.                         {
    
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
74.                                 }  
    
75.                         }
    ( `; `  Z+ K6 S
76.                 }
    - a" H. x8 c5 v, D
77. 
    - H4 W7 g, A* G! l* k/ G; n
78.                 /* 将新数据填入发送缓冲区 */
    " P9 {- k' j9 D# w! t2 \% R9 E
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    - h* u5 ~" j5 e( R+ z
80. 
    
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    
84.                         _pUart->usTxWrite = 0;
    4 K1 ]$ c& g/ D  e: }! I8 b
85.                 }
      R! G. Y+ m, M+ q: f+ @) o
86.                 _pUart->usTxCount++;
    
87.                 ENABLE_INT();
    . P3 Z  V5 e1 N6 C+ t- O5 ^
88.         }
    
89. 
    2 x) H8 ?% F% ~# F+ k5 K
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

' T2 z& e8 r# p2 J, j4 m7 U函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

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

/ c7 ~9 x5 s. ]4 w; D2 C# V注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。

" K' U1 M% I2 G! G! r函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

; B# a, N5 K5 y- U( ]  |

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: ComToUart
   
4. *        功能说明: 将COM端口号转换为UART指针
   # k3 \, U) Y' i' |$ g5 N7 i
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *        返 回 值: uart指针
   ; T7 k4 w% _0 j" e0 d; R
7. *********************************************************************************************************
   
8. */
   9 U# l3 F8 E- j
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   
10. {
    
11.         if (_ucPort == COM1)
    8 ?0 d4 F) [: p  F3 N
12.         {
    . M+ H4 q5 G* ]; T% }
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    
15.                 #else
    ) Q2 f$ D/ ]. k8 D: v" [0 L
16.                         return 0;
    8 k6 A$ E: }3 ?" S3 `. |
17.                 #endif
    # s6 l3 H% B0 u: z" s
18.         }
    
19.         else if (_ucPort == COM2)
    
20.         {
    $ B( z1 k' l1 K) r$ L# ~! ~
21.                 #if UART2_FIFO_EN == 1
    1 s+ T0 J9 L7 l" X, L
22.                         return &g_tUart2;
    3 M$ e* o- Q" [! V
23.                 #else
    + E/ O* T. o* e- V! w+ |; o" m0 [
24.                         return 0;
    
25.                 #endif
    4 ?2 l+ b8 l# P) ?6 D
26.         }
    ) d! y+ C' C" ~/ d% ]% X, O
27.         else if (_ucPort == COM3)
    * \4 E. l0 Q/ F& |
28.         {
    2 \( |# h: Z" `
29.                 #if UART3_FIFO_EN == 1
    
30.                         return &g_tUart3;
    & k% U8 z3 l: q* ]0 y5 p, I: C
31.                 #else
    
32.                         return 0;
    " I. F1 J! m" I: }
33.                 #endif
    ; H) E0 }, `% P$ x1 Z
34.         }
    & g9 I6 X& `- M# c: c8 a
35.         else if (_ucPort == COM4)
    0 d) }3 p( c9 t
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    
38.                         return &g_tUart4;
    
39.                 #else
    
40.                         return 0;
    ) R! p% W% l; ^. ~! o/ m& v" W
41.                 #endif
    % D4 j0 t$ c! G& ~2 [
42.         }
    & \$ h! E* Q! \2 E9 p
43.         else if (_ucPort == COM5)
    
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    . Q4 z" i! o1 n. L, s1 g+ P. z
46.                         return &g_tUart5;
    
47.                 #else
    6 E* S0 G! L$ W: r8 Y9 J+ v
48.                         return 0;
    4 i! N1 P# n9 D4 n4 w4 x) @8 D, T
49.                 #endif
    1 p4 l: N  _+ Q0 c& X' M, j" [' O9 q
50.         }
    - h; h3 _1 O& H
51.         else if (_ucPort == COM6)
    + Q% q# P; E  s0 N4 Q; L
52.         {
    & u+ b; E- n# r5 V
53.                 #if UART6_FIFO_EN == 1
    
54.                         return &g_tUart6;
    
55.                 #else
    ; `, y: b1 l& ^
56.                         return 0;
    ( j. b3 m7 C* ?4 S
57.                 #endif
    7 _7 R  w0 z/ d# K! `
58.         }
    ( k1 Q  a0 J. p9 P
59.         else if (_ucPort == COM7)
    9 {, G8 W3 x% v: d2 Q" |/ x) e6 `
60.         {
    + c4 e% z* k3 o" W
61.                 #if UART7_FIFO_EN == 1
    
62.                         return &g_tUart7;
    ; L+ _, `5 T9 q! q! G
63.                 #else
    0 k( d* X0 \' n& A8 \8 }" e) e
64.                         return 0;
    
65.                 #endif
    4 j$ C  M) {  s" L6 s* W
66.         }
    ; K  T( Y/ T% ^: @+ W) w
67.         else if (_ucPort == COM8)
    ( y1 z" T( U& J9 O1 G5 ]
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    " R. t( v7 A' p; _) d# E
70.                         return &g_tUart8;
    1 k* _4 }/ ?  e: b6 o
71.                 #else
    $ K7 l. I5 l5 Q' ^6 n3 P4 {
72.                         return 0;
    
73.                 #endif
    . a6 ~  c" }. f- k0 @7 G
74.         }        
    1 c8 [" T) h& \, f! @4 B
75.         else
    
76.         {
    / w2 f8 L) {+ p. m$ Q0 h6 R
77.                 Error_Handler(__FILE__, __LINE__);
    ' e( }& P1 b. u0 v% z8 q# y
78.                 return 0;
    ) V5 ?8 ]. X2 F+ i) C9 ~: A& _/ Z0 j, u
79.         }
    $ g* O' ^% v" \0 q( _, X8 z
80. }

复制代码

- ~) s( {0 B' E& V# h8 _30.3.6 串口数据接收
& J5 i2 C" N2 P$ E' C8 Y9 M3 ~- p下面我们再来看看接收的函数：
0 x3 @& ?7 F1 [' Q9 c" V/ b1 q, H

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _pByte: 接收到的数据存放在这个地址
   ' \/ J) z/ Q8 f
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   ( k, F3 }, Z, q
8. *********************************************************************************************************
   
9. */
   3 e! R* R# b! j  ^
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    7 e" `8 b5 Y, w
11. {
    1 l# {3 Z3 t1 U: K% I
12.         UART_T *pUart;
    # L; a; O% a4 I4 O. l
13. 
    
14.         pUart = ComToUart(_ucPort);
    
15.         if (pUart == 0)
    
16.         {
    - w! Y+ }- o* m+ M' e
17.                 return 0;
    
18.         }
    ' b: R% r# V+ I4 p; X4 t# Y1 i
19. 
    # V9 K& R% L. ~' s& D+ q( G
20.         return UartGetChar(pUart, _pByte);
    9 \/ ~# {1 c  B/ W* E
21. }
    : Q' }  G( I# T) F
22. 
    % ~6 I" i- r5 c1 i+ G6 I
23. /*
    
24. *********************************************************************************************************
    
25. *        函 数 名: UartGetChar
      p0 R# R9 ^8 F5 s6 |* j. E
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    ( a3 I" Y1 R& |( ^4 v! N; D
31. */
    / x8 \% h& i; b
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.         uint16_t usCount;
    / J8 T2 r# f, n2 e
35. 
    4 u/ y5 V. Y/ j' N
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    0 L6 p$ y; M" l; H0 _4 i
37.         DISABLE_INT();
    
38.         usCount = _pUart->usRxCount;
    + g- J  b9 X. C. D  s
39.         ENABLE_INT();
    
40. 
    
41.         /* 如果读和写索引相同，则返回0 */
    ; z! C$ B$ K% `: m, \" k" P$ \
42.         //if (_pUart->usRxRead == usRxWrite)
    
43.         if (usCount == 0)        /* 已经没有数据 */
    / k' H# s6 t7 T9 a  d1 G
44.         {
    
45.                 return 0;
    ' t& r8 Z7 \2 T7 n1 E( E/ ^' `
46.         }
    
47.         else
    
48.         {
    2 ^9 T' q+ z" h
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    
50. 
    
51.                 /* 改写FIFO读索引 */
      X0 H; f, B2 j$ H& y; K9 r$ B
52.                 DISABLE_INT();
    
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    0 ?8 N  p7 k8 U$ M
54.                 {
    
55.                         _pUart->usRxRead = 0;
    3 D% u; \; y! F) _( Z$ F
56.                 }
    ) X' n; L, K' A5 I& o4 S/ @
57.                 _pUart->usRxCount--;
    
58.                 ENABLE_INT();
    2 J8 a# \  w, J, i& u5 l- G
59.                 return 1;
    
60.         }
    
61. }

复制代码

; L0 D) q) Q- A5 i3 K7 v函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
' i# ~) c3 _$ y: j9 k: M. ]
注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。
4 L0 Z8 r; |. `2 }/ G
. e* U) |; J) b1 b* A* e30.3.7 串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。
- B# @7 b9 A5 g  ?% l
我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
. b1 H* b( D. g+ ~# n$ @- z  P0 g
' u% a0 |) z" T9 Q1 y实现printf输出到串口，只需要在工程中添加两个函数：

7 l  f3 C. N4 Z2 `9 i- G* w/ B

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   # C1 u  h- h! S; J: x9 Q
8. */
   
9. int fputc(int ch, FILE *f)
   , [; f. x/ l9 x3 ]. M
10. {
    
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    8 V; p+ X' @( u2 Q5 K5 E1 d* R
12.         comSendChar(COM1, ch);
    
13.         
    
14.         return ch;
    
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    0 C% t: d! n3 J; k0 z  W
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    
18.         
    ' e1 |5 V. {3 M- |2 B
19.         /* 等待发送结束 */
    1 M. @; `) S) p" J$ O9 J6 X
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    & ]" M9 F  ]) v" K2 X4 f0 n
21.         {}
    
22.         
    
23.         return ch;
    * y( }9 A  m9 ?' j' P% w: d
24. #endif
    6 h5 K" \. z+ A; c; R; K
25. }
    
26. 
    3 P( d9 K+ P% A) l& D' m" G) j+ ^
27. /*
    
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    ' I# W' |' y" E6 m
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    ) K- I2 K$ K" K: r3 s" Z
31. *        形    参: 无
    + B  a* t1 [$ y6 S
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    2 H8 U! J! N3 K4 c! S
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    0 o- s  {7 R" P% f5 O
39.         uint8_t ucData;
    & W- [1 O' m9 Y* D$ p
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    
42. 
    
43.         return ucData;
    
44. #else
    
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    
48. 
    ' s0 y/ f6 H9 L; }0 J  p# B9 Z
49.         return (int)USART1->RDR;
    
50. #endif
    1 |# l# k$ L/ T6 k9 C
51. }

复制代码

0 o3 [# u8 p. Tprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
3 k& ~, K" A3 o7 E
30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
" V0 i2 p) W9 h$ j) L串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：
, S, J1 S7 E+ o' a0 Z. Z# r' {- V. v
  bsp_InitUart
  comSendBuf
- H+ w7 O+ A& m' y% \, e2 O' \/ ?  comSendChar
  comGetChar
30.4.1 函数bsp_InitUart
$ l7 J' `: i3 u9 d函数原型：
void bsp_InitUart(void)

' U  g" [0 c  Q1 F函数描述：
, c6 h& |' p' w( S/ Y此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
( f  {* e" R) w1 i& N  s
  w  P! t( O. }' |+ Z5 v. m/ N* X使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

5 f& `4 B% u2 x: P& D30.4.2 函数comSendBuf
函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
& S$ C4 |3 Z$ E( n/ c9 p1 R
; e8 W1 |$ c3 g% S
函数描述：
6 g' v7 w* O9 _, ]& H# v$ D7 W此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

  X9 V) u: q: s1 B( N% I& `3 q函数参数：
3 B; H6 Y3 m. O4 h( W) Z  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。

  p. W1 Z3 q+ g0 `3 H. x- ^9 }
注意事项：
  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。

; S8 V, G) _% l
) }0 M  ~/ @3 L/ A, N使用举例：
: ?6 R! T& d% R调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

5 ~$ t1 W  a1 |$ u6 P+ iconst char buf1[] = "接收到串口命令1\r\n";
% K  S! l+ r& zcomSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
+ M; Z7 s! w, ?8 o
! l4 O$ e+ M: A$ L: n
9 ?) I3 V. g6 T30.4.3 函数comSendChar
) d0 p- I! p* @/ U$ C函数原型：
, E8 g/ U4 T0 n  c: D! K: ]0 Tvoid comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);
" {) I& x% G/ M% j" ?  R6 \( v
) v! y' N( T) Z, ~* f0 q( G! H
3 k5 W: j! ~/ y' Y5 F- {* l( k2 s2 W4 q函数描述：
3 d! ]/ U! E: o6 U6 r* G  I
此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucByte是待发送的数据。

1 w( P- _7 x, V$ P/ @! w
注意事项：
  此函数的解读在本章30.3.2小节。

( q" x* T- k- H) U+ _
$ C7 C/ h) N. v使用举例：
. ?# k$ c. z, o+ c调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。

  ^; M& n) t1 x: {30.4.4 函数comGetChar
. R8 X% V, A& C1 n- _" v2 h函数原型：
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
, T# ~. V+ ?7 M$ z: {
- |4 o" }2 U* b5 {) O3 Q  Y
函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

% ]# d0 x* [1 p; f1 K$ A7 b函数参数：
2 l1 L) ^0 F! X; j& t4 I  第1个参数_ucPort是端口号，范围COM1 - COM8。
" y: p* g2 j/ _' |+ p) T6 ~  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。

' x$ z9 g  E8 L  a9 I+ Q) C
注意事项：
" x; u9 h. C# g  此函数的解读在本章30.3.6小节。
' z- N4 t2 @% c
4 F# m- q5 s4 E- m1 e+ y( N( U  `
6 x4 B- p, P' w/ i) p, {使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
) i8 y. a8 a7 F6 O
比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

' V2 P" N/ C1 x/ L/ v- M30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：
' |, [8 s9 \- G1 }; J2 [4 N5 }, p7 b
  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
% V) h' [  x9 [4 h9 F' [

1. #define        UART1_FIFO_EN        1
   
2. #define        UART2_FIFO_EN        0
   
3. #define        UART3_FIFO_EN        0
   
4. #define        UART4_FIFO_EN        0
   * Y4 l  Q% W; G) ~! ]2 \
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   
7. #define        UART7_FIFO_EN        0
   ! q4 r1 X4 E5 s) F0 D
8. #define        UART8_FIFO_EN        0
   ' a5 H$ C+ \! \' d. F! q5 L
9. 
   
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    / d5 P! e; F' N& ?' ~  z: Z% h3 l
11. #if UART1_FIFO_EN == 1
    
12.         #define UART1_BAUD                        115200
    ( L6 P4 [% T0 [3 h
13.         #define UART1_TX_BUF_SIZE        1*1024
    # W& h0 {. Y: L# r& S
14.         #define UART1_RX_BUF_SIZE        1*1024
    7 {5 X( C' Y+ ]
15. #endif
    0 V. C0 p  E, M; ^" x/ O
16. 
    ! e0 N4 \$ t4 y. _* O6 `' {
17. #if UART2_FIFO_EN == 1
      U+ `4 J5 C; [. \) [- D6 p
18.         #define UART2_BAUD                        9600
    & a2 E6 y0 H' i% w
19.         #define UART2_TX_BUF_SIZE        10
    + U4 H6 W$ z0 e' z& ^
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    
22. 
    
23. #if UART3_FIFO_EN == 1
    % z" a( `' [- k- E3 k
24.         #define UART3_BAUD                        9600
    
25.         #define UART3_TX_BUF_SIZE        1*1024
    7 V) J: X4 ^7 Q8 f7 \& A* I
26.         #define UART3_RX_BUF_SIZE        1*1024
    
27. #endif
    
28. 
    
29. #if UART4_FIFO_EN == 1
    3 b4 \0 D+ c" j
30.         #define UART4_BAUD                        115200
    $ g  r: `7 V6 l
31.         #define UART4_TX_BUF_SIZE        1*1024
    " b, m! j2 r3 \7 _2 L9 ~- d: B
32.         #define UART4_RX_BUF_SIZE        1*1024
    
33. #endif
    9 m. m- u( S8 q+ O/ ?, t: e
34. 
    
35. #if UART5_FIFO_EN == 1
    - t/ Q2 l" {: y3 m9 U. q4 s1 `
36.         #define UART5_BAUD                        115200
    , n' p6 w  ~' X' T: J) s& ^
37.         #define UART5_TX_BUF_SIZE        1*1024
    ( l9 x5 _2 E+ c- D& ?% e( F' E
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    0 ^" b* E  c8 u( P0 G
40. 
    
41. #if UART6_FIFO_EN == 1
    
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    
46. 
    
47. #if UART7_FIFO_EN == 1
    
48.         #define UART7_BAUD                        115200
    
49.         #define UART7_TX_BUF_SIZE        1*1024
    
50.         #define UART7_RX_BUF_SIZE        1*1024
    
51. #endif
    
52. 
    * E& k1 M  Z) a! f$ b, Y
53. #if UART8_FIFO_EN == 1
    # F0 n- o! n- s5 k4 f- o
54.         #define UART8_BAUD                        115200
    . f& Y$ {0 k( r6 N: y
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    # f7 E  G5 R0 W4 X; g3 q
57. #endif
    

复制代码

1 r1 `* v8 U0 |: j6 w( k# r; l- |  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。

/ `: ]% [0 n7 q! \4 ^30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

2 m# u9 a7 F! @" E) f, r) v
  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
& C9 }2 ]4 u* R& h+ _  第2阶段，进入main函数：

, O- B% q5 D" j$ c  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
1 Q" b4 q8 x  i8 a  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。
3 z: R: R. g# h9 Z8 e1 V; Q+ o
30.7 实验例程说明（MDK）
配套例子：

V7-015_串口和PC机通信（驱动支持8串口FIFO）
; [" d$ l% p6 |' J2 u2 P/ u
7 l+ L. X' R5 `( }2 P实验目的：
学习串口与PC通信。

6 q6 b5 j* g9 n# K0 @9 H
实验内容：
8 k/ J/ n7 c4 p: H启动一个自动重装软件定时器，每100ms翻转一次LED2。
. |# S1 u( U1 J, d4 M

' F0 `% w$ Z$ |) K实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
- Q' b" y- f7 n9 y串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
+ |, s: f- z, I& F  S串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
' m2 q% ~# f& x% _! qK2按键按下，串口打印"按键K2按下"。
3 p9 Q! v7 _- j' l. [K3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：
. r  Y/ O* V7 X
. F3 W5 i2 y$ h3 x, I波特率 115200，数据位 8，奇偶校验位无，停止位 1

2 s+ E9 L6 E# [* P8 Z" x3 J
程序设计：
' _* x9 R% z2 C) G; b/ u
: R, x1 p; l) Y" j  系统栈大小分配：

3 ~$ T% i6 e: `' {, y, S0 b

5 n& D  Y, d. F( e. O0 c  RAM空间用的DTCM：

* K! a* q, k2 i6 t0 t

  硬件外设初始化

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

1. /*
   9 I+ S" l' Z% ?8 _# c! [
2. *********************************************************************************************************
   ! t1 R+ t9 p$ r' ~- X" H! q
3. *        函 数 名: bsp_Init
   ' S& Z( M$ G8 y
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   * [0 L0 g# {3 N( M) i
5. *        形    参：无
   
6. *        返 回 值: 无
   6 l) v. B- b$ s0 [, b
7. *********************************************************************************************************
   
8. */
     L: z! ]3 G9 W% i
9. void bsp_Init(void)
     {/ ^' A4 m. t; |2 b6 r3 I/ D
10. {
    8 [3 i; a/ R5 g) ~4 x% R
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    ! p/ F7 K3 s7 u( A' |0 \
15.         CPU_CACHE_Enable();
    
16. 
    ' n1 ?' ]) i4 t* R
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    # Q  l, \1 V6 s8 \) v
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    3 c1 |" A9 Q( b5 M; S/ P
23. 
    ! C) M8 H5 e4 ~; e/ R3 `
24.         /*
    
25.        配置系统时钟到400MHz
    + U: O* S5 H, c
26.        - 切换使用HSE。
    6 p. k0 b# R' I$ j' m5 Q0 m
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    3 D$ b! B7 h2 O$ F% _
29.         SystemClock_Config();
    ! b: S1 L/ U5 C  U9 o! D
30. 
    ; B, p% G" d$ J# @; d1 M9 O, w' }
31.         /*
    ( N% K3 I' ^0 p$ ~1 E
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    # L- g5 U$ j3 p; k8 l$ l' s
35.         */        
    8 H) a! q0 K! A1 T! J0 c$ ]
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

+ G" f1 Y$ A# C7 p: A" ]6 v  MPU配置和Cache配置：
8 k4 K- L/ D2 a0 M" `# Z; Q& j3 M
) o  ?+ T( E' ~数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
, L) D8 k2 R; Y1 P& i
8 A. L3 G5 R  h: h! `0 h% l7 h; K. E

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   ' F" B2 m5 g  v# g/ M7 O
7. *********************************************************************************************************
   $ ^$ V! [2 M- h+ Q9 g0 Z
8. */
   $ A( a$ s% l; u. b
9. static void MPU_Config( void )
   
10. {
      g/ l: j% Q2 A$ H
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    5 [( ]& z$ w  q
12. 
    
13.         /* 禁止 MPU */
    / h6 `7 V6 C" S. T
14.         HAL_MPU_Disable();
    $ p; m, _0 f- T& E$ b# P: q$ x+ f' S
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    8 t6 {6 n$ n: T, l4 ~6 d' M' f
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 k5 @2 Q- [6 I4 {! v+ L
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : ?, T. C0 `% F, l# G' v
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % ^, J! J: V4 G
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    3 Z2 \* I! |: }8 K, ^, f8 I
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    , j" R2 ]+ H% m. w
30.         
    6 B/ u4 n; Y7 X3 v) R+ z
31.         
    , R! v' |& P" \
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ! N- P$ b0 y: F# U% X8 R' Q/ v
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    5 i$ A1 h  ?- U- |- \! K% P- n8 I
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    , F$ i, W# Y+ A7 H4 H/ |" E0 x
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;        
    5 M6 y. J$ r; c; K0 J. O. q
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    1 q+ k; r4 R9 \. j% ^$ Y! |4 D
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : F, F9 E$ k) ^/ ?" Y2 N+ ^' l
44.         
    : o8 G; ], U. L% L
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    $ h$ J0 A7 }$ `+ {. P$ I, ^3 G
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    3 o% [2 y# l5 q9 g9 Y3 d
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    ! ~$ z$ F/ R: Q+ y, M" P' H
57. *********************************************************************************************************
    2 F( u& u5 i+ W; g) [4 b! g/ d% Z
58. */
    
59. static void CPU_CACHE_Enable(void)
    9 N( B6 D, P& u/ y' D
60. {
    ) P1 t) _+ u( j* D% ~. O. }2 P
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    : `( g- Y' X) X: R& g, L! ?
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

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

- I4 ^# G- y- D% D! S. j, p蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   , `% }5 V7 p& p- I- K) d8 a
2. *********************************************************************************************************
   2 G2 z3 c  ]. f9 r
3. *        函 数 名: bsp_RunPer10ms
   + ^- k# J+ ]: n' i# q) i
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   ' G2 J* P9 y$ T! R  s
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

主程序实现如下操作：

: `7 q+ y! I$ ]9 k  g  E* t  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
' A5 W4 S$ |8 m$ Y' z  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  Y; W* m5 a- u' \  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
# i; q$ ]! j+ o6 e  K2按键按下，串口打印"按键K2按下"。
2 O# x$ }$ K6 _3 M# _# j+ G  K3按键按下，串口打印"按键K3按下"。
' L( F- ~9 I; ?  s4 n: z# v

1. /*
   3 S  B0 D# L* r, Z2 K" A
2. *********************************************************************************************************
   
3. *        函 数 名: main
   ; k+ \+ b" Y; V
4. *        功能说明: c程序入口
   : i% Z% w, w0 \2 S
5. *        形    参: 无
   0 ~( ^9 }# ~5 B, a2 D. J! I+ B
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    9 L2 U+ U. i7 }; N2 F% R3 L
13.         const char buf1[] = "接收到串口命令1\r\n";
    1 {* |7 K7 t: l. j: w
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    2 m3 ^, Q9 I: c; t/ v
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    9 a& \0 c3 p8 N# Q! D1 s$ Z( Z9 V/ ?
20.         
    0 f) l2 r3 n# T, p
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    6 K( Z+ h6 F% o: N2 M2 L- {
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    % f0 X8 n: O; k
31.                
    
32.                 /* 判断定时器超时时间 */
    2 ~( K6 O7 h- \- K! m
33.                 if (bsp_CheckTimer(0))        
    ( I& g; E( v9 F* V& G1 f6 b
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    5 \9 f1 S: r9 P6 ]' s
36.                         /* 翻转LED2的状态 */
    7 Q6 A* j  m9 a, E- M/ r
37.                         bsp_LedToggle(2);        
    4 S+ w: p( n1 R3 X/ X6 r4 x
38.                 }
    $ a3 i+ |$ T5 J
39.                
    / I1 A7 }" h6 c" U
40.                 /* 接收到的串口命令处理 */
    ( l9 e- b7 d& i# l- R3 S8 O
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    ! q: O' N( ?, U, z5 f3 i
44.                         {
    
45.                                 case '1':
    % L* J3 L1 t& {$ p0 u) O
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
      ~5 j9 Z5 S  B+ |. }
47.                                         break;
    ) ]; }7 d. r: m$ V0 f) |
48. 
    
49.                                 case '2':
    + E. y2 D: P( V( p9 ?9 @
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    8 p1 m7 b* ]- ]1 q3 D! v1 V1 z
51.                                         break;
    - x0 k& @4 E/ J0 [) a+ g* @
52. 
    
53.                                 case '3':
    9 M. Z  }  ~$ w  |/ I3 Y" d
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    
56. 
    
57.                                 case '4':
    / l+ L" V9 S% |  E
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    5 ^2 }! U, D7 D2 Q7 l& p6 E+ v+ Y2 |1 I
59.                                         break;        
    
60.                                 
    
61.                                 default:
    ) |2 s/ @" J' O
62.                                         break;
    
63.                         }
    ; Q4 _8 l2 i$ z# C; e
64.                 }
      n- u; _. ^0 p
65.                
    
66.                 /* 处理按键事件 */
    % O; ?8 k8 t+ B  }. K, D1 k
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    ' i1 |# N1 p* r* M% ^
69.                 {
    
70.                         /* 有键按下 */
    ; j2 V4 ]/ n' U% B
71.                         switch (ucKeyCode)
    * z* c/ I, r& Q4 E9 K' S
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    9 `, O2 o1 Z. _' B3 L
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    # Q9 S# L5 n  o0 D7 I" D* e
76.                                         break;               
    4 H4 q  _7 C1 I) }: A5 x$ ]
77.                                 
    ( w; I, W# b; O: k
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    , F+ L( V8 H4 e2 Y/ o
84.                                         printf("按键K3按下\r\n");        
    2 k  ?. f3 q: B& ~
85.                                         bsp_LedToggle(4);        
    / ]9 e% E, r; v6 U- J# O; O
86.                                         break;                                
    
87.                                 
    
88.                                 default:
    / b. w4 b# v0 T' F
89.                                         break;
    , z- P) u9 F7 i
90.                         }
    
91.                 }
    
92.         }
    ; K$ [( T0 z, h- r' c
93. }

复制代码

30.8 实验例程说明（IAR）
7 O- l. A2 b+ @! G配套例子：
. Y6 F9 r  ~- @
V7-015_串口和PC机通信（驱动支持8串口FIFO）
' v4 Y9 x: y7 [
实验目的：
3 ~) t0 {: A) x  t; \学习串口与PC通信。
- D, k. \) `( t3 v  a+ w
1 r% q, A7 F1 N% ?2 T. d
, y5 C6 \7 w- J* u! R' ]实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。

+ q" Q" m4 Q$ X/ Q9 N
1 x1 y+ G6 E5 Z, ~实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
$ H6 V1 G6 {$ |, l串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
$ v0 `' I5 r. d  A串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
1 P6 g. {( V, v: }6 ZK1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
+ t# ~. A- K" M- WK3按键按下，串口打印"按键K3按下"。
8 r+ P$ H1 N- E& @& A0 n% C/ G' w上电后串口打印的信息：

. [) [) A( `# h4 Y波特率 115200，数据位 8，奇偶校验位无，停止位 1

8 k6 U4 j' |7 }6 W6 `# s( o, V$ I* p

0 `1 ^7 N1 s3 ]- @" t8 [. O
程序设计：
6 E" d) U0 L( c6 I6 Z
   系统栈大小分配：
5 ~. q8 k% ]6 h. A

   RAM空间用的DTCM：
1 h0 A, C: i2 b/ ~

1 O2 Z* }  z( j; I: q8 H
% }% [) G$ O& r7 h  k  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
. r, [$ f$ d# v2 D0 i$ U# m

1. /*
   0 z( b8 R. `7 e- Y3 ~' o2 d
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   5 i- m$ H* D* s0 p
8. */
   
9. void bsp_Init(void)
   ' V, s) b- D$ U6 n2 |% A8 l
10. {
    
11.     /* 配置MPU */
    , X8 C- v5 k1 O8 R5 L5 u
12.         MPU_Config();
    / P( M5 v  l# ?+ ~$ Q0 y
13.         
    
14.         /* 使能L1 Cache */
    1 ~4 b( f+ B4 J7 D
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    2 ]' M( v1 Y( g8 [  _
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    3 n  U  y" j0 X, y8 I6 i- L  R
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    / W2 G6 e4 [: R
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    * U# Z* E9 Q0 v$ J% J7 R& r( z' j
29.         SystemClock_Config();
    
30. 
    
31.         /*
    ( G6 i2 F6 L9 F, J# x+ v' [
32.            Event Recorder：
    4 Z! ^* H) Q! c9 B' S
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    % U' Z* b0 K1 e- i9 n7 Q
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    2 G/ a' C# S! F
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    8 r; B8 d; ~( H5 U
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ' w0 o/ d# x0 Z( w  p# r. z
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    ( @) d6 G. N  b2 N
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    0 Q8 b; O+ L7 S* A
47. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
5 v0 n1 K7 C5 K0 [8 e4 ?4 K8 A
! q7 T. J& d0 H( w4 O6 X5 ?* {

1. /*
   7 R, [6 }1 r: c* \+ k$ T0 I% \! p
2. *********************************************************************************************************
   * B$ ?. c2 {: Q% T/ i
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   0 s2 u; P# n- a9 X' Y) o
5. *        形    参: 无
   5 h2 x8 d# ^+ U# r8 Q( z2 H; {
6. *        返 回 值: 无
   + A3 A3 ~& @, t& c* S5 o# @
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    # `0 W+ R- y: z! \
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ( I* c8 F/ Q8 ~! Q" N
12. 
    / R9 ^) j! z8 i* C) D$ n
13.         /* 禁止 MPU */
    ' y9 Y6 Q- z6 R& b3 l. a$ z+ H
14.         HAL_MPU_Disable();
    " {( G( s. l6 ]4 X
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    - ?6 ~/ G$ ~3 }, X9 @6 K
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    7 s: q& Z4 `6 D3 s7 |) C& d" V, B: {
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 d$ S' E5 V; R* p
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    6 g9 u* q5 Q! R/ ]) P% Z
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ) H% H. O1 }: E( R4 C4 r9 x
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    % E! \$ [4 y. a8 u! E8 @3 P* Q5 A
28. 
    + S! N$ y! ~* e
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    / |$ l( w* p+ O
30.         
    8 r7 q0 d( @: E! ?4 R3 `
31.         
    
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;        
    + {# @% U& t9 Z. O5 @7 P' q
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ( s6 w* G0 D/ R
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    6 C$ K0 E* T7 |. s  c& e* q
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    4 {  p+ ?+ U* i* a& W) F; L3 y9 N
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    $ r6 l! r) W  Z3 d( r
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    - E7 V+ J' `1 e
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    7 L' j+ c+ [+ r6 X8 s
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    + p. y5 p$ V2 D# P0 b
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    6 e- w- y* i& M- ]0 x, g+ B
52. *********************************************************************************************************
    9 v( w. e2 s& }% J: B
53. *        函 数 名: CPU_CACHE_Enable
    4 g; W$ `. N6 {+ _$ n3 ]4 W" Y" ~
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    ' U7 U9 F( U: E8 w6 A, r
59. static void CPU_CACHE_Enable(void)
    
60. {
    5 |- t8 s' K( b: R
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    . D& K( i6 R1 G" X
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    5 w% Z( G' y( w6 _+ L
66. }
    + {$ ~' g# S( {: X. f
67.   每10ms调用一次蜂鸣器处理：
    0 Q/ f- B2 c6 K
68. 
    
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    
70. 
    # s1 q% ~1 C) P& u
71. /*
    
72. *********************************************************************************************************
    
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    . A: z7 r( k$ z* {
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    6 b  H$ }- l" q2 a: ^- T6 r
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    ) G* ]  ?2 m1 R6 T
79. */
    
80. void bsp_RunPer10ms(void)
    
81. {
    $ ^$ ~8 t- S. {7 ^' X
82.         bsp_KeyScan10ms();
    8 S% Y& s9 j+ R! i- g$ x- }: H% z' i3 O/ _/ w
83. }

复制代码

( ^  ^1 l6 s: Z& R  主功能：

5 _; ?! F- `. k2 T+ p% U8 I主程序实现如下操作：
, \6 o, m- q7 H4 I4 c1 M' D4 f5 H
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
) P( _  v% `8 i' D* u1 p& x5 a  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
6 K: p1 }. d: D, @: x  K1按键按下，串口打印"按键K1按下"。
  c& M7 [/ D$ e; o, y, _9 x0 ~  K2按键按下，串口打印"按键K2按下"。
) V' l# f* y1 {0 ?; N$ K- _  K3按键按下，串口打印"按键K3按下"。
3 P* M, o( K% ^, S2 J" O

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   9 P3 ?  R/ ?7 n3 t% ^3 P3 T7 I
4. *        功能说明: c程序入口
   5 V/ ]  w3 [& T2 C
5. *        形    参: 无
   / C  h) Y0 L, f# M( p2 |$ C: I
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   ' k4 A! g: ~7 k- S6 D, n
9. int main(void)
   
10. {
    , F8 V  ^6 h% H  R( t! q9 q
11.         uint8_t ucKeyCode;        
    % S/ K$ C- e/ A- Y
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    2 B5 ?( q2 A, U  H
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    8 h' Y; a5 w3 A& y; `7 _
17.         
    
18.         
    % c& v" e% e% d% }/ |6 H
19.         bsp_Init();                /* 硬件初始化 */
    ; E. H% P1 k; P4 i8 n! Y! h
20.         
    ' i6 O" `5 B. Z2 o
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    ) D$ k( I8 {5 G. U% A; F* @+ B9 f
23. 
    5 N4 |( w6 [5 x; F+ h0 Y
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    2 m  V, D9 K! u
25.         
    
26.         /* 主程序大循环 */
    ! [3 V! }9 t/ u$ E; o
27.         while (1)
    , `# Y' R- k+ P" _" H. ?
28.         {
    # b* C2 \6 }5 B: `
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    6 ~& g$ h5 X: b; P3 w6 l6 b( h
30.                 bsp_Idle();               
    4 _/ E) a* r1 H1 {0 z
31.                
    . h, D8 C- r/ \# v' g- I8 D
32.                 /* 判断定时器超时时间 */
    9 B5 i  B# p. z" M: c8 H, J
33.                 if (bsp_CheckTimer(0))        
    2 o; d7 F$ F8 ]- ]* W8 m
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    5 g& {" M2 X1 M* [  \
36.                         /* 翻转LED2的状态 */
    7 K+ k. }: v6 O
37.                         bsp_LedToggle(2);        
    ! f9 q! ~$ ?& d3 T3 L0 V- B1 h' V
38.                 }
    
39.                
    
40.                 /* 接收到的串口命令处理 */
    5 ]  S: p8 V  B0 S
41.                 if (comGetChar(COM1, &read))
    # h( b& q1 s* h4 k3 U) @
42.                 {
    
43.                         switch (read)
    2 C. x6 H: C3 b- H* g" Y
44.                         {
    / b0 ~4 Z# A* C9 D: }
45.                                 case '1':
    4 G- Y' Q  W( _* b6 h& h
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    * L6 x: D; f  a. t6 \5 t
47.                                         break;
    & O1 `! U, A( H3 w4 v2 A3 D
48. 
    
49.                                 case '2':
    ! A1 x# @" c  n6 |$ y4 n
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    + ?7 p, x: V" X. d
52. 
    % I% p! F' i, V, f" F! B3 |
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    ' c# A4 [- f4 i+ h. m+ o1 S
56. 
    
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    
60.                                 
    
61.                                 default:
    
62.                                         break;
    ! Z9 v. C: U0 R( K1 F( I
63.                         }
    , o( M- l1 _: |8 ~* f
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    5 ~4 k) S# i$ R8 e7 j
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    ; G4 u  m& i; X3 O$ D+ H2 h
72.                         {
    ; Z* K  @. u6 a/ r+ Q- ?
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    + s  o. E& \. g4 p0 l, x
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    . H4 ~. N) h( S8 w6 M! D4 X
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    5 b) S. i* U, |; N: e
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    # t- d' n9 Z$ }
82. 
    . @( J2 i' f$ {/ s: T( l7 `0 s8 h
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    * `! n  a3 F3 H1 N
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    
87.                                 
    
88.                                 default:
    
89.                                         break;
    
90.                         }
    6 b7 r8 V, A% {( ~6 R
91.                 }
    
92.         }
    , ?+ m, p1 |9 b: `
93. }

复制代码

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

- t* o: C* Y8 O% v6 J! K7 q
* ^" m8 _. k0 m* w/ q% B

6 T7 i- K& k# p3 R6 ?
5 a9 n/ F9 ~3 I' D                                                                                                                        
  j! B* P# F3 |/ B/ l4 U: s