30.1 初学者重要提示
( [% U6 K8 ^5 W, ]4 A/ H" K学习本章节前，务必优先学习第29章。
$ e1 V+ A2 [- ^串口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。
3 @- Y% U& [  \* h30.2 硬件设计
STM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
% H/ {# p, \! f7 X0 |8 }
1 d  _* |# }0 s; q4 @串口USART1  TX = PA9，   RX = PA10

串口USART2  TX = PA2，   RX = PA3

串口USART3  TX = PB10，  RX = PB11
# M* @$ P  ?; R- ?+ V/ g' w1 s; R8 a
串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

: P" Q, o5 x9 A1 A串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
0 `9 ^3 Q2 S+ Z' B% n
串口USART6  TX = PG14，  RX = PC7
( I, i5 F# h3 H
2 C# ^' U6 u' s) o5 {, B7 C串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

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

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

0 J7 f4 S+ W# w( Y串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
串口2用于GPS
串口3用于RS485接口
, k+ O0 o; O6 m- w0 R$ @: i' i串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
) i6 R- C1 B9 \: z, f; N8 h) \

. H2 h  ~& s: \4 K5 b
$ H7 \6 O; x( V/ M' i+ d) K1 s: p- r! Z关于232的PHY芯片SP3232E要注意以下几个问题：
  P" C8 c# m1 C- Z# m6 [
SP3232E的作用是TTL电平转RS232电平。
- ?2 L6 R, z& K/ s5 z电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

$ A1 ?7 p! i. n. N7 Q2 g' h9 j
实际效果如下：

/ ~4 C% x" |8 c% J; m

# S' t! i1 p, P( |
4 N& b! b; e2 t通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。

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

30.3 串口FIFO驱动设计
5 i+ C- e  \5 G) w" S# D: |+ n  p+ `30.3.1 串口FIFO框架
为了方便大家理解，先来看下串口FIFO的实现框图：
2 w' P' x* }2 E" c1 I4 C! t" T

第1阶段，初始化：
% o5 D: [* q/ P& h' a5 I% r( x
通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
" d" _4 H5 y, t' i# o" M1 c6 v; s第2阶段，串口中断服务程序：

接收中断是一直开启的。
7 D+ K& K7 @( A3 O5 c做了发送空中断和发送完成中断的消息处理。
4 n% E" M; H' x* ?8 H2 Q) X! q第3阶段，串口数据的收发：
  V% E: S5 {' v+ f' E
串口发送函数会开启发送空中断。
/ B$ {8 m& B  J+ D* ]0 D串口接收中断接收到函数后，可以使用函数comGetChar获取数据。

7 |( x) B' Z7 K( F* Y) Q30.3.2 串口FIFO之相关的变量定义
串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。
1 c# |3 s' L% i5 R- V
每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

# _9 N8 E, J: y4 I# o

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   . _8 {' Y4 G/ O( _
2. #if UART1_FIFO_EN == 1
   
3. #define UART1_BAUD                        115200
   
4. #define UART1_TX_BUF_SIZE        1*1024
   / n; g: K! D6 g6 R% D; N1 C$ x* f
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   
7. 
   : p8 N" ]9 a& i( V- k! n* a& X
8. /* 串口设备结构体 */
   " B8 [) ?# V5 X1 u$ k" N' q
9. typedef struct
   
10. {
    ' S% i: @/ }% ?6 e- F. r
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    1 p2 K& p0 }. y* _6 F6 M! ?7 M0 O
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    * y" {# d9 j5 W- G4 `1 y
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    9 G4 b$ v* J  |! @" h% s. b
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    & f* A7 V9 d3 M/ l8 Y' y, D
19. 
    
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    6 L! D4 g: s- E4 }
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    2 e* [+ u' c4 G. F  ^+ A& Z0 j1 J
23. 
    6 z: o# f: b/ }9 v
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    0 {& q# q/ u% b6 _
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    / D2 b/ X0 d4 e/ ~+ l4 G  F
27. uint8_t Sending;                        /* 正在发送中 */
    1 [- w9 _9 l1 i, l/ p/ K
28. }UART_T;

复制代码

$ L: \  g6 J4 m0 A0 fbsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。

1. /* 定义每个串口结构体变量 */
   
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   + h! G1 {, o  a8 r  e
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   
6. #endif

复制代码

关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
: G* k4 G" m5 i* G; g) z0 w6 K
30.3.3 串口FIFO初始化
" ?1 a; m$ z7 t* G( |# y. a/ v, m$ q串口的初始化代码如下；
. |) ^% d( i( \2 U) ]
# z  V7 I5 k" n5 j

1. /*
   5 t- s5 @* h& k0 X6 \, W
2. 
   ' j$ i- T* ], I3 J6 K
3. ---
   
4. 
   $ p) f; D. [; N3 [
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   5 \9 w% j1 V- \, ~0 |* x
7. * 形    参: 无
   7 E% D/ E# @3 s2 a' b0 r1 f; B* @
8. * 返 回 值: 无
   2 c, [% c0 v4 V4 e$ P) Q: ^
9. 
   ) ]( O1 L) _. ^. e, V
10. ---
    . n' v; H9 A% n, N) w1 T
11. 
    % k2 u" k: l( c0 s3 p2 i2 L( `
12. */
    
13. void bsp_InitUart(void)
    2 Q+ _6 n8 b; f+ x4 t( e' y4 G8 t% \
14. {
    ' q! }% E$ L3 n7 ]; w2 Z6 W
15. 
    ( h1 a5 M' R: a3 R
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
19. 
    . p! Y7 G8 P- E( [
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    0 T, F' a, e- B3 P/ j$ S* O
21. }
    

复制代码

, U4 t- ^, w8 e; }5 w下面将初始化代码实现的功能依次为大家做个说明。
8 {% r$ b2 X2 b2 K' \
函数UartVarInit
这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

: _" l% a$ A  V/ C( U

1. /*
   $ j- |3 ?: N& C4 z
2. 
   
3. ---
   ! Y- V1 k) d: |8 h/ s& H( y1 b
4. 
   . W4 x* N+ l) ]' r+ f, C6 p' R' q3 _
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   
7. * 形    参: 无
   0 J# ^3 t; G* n; M
8. * 返 回 值: 无
   
9. 
   
10. ---
    " J4 A& Z$ E% y) R' x
11. 
    " V. P# o" Z1 t, ?% u
12. */
    
13. static void UartVarInit(void)
    
14. {
    
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    ; W2 I4 _" r. h* Y- q* r
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    , C& ^# d  r# w6 E
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    2 E( [6 u# s6 {- L8 f6 x
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    " j( y7 T- d: k( M( M  V) J: R
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    # M* M6 r, J# J# l  K/ x
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    " o' |& o/ |% y7 j$ q$ g6 v) S
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    & k: v: q- N/ @3 L4 x  c9 @
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    , ?- U+ N! Y6 o! z8 v
31. #endif
    
32. /* 串口2-8的初始化省略未写 */
    4 W4 y: P$ T5 h) o# ~5 A
33. }

复制代码

函数InitHardUart
此函数主要用于串口的GPIO，中断和相关参数的配置。
; x0 J% v. X% r- Z: Q+ M

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   
3. 3.        
   ; U. ?. x' b1 j1 i% @+ K
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   3 \7 G& p( g8 x& f
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   8 A4 c, [9 I) J8 ^& q8 v5 l* a
8. 8.        
   
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   ' J. Z* w4 {& c" W$ L* j/ ]* x" f2 R
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    ! R7 P; H: c' u0 a$ c& }
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    
13. 13.        
    " e# k2 p. ], u
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    : F" ]- [* g( G2 m) U: x5 x, x
15. 15.        
    ' {3 s8 C: C# P; w  M7 b% y
16. 16.        /*
    - u# c0 z+ k' I2 n1 z
17. 17.        ******************************************************************************************************
    ! G& r! u1 w% w. D( }  C
18. 18.        *        函 数 名: InitHardUart
    2 ^& ]2 A+ ?0 u5 W9 E( L
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    
20. 20.        *              发板
    
21. 21.        *        形    参: 无
    & G& x) M" @2 }2 C/ G$ E* n& R$ g% X
22. 22.        *        返 回 值: 无
      y5 w$ w4 _5 F7 F8 a
23. 23.        ******************************************************************************************************
    - C7 M3 z, {( l' k- O1 e
24. 24.        */
    2 r" o6 h; E8 l& m$ m
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    % _- ~- i+ s" A% t( g) p
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
29. 29.               
    
30. 30.                /*
    ; {4 V9 Z6 C$ ?/ w. S( L! N
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    , z7 a- h% @# c9 B( s# }
38. 38.        
    
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    7 o$ f& f5 E) h. p9 H7 T
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    ( \8 v% ~, N% o
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    . c( K) S5 \' o5 J) M6 Y1 F/ T# y
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    : Z  p! R& k) r: X( A6 x
43. 43.               
    / a. l/ d  \9 U4 S0 r) s" r
44. 44.                /* 使能 USARTx 时钟 */
    
45. 45.                USART1_CLK_ENABLE();        
    7 x1 \+ U4 c- x* ^' J( M: j  j: `/ L
46. 46.        
    8 U& p, R* Q9 B3 D# l$ D
47. 47.                /* 配置TX引脚 */
    
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    $ |; x9 V' w9 r5 ~) x# T/ a
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    $ J" F) A) U: t- I3 c
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    1 D4 X: ^) \3 Q- ~) X! t- `
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;
    , D+ f  z; L$ A/ Z2 L% A
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    8 ?: Z' H" ?( O4 U0 y! l: D
59. 59.        
    3 l/ d- b/ W/ r6 `# y% M; @
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    8 q8 b$ t/ P/ r& A4 S& E1 l
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    % ?& {1 a0 D9 I) w2 W$ y$ k
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    # Q* B7 f. [) J2 Q6 O0 X
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    3 x  I, D# l5 h
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    + m; o1 h  G0 @# y2 K
71. 71.        #endif
    6 a( }* K, I' `* @. U" ~% M+ D
72. 72.        /* 串口2-8的初始化省略未写 */
    
73. 73.        }

复制代码

8 f2 ~: S2 l' q第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
/ m" r7 g, p! O" J# `& S第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
: r3 t: J2 p$ _( Y+ Y- r第65行，配置串口的基本参数，具体配置在函数里面有注释。
                                                                                                                                                
+ f# |3 w4 T% ^- [8 g  e; i

1. /*
   . x5 n7 ^2 x5 L9 a0 V+ m' |8 z
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_SetUartParam
   
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   1 E. ]+ K% \/ z
5. *        形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   " g- n, M0 d( S/ k
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   " X. q1 C0 J1 r0 Z4 L" P  s
10. *********************************************************************************************************
    
11. */
    : Y' |6 U4 i5 Z8 g7 C  n
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    ' Q6 W2 w0 U" f9 M8 m. r2 I+ l7 G1 P! u
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    3 m; ?: ?7 M, q
15.         
    0 p- e5 o/ g9 W5 K9 V/ I3 U2 g2 I
16.         /*##-1- 配置串口硬件参数 ######################################*/
      I9 N" [+ }2 ~
17.         /* 异步串口模式 (UART Mode) */
    + P# E1 N8 d4 y( N+ P3 c  m4 \
18.         /* 配置如下:
    9 T# {6 c5 @7 f4 e, u6 ]7 v
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
    
21.           - 校验    = 参数Parity
    
22.           - 波特率  = 参数BaudRate
    ( c# A0 B4 u! n$ J( D% N& d
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    2 S7 {; ?1 _. H+ S/ ~
25.         UartHandle.Instance        = Instance;
    
26. 
    8 w: S% v1 @8 s4 L3 h# L
27.         UartHandle.Init.BaudRate   = BaudRate;
    
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    % K9 k' t* ]% ?! X( h/ ^
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    ) w4 u' m. y' Z7 z, E% l, r
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    " x$ \% z+ |2 x) d, Q1 y( e
32.         UartHandle.Init.Mode       = Mode;
    
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    7 }4 T9 q7 e2 ^! G# f  K3 x$ _
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    " [0 w; Y, g% ]; Q3 }
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    / Q6 u& l2 V) Y
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    . Z* z7 K( `3 ~4 Y! u( O
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    % A/ \$ F4 E- S7 Q2 ?
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    & L- Y9 M! @1 S7 z% ]! T
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40.    
    , L! K3 J' c, M8 w
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    ! M9 W" y+ p1 b1 H0 ~; k- A
42.         {
    ( q5 b: ?. S- v/ d$ |" _; x+ x
43.                 Error_Handler(__FILE__, __LINE__);
    7 Z1 d6 v: Q. Q) t1 W% m& j
44.         }
    
45. }

复制代码

" `! R' k7 X' ^0 Q函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
6 m0 `- P& G1 B9 r/ p

1. /*
   
2. *********************************************************************************************************
   0 I6 t1 d7 Q& _+ W1 D: h$ F5 W
3. *        函 数 名: RS485_InitTXE
   0 g2 h: X' i7 _
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   # Y: K* m; i! i* E
6. *        返 回 值: 无
   2 s. G' b( D7 m: R3 S8 u& F& R
7. *********************************************************************************************************
   6 B- k9 Z" H* j
8. */
   
9. void RS485_InitTXE(void)
   ) K( A* n* m7 l. A- U8 v+ ^% @
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         
    & b: S$ _' c5 u
13.         /* 打开GPIO时钟 */
    
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    
15.         
    7 t+ I, O6 O# @3 m; S! h2 E- R3 J0 a
16.         /* 配置引脚为推挽输出 */
    . P. ?$ g" B1 V& Q6 ~5 X( c8 `  F5 e
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
      `8 C0 i$ d1 h1 v) T* d
20.         gpio_init.Pin = RS485_TXEN_PIN;
    2 y2 W) U: V0 _- ~+ Q9 r
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    
22. }

复制代码

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

# h* a  i3 b7 f7 d收到新的数据后，会将数据压入RX_FIFO。
5 X6 J% t( H9 x6 X检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
$ N9 f* ]' ?" }0 f7 N/ Z) Z如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

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

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

; ^2 r, u4 h' A  j' _0 c

1. #if UART1_FIFO_EN == 1
   / W6 N% D: Y/ Q  M) I: ~
2. void USART1_IRQHandler(void)
   
3. {
   
4.         UartIRQ(&g_tUart1);
   
5. }
   
6. #endif
   
7. 
   
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   
10. {
      u& `$ u. \/ Z% n: s
11.         UartIRQ(&g_tUart2);
    . C. }1 Z" f0 L1 b( _
12. }
    
13. #endif
    
14. 
    
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    
17. {
    & B' M! p% t6 ]- m! `
18.         UartIRQ(&g_tUart3);
    / t) O( b8 M' Z! \' X
19. }
    
20. #endif
    
21. 
    1 }! d  h$ h# `! ?9 m9 l' N
22. #if UART4_FIFO_EN == 1
    
23. void UART4_IRQHandler(void)
    
24. {
    , O7 w; K- c+ g4 g% |" }+ ~
25.         UartIRQ(&g_tUart4);
    
26. }
    + |6 n/ E( X7 g6 l2 f' k2 E: S! w
27. #endif
    " h& v4 X* x9 \1 Y" H* d; {
28. 
    ( q1 ~: Q1 Z( R8 k
29. #if UART5_FIFO_EN == 1
    
30. void UART5_IRQHandler(void)
      O. B9 @  ~2 x+ b
31. {
    
32.         UartIRQ(&g_tUart5);
    , e& w: A# ~2 O5 @" V2 u- x
33. }
      ~+ L0 S7 e( N' }# Y( W' v7 F1 Y- l
34. #endif
    0 S* J+ U9 I; m' \% A/ X8 U8 |
35. 
    
36. #if UART6_FIFO_EN == 1
    ) H5 W* y1 ?  Q5 Z4 Z
37. void USART6_IRQHandler(void)
    ; K$ {0 R$ w( G$ @
38. {
    
39.         UartIRQ(&g_tUart6);
    ; ~8 W# X; ^: C) y( |1 I1 i
40. }
    
41. #endif
    
42. 
    2 m  q' h+ h) Y" O" v5 U2 R& t
43. #if UART7_FIFO_EN == 1
    . Z: p- |% m3 T4 ]
44. void UART7_IRQHandler(void)
    / P% r3 Z1 {, g% J" L# q
45. {
    4 K$ ^4 R4 Q5 J% C9 \+ P
46.         UartIRQ(&g_tUart7);
    
47. }
    & T: P3 Z: z8 z* c( D
48. #endif
    
49. 
    
50. #if UART8_FIFO_EN == 1
    # \7 r9 z0 r$ r9 g& o, S
51. void UART8_IRQHandler(void)
    
52. {
    8 G$ o: x. y) f5 K4 S8 N( z3 v( A' e
53.         UartIRQ(&g_tUart8);
    & L, l% Q0 ]/ k; R) }. A! p
54. }
    
55. #endif

复制代码

大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。
0 w1 q' Y+ x0 |1 i  _- m3 B; @
下面，我们来看看UartIRQ函数的实现代码。
0 ~5 h! ^6 O9 X+ r- Q* r8 H/ a
' ?! `1 ?8 E- I# ^

1. /*
   1 T8 f+ H. u2 q8 M% \
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   1 ~1 \2 a& S# n0 G; d
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   4 G2 d2 L" f6 E, |# c
8. */
   5 w: V3 z/ o& Y1 O2 ?3 h; V
9. static void UartIRQ(UART_T *_pUart)
   + W+ V/ S: |" W8 y* V
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    1 R+ V0 O/ o- a0 p+ L4 E* c
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    8 j; V% Z1 o: B" U4 X
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    
14.         
    
15.         /* 处理接收中断  */
    % z* d) |2 D; W% }
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    # c4 K' A: P: Q) x7 m9 o
19.                 uint8_t ch;
    / Y. `9 _# W! y2 ?; |. |3 k$ T% [
20. 
    " }. b' v5 [0 E' \$ y6 Y. V) j
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    4 r# p; K8 Y1 n2 f4 Q6 [
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    0 O. _- A. E; C% p
28.                 {
    9 `5 L. E+ w2 D. V0 V! K/ [
29.                         _pUart->usRxCount++;
    
30.                 }
    " r! G' h4 e# a+ P7 K% N
31. 
    
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    0 S( j1 G" L0 W6 F2 G/ }) x9 j
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    
36.                         if (_pUart->ReciveNew)
    
37.                         {
    
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    ; x* U5 ]; ]; P
40.                 }
    
41.         }
    
42. 
    8 V" f. K4 ]" F& m8 Y4 C& R
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    3 C5 V; R! Z; }8 s# y/ Y' W1 O% s
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    3 ]8 Y  x3 p1 U' i
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    
53.                         /* 使能数据发送完毕中断 */
    
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    7 U5 x# e; |8 W# R% e9 L
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.                 }
    2 i* A) H* {0 e) P7 k, d
57.                 Else  /*　还有数据等待发送 */
    
58.                 {
    ; W- f5 N+ N+ m/ B9 o( E* O
59.                         _pUart->Sending = 1;
    5 |1 X* L/ v% g: m
60.                         
    
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    & ]# j, t9 F9 ~2 z% V: a3 w8 w* f
65.                         {
    ( H9 c& x* ~! L" e. `3 T7 t
66.                                 _pUart->usTxRead = 0;
    - J3 o3 f$ s$ k, }1 p: @5 `" W
67.                         }
    
68.                         _pUart->usTxCount--;
    : A: C8 F) [9 R) z
69.                 }
    5 L. a7 P( H1 p2 q! H& j
70. 
    
71.         }
    
72.         /* 数据bit位全部发送完毕的中断 */
    / n4 i( ]& ], F
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    7 g3 E) k3 w/ u1 D* d
74.         {
    ! M8 R. y2 ]7 ?! _, W
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    * Z0 t$ j8 Q# d
77.                 {
    " l% P1 h7 a! w
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    9 z; x7 s+ {) C& B* ~- r
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    * b) i, ~1 ~: x
81. 
    / D/ Q0 O3 _$ e( q- Y; z7 r
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    3 X# g/ h, G& `, C+ f. `
83.                         if (_pUart->SendOver)
    1 N) i, T( q( C* s1 b/ ^) |
84.                         {
    
85.                                 _pUart->SendOver();
    
86.                         }
    1 v& k- s! J3 M8 @( _1 O$ q
87.                         
    * W* k- E( I& i) C  w6 N
88.                         _pUart->Sending = 0;
    6 e- F& c/ ?0 w
89.                 }
    
90.                 else
    
91.                 {
    $ m4 q' g4 X1 e8 \" q/ |
92.                         /* 正常情况下，不会进入此分支 */
    3 A0 k6 }. \, j2 K
93. 
    9 U1 M& i: u& `% o$ I6 r  R
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    6 o& i4 x% b4 b" \* `( E, p
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.                         {
    & g# h; L! l. o4 U. [: G. s
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     7 s( y# q( I) D/ B4 ]! Q4 v. G& S
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     
104.         
     
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     9 V* ]( E, m2 L1 W" k+ d
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     & ]: d& E/ M/ M/ z. a6 p! P: m
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     % x' p/ @& {% N( O( B* e0 s
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     0 }# b3 r" A! L9 R2 _
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     & N& {( d# B* f7 w5 Z8 {
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     " E0 [2 O: [! o" }, T  ?9 z
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     9 e& b2 N6 o- C0 Y/ V' M  Q, ~
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     
117. }

复制代码

- u4 ?$ S: Y9 w# K0 v中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
' Z; `. o! W5 X% |1 q
! W+ @5 _) [0 Y3 s  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

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

2 J& ^+ U5 V! N! @) H9 X* p) b30.3.5 串口数据发送
7 L# t, s' ]8 `+ l4 j5 Y串口数据的发送主要涉及到下面三个函数：

1. /*
   4 Y( }( h1 y, |% o. e: ]
2. *********************************************************************************************************
     e  v; I/ y5 Z  h6 f( z1 W1 p- b
3. *        函 数 名: comSendBuf
   % ?9 a9 |# x! R% c$ w- r+ }
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   - {' ~) D+ v' o. c7 F) v
6. *                          _ucaBuf: 待发送的数据缓冲区
   - ~9 I! ?: T$ @: F
7. *                          _usLen : 数据长度
   0 n6 X/ ~: b' q
8. *        返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    1 y6 n% i7 r2 V2 h' L
12. {
    
13.         UART_T *pUart;
    
14. 
    
15.         pUart = ComToUart(_ucPort);
    4 n/ v$ r3 a, Q  q4 f
16.         if (pUart == 0)
    
17.         {
    ' B- p2 P. @$ v1 R- e* _$ f8 J# G
18.                 return;
    ) A9 x; y" B0 u3 z9 j0 g" B/ a
19.         }
    0 F2 G+ H9 B9 x; f7 M% \. ^
20. 
    - Q* N; p- U* z; k3 n7 c9 [; D' ^0 k; s0 \
21.         if (pUart->SendBefor != 0)
    
22.         {
    5 `: I* d8 m1 @+ k3 @1 J
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
      x8 b9 Y  D( Z1 Y, I; T8 s6 z& |- [
24.         }
    
25. 
    8 Y1 ]3 h. T: z( b! ]( }/ f( Z
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    
28. 
    , r9 p/ z- m5 q+ N# |1 `, [' p! X# a
29. /*
    2 o& `+ `7 n5 B- E# v
30. *********************************************************************************************************
    
31. *        函 数 名: comSendChar
    , q. |0 }, y# Z) l' N2 c% E
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    
34. *                          _ucByte: 待发送的数据
    ! T! E  Y) i& A' ^
35. *        返 回 值: 无
    
36. *********************************************************************************************************
    
37. */
    ) R& ~+ U1 w* L5 ~% D* f4 D: ]
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    0 U/ L1 E( F. ^" n" l) }3 s1 c9 [+ z
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    / [) w) c4 Z4 [2 C+ P
42. /*
    5 I4 Z: M/ p& B8 o. i/ N& b
43. *********************************************************************************************************
    
44. *        函 数 名: UartSend
    4 d- H; V/ k, f; h
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    9 B- y4 l, Y7 h1 Z# j
46. *        形    参: 无
    7 O; l4 T4 Y  ~! _* c$ n  i- ^
47. *        返 回 值: 无
    ) s! _4 g, n3 Q  V/ [
48. *********************************************************************************************************
    
49. */
    
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
51. {
    * y( e! Z4 |+ h  S3 I$ {
52.         uint16_t i;
    
53. 
    
54.         for (i = 0; i < _usLen; i++)
    
55.         {
    2 Q4 X' _! C; I9 F2 v. m
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    7 ]$ v. @. y3 L- R9 Q$ t
57.                 while (1)
    ( f0 y  J  T$ C5 o$ X# l
58.                 {
    
59.                         __IO uint16_t usCount;
    ! c: h5 r! H4 K; J3 |; w
60. 
    , m6 @8 O1 ]2 F  k( B* b( V
61.                         DISABLE_INT();
    , X9 W- {4 b" I, G
62.                         usCount = _pUart->usTxCount;
    
63.                         ENABLE_INT();
    
64. 
    3 Q6 S% _( P# m+ d
65.                         if (usCount < _pUart->usTxBufSize)
    3 J  N. t. \' a& [  _
66.                         {
    ! s0 \7 q! `# F/ k* R+ W
67.                                 break;
    + b& d( T9 Q: s4 P; ?* M# Y
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    
70.                         {
    & |  O# Y- O, E  k' ~& p1 P
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    & w* y- `% b+ u$ o5 k: O3 F
72.                                 {
    ; D7 U2 i( a! n* }( K& X
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
74.                                 }  
    
75.                         }
    
76.                 }
    
77. 
    8 \$ a$ V- d  j; e1 s3 Z# H1 v1 k4 I
78.                 /* 将新数据填入发送缓冲区 */
    ! Z- R. i. C! u' m8 ~8 J
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    2 o" W  T2 S8 P. [: Y+ u% ?
80. 
    - M/ j/ @# j$ g
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    3 C# z% j- t% F/ }6 T$ v) a: r% P2 D
84.                         _pUart->usTxWrite = 0;
    
85.                 }
    
86.                 _pUart->usTxCount++;
    
87.                 ENABLE_INT();
    . b& Y; {  z/ y7 e/ b5 E
88.         }
    
89. 
    
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。
9 r$ |) Y0 _, h- j
函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。
! S5 Z# V3 X! m% O  c; a
4 a! Z: V4 w; C3 |  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
9 n- D" I( f2 w  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
2 S  Q5 s/ c5 F4 d" N* Y
注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。

函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

1. /*
   
2. *********************************************************************************************************
   / O" r! r7 g7 t4 L; }5 g
3. *        函 数 名: ComToUart
   ! [2 B9 F% N) z. b& ^, w+ T
4. *        功能说明: 将COM端口号转换为UART指针
   3 `% P7 g3 R& s) f4 C* n" X
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *        返 回 值: uart指针
   
7. *********************************************************************************************************
   " Y& l, i8 {% K  l- k; B' l
8. */
   . M( o4 \& i2 u3 ]9 ^
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   
10. {
    $ ^1 e: c' I, Z9 N
11.         if (_ucPort == COM1)
    8 b2 d7 O/ L2 U; p
12.         {
    * g! C5 }# `; v- j
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    , E- E. Q3 }& Z  Z
15.                 #else
    
16.                         return 0;
    
17.                 #endif
    # B/ t8 `( E3 w- I* V
18.         }
    
19.         else if (_ucPort == COM2)
    
20.         {
    
21.                 #if UART2_FIFO_EN == 1
    ; W3 I7 @/ z1 ?! F& I
22.                         return &g_tUart2;
    , Z, N; f1 c, P& m$ P' A
23.                 #else
    
24.                         return 0;
    
25.                 #endif
    
26.         }
    
27.         else if (_ucPort == COM3)
    & `4 i4 l. E8 @( G
28.         {
    
29.                 #if UART3_FIFO_EN == 1
    
30.                         return &g_tUart3;
    
31.                 #else
    
32.                         return 0;
    / z% z7 ~: \6 N  m3 [! Y
33.                 #endif
    
34.         }
    
35.         else if (_ucPort == COM4)
    7 v" ?0 d" f' q3 M2 J* c
36.         {
    . D: _# l- L4 `/ d' K
37.                 #if UART4_FIFO_EN == 1
    
38.                         return &g_tUart4;
    ' j3 n* \% H8 S6 v  K3 g5 m1 N( X
39.                 #else
    ) R. x$ U) @0 Z- o
40.                         return 0;
    
41.                 #endif
    
42.         }
    4 X- u8 K$ c- y3 \& M% I
43.         else if (_ucPort == COM5)
    2 y% V/ c: ~7 {% k7 B) J* S$ m
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    " u2 M# Z7 S; v& j  u
46.                         return &g_tUart5;
    
47.                 #else
    
48.                         return 0;
    . |2 y1 _, g$ }& p; |2 W4 l% f! u) s# R
49.                 #endif
    & v9 _; `3 M: o3 J$ u
50.         }
    
51.         else if (_ucPort == COM6)
    
52.         {
    % ]- k* o+ W' n; Z
53.                 #if UART6_FIFO_EN == 1
    4 `( t4 V* K+ h& N! y, Y. C" B2 a
54.                         return &g_tUart6;
    
55.                 #else
    
56.                         return 0;
    
57.                 #endif
    $ B5 d$ `# T/ i1 x( o& W! Q1 ^
58.         }
    
59.         else if (_ucPort == COM7)
    
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    6 ]$ `( P1 P2 G3 |; w9 u7 p
62.                         return &g_tUart7;
    
63.                 #else
    
64.                         return 0;
    : y" ^2 n- e9 j+ `# @# I. Q
65.                 #endif
    * X; X# y# T4 d* h, p# l
66.         }
    
67.         else if (_ucPort == COM8)
    , |; G9 Y/ `( r$ K0 t1 B8 K  T! E
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    
70.                         return &g_tUart8;
    
71.                 #else
    
72.                         return 0;
    3 d! N# {7 i7 ]  c0 `. ~% s; W
73.                 #endif
    % p  W" n$ u  Y" v" C0 E
74.         }        
    7 b+ f1 S# Z  B8 j3 m4 |7 ~
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    9 P1 I7 R' K8 `
78.                 return 0;
    
79.         }
    ' F$ }; y) n3 Y% t" C
80. }

复制代码

30.3.6 串口数据接收
$ z5 W, @) E. v) ^# q8 Z下面我们再来看看接收的函数：
% s! E! R, Y' U( m5 L/ D* D
5 Q& x) J) y( X

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _pByte: 接收到的数据存放在这个地址
   
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   1 ]; v; B+ _/ Q4 {* x  E9 v
8. *********************************************************************************************************
   5 ?% t* H  x" z4 ]& p
9. */
   # L! r$ P! w7 U" a# J
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    ' f/ F7 c/ M6 U) v9 c5 l8 I
12.         UART_T *pUart;
    
13. 
    
14.         pUart = ComToUart(_ucPort);
    
15.         if (pUart == 0)
    + V( n  _( p% ]. i% {" @, [9 E
16.         {
    
17.                 return 0;
    
18.         }
    
19. 
    
20.         return UartGetChar(pUart, _pByte);
    . E( l3 d' L) v# }2 t
21. }
    
22. 
    
23. /*
    ' n+ G8 p: l( C& A4 e
24. *********************************************************************************************************
    
25. *        函 数 名: UartGetChar
    & x; S; G. a, y/ Z
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.         uint16_t usCount;
    / {- l# w# |5 h: z. q* v4 V  D
35. 
    
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.         DISABLE_INT();
    
38.         usCount = _pUart->usRxCount;
    ! b) P/ B0 ~0 Q  c) w. M9 Q
39.         ENABLE_INT();
    3 u+ p5 A5 N# n
40. 
    
41.         /* 如果读和写索引相同，则返回0 */
    5 W4 J+ o6 X/ ]& @
42.         //if (_pUart->usRxRead == usRxWrite)
    
43.         if (usCount == 0)        /* 已经没有数据 */
    ! t- C- F' X( ?3 e" ]" C3 j
44.         {
    $ o/ W% L2 M+ P2 h/ O: Z7 x/ L- y# K
45.                 return 0;
      Q; K3 T% S- C' g& Y4 b
46.         }
    
47.         else
    $ P3 [; @2 P6 z  {
48.         {
    
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    
50. 
    $ f) o& r! s3 M2 D% u
51.                 /* 改写FIFO读索引 */
    
52.                 DISABLE_INT();
    
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    
55.                         _pUart->usRxRead = 0;
    
56.                 }
    5 U+ j3 r& R6 T5 h* }
57.                 _pUart->usRxCount--;
    
58.                 ENABLE_INT();
    
59.                 return 1;
    
60.         }
    " \$ y( L+ ^4 b4 h9 t  X# N
61. }

复制代码

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

9 C) p+ b- S1 H9 w4 ^' N注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。
% |6 ^1 J5 P1 U% `( `( b
30.3.7 串口printf实现
7 J; P7 p0 m2 ]1 Hprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
2 C% H; ]7 Y* w+ J# G
为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。

实现printf输出到串口，只需要在工程中添加两个函数：

! M# L- z# r4 ]2 p

1. /*
   1 ]2 b9 ]  i: M; x5 i  K
2. *********************************************************************************************************
   - ^) |* H: ]" J/ N1 F
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   # a2 ~0 k& D4 r7 H: D  M8 p4 i
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   & M! `  P  k6 V
8. */
   : Y$ N- t/ m. n, o: @
9. int fputc(int ch, FILE *f)
   
10. {
    4 w4 G& }% M! e+ H4 a( W
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    1 k) g- v. M7 p8 f
12.         comSendChar(COM1, ch);
    8 y; E  h- Y* d# I  J: ~$ t
13.         
    * V, g9 {# l. \: @' P
14.         return ch;
    
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    9 C( v  u& x. J
16.         /* 写一个字节到USART1 */
    1 z* g5 [7 P' T: l
17.         USART1->TDR = ch;
    
18.         
    ; D- G* f* `' X6 R! W% F% z  U
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    
21.         {}
    $ y( x; h! c% Y4 K
22.         
    - k5 F* k2 Z/ M2 B& R8 m
23.         return ch;
    
24. #endif
    ) c- }, a7 o+ K7 V! a
25. }
    1 N& w3 O! l# W: s& O1 L# s
26. 
    # H. a% x; W8 N5 }: m4 c) [. O
27. /*
    
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    ' F! Z- K6 U) }$ Z* w7 G- u& d$ p
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    - s- w2 [7 g& J1 [
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    & W' _: ~4 p. [$ E
39.         uint8_t ucData;
    
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    
42. 
    
43.         return ucData;
    : k7 m+ |$ \) Z1 D0 M; C  E2 d
44. #else
    
45.         /* 等待接收到数据 */
    4 C# C1 G, N' K# e! P3 _' |/ m
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    2 U% {9 l8 b" A* F$ a# I# P* H
47.         {}
    7 x, W2 {- s) ^  e9 G$ u. [
48. 
    
49.         return (int)USART1->RDR;
    / d/ j& {! x+ H
50. #endif
    ; X3 T; b4 F, i0 W3 ?
51. }

复制代码

printf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
9 h9 M7 q- F" m
+ W2 O: k0 X" K* t30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
+ F- w8 {3 X. @, u. k* c0 ?串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

  bsp_InitUart
  comSendBuf
0 o2 E7 c. A/ }% p  comSendChar
2 B# I3 C1 I# ^/ Z) b  comGetChar
30.4.1 函数bsp_InitUart
函数原型：
void bsp_InitUart(void)

函数描述：
' n2 r# }/ J8 R4 K& ~, h& q7 J, E此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

( g$ r: P& r1 j. }6 A$ _1 l使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
" T6 o3 E5 G& C8 l0 O
; c7 D  V/ M3 w, S: ~( W2 C30.4.2 函数comSendBuf
函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
2 u8 R0 F; L. N6 X
& s/ ^! I9 T% ?  ?1 b+ l* ^
函数描述：
9 X/ C! z% _. T+ s" k: u此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
6 C7 {/ q3 [7 O8 L9 Y/ b
! I7 s# O/ M9 @, {( _函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
. u5 M4 X- M6 B+ o1 B  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。


! F8 R! ?# \& l. i3 D* Z3 j* C注意事项：
/ ]9 G$ c1 d, A1 ~; O2 S" L& b  此函数的解读在本章30.3.5小节。
, C* H( U& ^: R  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。

( l) {8 x+ \% {
4 {1 E, e, M2 O: T: e+ `8 y使用举例：
" j; l: p) @6 _. {! G! r, L调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
! S  X' p: x" R( m$ o1 A1 `
const char buf1[] = "接收到串口命令1\r\n";
comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
- B, A$ R( ^' j9 h2 M3 X$ }% u0 i+ T
) o, s4 J( ~) p2 ~7 T( d' n
% }$ i7 K0 c9 z6 C% q30.4.3 函数comSendChar
函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);


函数描述：

此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
4 |$ ^# @9 A  h8 K2 r
. X  Z. [/ m  d4 _! G/ ~. [# O函数参数：
) m# h7 ]+ c1 c( V  第1个参数_ucPort是端口号，范围COM1 - COM8。
+ R+ ?9 S7 j4 k4 B+ }! c! D3 x! z9 O1 z  第2个参数_ucByte是待发送的数据。

$ X+ p- z; F+ ?/ j' i( f" x' @; W
* [. g& _2 T/ n, l% x注意事项：
  此函数的解读在本章30.3.2小节。
' P  M' t, B6 ^- D7 k+ F1 a3 K& q

4 L" a$ U+ x  C/ C( U! G+ ^& W使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
7 C/ A) o# S9 O比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。
2 S3 I# |  x# _
  n% M) l+ X: n$ Q0 r! q30.4.4 函数comGetChar
函数原型：
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
4 S0 i6 V6 _/ M$ U# q% r  ?
. Y" C7 _* C( q
7 u/ Z5 @% O) o- d) [# Z函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

2 y$ u5 v8 W( T3 M函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
; w0 g/ \+ ]2 Z0 f" F  k& T  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。

+ @! K4 P/ w" u  B9 u
注意事项：
  此函数的解读在本章30.3.6小节。
- A' `0 c# q, h% w- ?
6 @; [4 A" |7 M/ O
3 z, d( W1 u( i9 C7 r使用举例：
7 l2 J6 O; j" S( m; j调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：

4 V- R: `/ e, t+ U, z  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
$ n/ ~3 o6 U- }2 j- ^  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define        UART1_FIFO_EN        1
   7 E  i2 x# _  Y$ ^
2. #define        UART2_FIFO_EN        0
   
3. #define        UART3_FIFO_EN        0
   + T. }- w" |% W; _: X
4. #define        UART4_FIFO_EN        0
   . w7 _5 }7 W9 m. N; B# y
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   - p( t0 ^. o7 l6 r/ M) l
7. #define        UART7_FIFO_EN        0
   
8. #define        UART8_FIFO_EN        0
   # K5 K4 c% h0 h) Y
9. 
   * l9 g+ w5 F0 H& B
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    
11. #if UART1_FIFO_EN == 1
    
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    ( T$ l) s1 @& S+ m$ \
14.         #define UART1_RX_BUF_SIZE        1*1024
    + f; L, m# o' p% i! p0 i$ c! B
15. #endif
    
16. 
    * U1 @& z0 `8 W+ _
17. #if UART2_FIFO_EN == 1
      i% Z* R+ V, }6 B# K! u
18.         #define UART2_BAUD                        9600
    : d: o% Q1 x' Q: f
19.         #define UART2_TX_BUF_SIZE        10
    ; h" `3 m5 v) K: N. V/ g
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    
22. 
    & r: s$ M: R/ ]( E
23. #if UART3_FIFO_EN == 1
    ( q4 K! |; i' Z7 p+ c2 ^. i
24.         #define UART3_BAUD                        9600
    ' K6 [6 z* J6 y: ]9 d% ^3 `
25.         #define UART3_TX_BUF_SIZE        1*1024
    ( @! f- K" I' g9 u% Q1 c; c
26.         #define UART3_RX_BUF_SIZE        1*1024
    " b. n1 _$ h4 i# T( k9 P# w  o, R
27. #endif
    6 H  d# I' p0 F/ q/ g# j
28. 
    ) b; _' O4 v7 z6 E" d$ a- ~6 v
29. #if UART4_FIFO_EN == 1
      }" ^+ D  }9 c( Z- x
30.         #define UART4_BAUD                        115200
    
31.         #define UART4_TX_BUF_SIZE        1*1024
    ) [  z9 z3 ]8 c  j5 m5 s# m  G' Z
32.         #define UART4_RX_BUF_SIZE        1*1024
    " }+ v2 A9 F, I4 P6 w1 A4 |) W
33. #endif
    , f0 u! a" D5 S. l" q4 ^: @4 O
34. 
    9 ^- Y2 E/ o9 z; n0 t3 `4 D) h
35. #if UART5_FIFO_EN == 1
    : Y' s0 Y6 z& f5 g4 i, R
36.         #define UART5_BAUD                        115200
    " O' _: v2 X' f" B
37.         #define UART5_TX_BUF_SIZE        1*1024
    
38.         #define UART5_RX_BUF_SIZE        1*1024
    2 I% Y- [5 P8 c  ?' }9 W
39. #endif
    
40. 
    7 i4 Y9 t# ^2 p0 W, V0 s( ^
41. #if UART6_FIFO_EN == 1
    - }: ~( m2 W, q* w" T+ H) l2 G- n
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    8 [+ x8 w' w$ ^/ l. F. ~
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    2 c% V; O  n! e+ ?1 ~1 V6 G7 G, V! R
46. 
    
47. #if UART7_FIFO_EN == 1
    ' A2 J( Q/ b9 }
48.         #define UART7_BAUD                        115200
    2 y, p% R7 Q, X% r3 I6 R
49.         #define UART7_TX_BUF_SIZE        1*1024
    $ U! f* I( Z6 c+ P0 Q! O
50.         #define UART7_RX_BUF_SIZE        1*1024
    + f. @6 O; a8 q7 [# a- @
51. #endif
    3 m* y1 X! a' u. A9 x. ?; v
52. 
    
53. #if UART8_FIFO_EN == 1
    4 [- }* y( P: ]$ k
54.         #define UART8_BAUD                        115200
    4 J2 U. ]$ E- y7 g" K+ K
55.         #define UART8_TX_BUF_SIZE        1*1024
    - V, s* B1 _, K. U5 U
56.         #define UART8_RX_BUF_SIZE        1*1024
    1 X" k& C) S6 h4 W1 C
57. #endif
    1 d, ?4 j  e( x/ z8 H8 n

复制代码

  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
) ]& ^/ B7 ^: W2 \3 w2 i  第4步，应用方法看本章节配套例子即可。
7 C$ j- r: K0 F1 Q
9 a$ _$ g0 D1 L7 |- G, g2 h30.6 实验例程设计框架
( W, Q/ b' s1 Q7 t0 o通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

: A, q! J# W- @3 f3 x

  V7 i7 Y9 v( B- ?7 }8 W, k
: R* M1 L7 w4 j: _9 ~  第1阶段，上电启动阶段：
( a7 B& y9 e7 V/ q
/ u* t" \3 R; }( E: C' o8 g4 C: P% {这部分在第14章进行了详细说明。
5 s& F6 q# s/ a, f  P7 Y  第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  F1 l2 K6 P6 X  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

/ E* q7 S: c: u5 W5 q" o+ {+ V30.7 实验例程说明（MDK）
% c/ o2 S% z$ B1 T5 X- n5 f8 H配套例子：
) A# B' d, d/ O+ L& A
V7-015_串口和PC机通信（驱动支持8串口FIFO）

实验目的：
% u& a. j( U& b1 Z* \1 J- a学习串口与PC通信。
" h) j9 F6 |8 V7 J) K4 B

! D; G* n  w* n6 y) _4 |5 P! Y实验内容：
+ _; U+ V5 T( U* q% x8 e启动一个自动重装软件定时器，每100ms翻转一次LED2。
0 m/ N' z: E3 {, M; {
' e7 ^: d0 }3 a# d' X
9 x/ B: F% T* n, p! ?实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  ~# D; S  Q7 g8 K; w7 o6 l串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
7 c3 @& b( F6 O4 p% o8 TK1按键按下，串口打印"按键K1按下"。
# R5 j+ v. v2 A# Y2 ]K2按键按下，串口打印"按键K2按下"。
  ?! E2 W0 N" Y  uK3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：

( z, x) u+ |' Y! \3 {波特率 115200，数据位 8，奇偶校验位无，停止位 1

: w" e6 m  T5 G

& }2 r" l; e1 F$ g程序设计：
8 \) G3 C  z) d5 y/ q1 }# U3 P2 u- M/ s
  系统栈大小分配：
  M7 S. e- ?4 f+ N& Z: ?0 s! p9 U

  RAM空间用的DTCM：

+ |( g9 |* t  \% ^) x$ N

: T9 J# W! w( ?: O( u  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
( U5 Z; X  J; u5 E
) m, t1 E6 j, m

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   4 C( V0 X* e! N% x2 g
5. *        形    参：无
   + H, P$ v3 E* [2 s# V5 ^$ p8 `
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   & |* E5 B* `" d
8. */
   
9. void bsp_Init(void)
   
10. {
    ! {. f0 m& [& ^
11.     /* 配置MPU */
    7 w  a" |/ W0 n8 }
12.         MPU_Config();
    
13.         
      W' n0 I) ?# F! [- }; O7 Z
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
      ^* T; ]+ j3 H0 t! G6 w
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    $ y8 D. K, k: r
23. 
    9 E4 N& g- l3 f8 h1 L8 @) }: r
24.         /*
    
25.        配置系统时钟到400MHz
    / M# @( E2 v* Z; D8 a
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    / T) D" t! |5 h6 Z7 s5 f, U
30. 
    & ^* `0 W+ r# P* Z. p' B- i
31.         /*
    2 i6 V/ O  k$ Q/ n
32.            Event Recorder：
    1 ?3 N7 G$ o( b, K) [
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    - [) w8 P8 a" P
36. #if Enable_EventRecorder == 1  
    7 s" H4 ]) ~( ~: S5 o9 c" l* x
37.         /* 初始化EventRecorder并开启 */
    # ~' B* T# w2 c% ]; J: _# q
38.         EventRecorderInitialize(EventRecordAll, 1U);
    7 t" S2 l8 m6 V% A' ?- P/ G: J2 P
39.         EventRecorderStart();
    & B- C  G& T/ E8 F3 W- _% b
40. #endif
      c( w7 V1 ^+ C0 ^* ^. m5 Q
41.         
    & U4 s, h+ Y- ^1 j1 |
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    , g1 V, R! J$ l8 }' t9 B) F0 l
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    * B9 _$ v( [* L7 R
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

% n3 O' t- R: K! g' T  MPU配置和Cache配置：

% Z3 L$ B& A9 \9 L# |数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   ; t" J. p$ T+ j7 R' C: b
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   3 d6 F0 h9 Z7 J' E
10. {
    ; F- D( s% w; [, R- E5 x/ @2 a: M
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    2 o  [  l1 W9 |: T  j
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    & B% f* M/ |" J8 ], I
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    . [- N, J" |8 Y' c" ^5 F4 K
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    6 h. V) ^- P8 M- ?/ I- u
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + F$ `" Y1 w/ j2 v) ~& o5 }% ~
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 ?/ C: X8 E/ b  M4 n
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ' M+ X/ r; \; r. N5 }
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    7 q( G6 t* |! J. {7 I
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    1 r7 `. H" j, c8 D+ \! I
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    ' Y2 s& O0 H# h9 k
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    / l% R+ b. y- e5 Z, B
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    $ P: g' D- [% j2 q2 [
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ; f8 u: n7 e; h0 O5 ~+ ^( Y
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    6 i9 W8 f/ L- @
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    : A6 V% o0 Q& `
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    - y9 |$ _: G2 u* _, ?$ H1 F
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    * Y# h/ \# `+ [8 n" G3 m3 |* C, u
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    ! I0 Y9 t' Z6 Z% _- `9 k* Y; w
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    5 Q( X2 r8 B1 r/ E9 r6 k7 e
54. *        功能说明: 使能L1 Cache
      S1 b1 h3 T" O: @+ h) |
55. *        形    参: 无
    - d0 X6 d5 r# ]/ `" M1 t
56. *        返 回 值: 无
    ' d3 w; \$ \) ^$ }% K5 U( f
57. *********************************************************************************************************
    
58. */
    9 L# a6 ~8 |% P0 C; Z% ^- ?
59. static void CPU_CACHE_Enable(void)
    $ o$ X5 w1 x& x# W) s6 |$ `
60. {
    6 a5 R+ z* w( ^6 r$ g
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    $ o) g! V; V/ h0 K4 P4 ?4 g8 h
64.         /* 使能 D-Cache */
    5 M' G, z/ U# U3 Y" u
65.         SCB_EnableDCache();
    
66. }

复制代码

' U0 g1 M6 c$ n" ~2 M* F  每10ms调用一次蜂鸣器处理：

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

6 `2 O# Z) h7 C  n, k

1. /*
   9 ~9 N4 G5 t$ \% ]5 Z) p" _( D) _
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   : F4 n9 _# A) X8 r& Q1 T+ F
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   9 q0 {# Q8 ^, a
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   0 ?: D3 S1 _4 R' R. d, d/ v  p
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    / T  e" E; o2 F
11. {
    2 g6 r$ k# e1 w' a) {
12.         bsp_KeyScan10ms();
    # D6 n1 T) c5 g
13. }

复制代码

4 j' `$ I, d) i& o  主功能：
. S6 ~( E- x1 M! @# h
- z: u! J9 T( \$ K7 G( s' `' U4 D  s: O主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
' [) ~4 s' |" V8 k3 M  K1按键按下，串口打印"按键K1按下"。
7 |1 b, n$ @! L9 {, V  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。

1. /*
   : d( H/ t4 ~3 k! K# H
2. *********************************************************************************************************
   ! }3 ~7 R& t+ z/ {( Q7 P
3. *        函 数 名: main
   5 }  L. D+ G/ O; w5 ~2 t
4. *        功能说明: c程序入口
   & v2 P( n2 }* L& w2 F
5. *        形    参: 无
   & Q6 b: e7 c- {1 ]3 r3 E
6. *        返 回 值: 错误代码(无需处理)
   ; r( f, X4 ]) b0 d' ]# w5 k+ `
7. *********************************************************************************************************
   
8. */
   , |+ }" `' V; S! Z* v; Q% _
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;        
    - @' D2 D7 r) X, {% v
12.         uint8_t read;
    & T+ q! ~: D6 e
13.         const char buf1[] = "接收到串口命令1\r\n";
    : V0 Z) P: c2 f& p
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    : a. ]" E# Y! J9 Z) H
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    $ a% `% |+ A9 N5 y/ A2 U
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    - m3 W9 H& z" N. x: M
22.         PrintfHelp();        /* 打印操作提示 */
    0 S" K, F( i% U
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    * u2 k6 }2 D. G' m
25.         
    
26.         /* 主程序大循环 */
    . A0 B: N; S  e& B) k. O
27.         while (1)
    6 u- \/ z( u9 _, T9 l' {
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    
31.                
    ' v! |8 p4 Q9 K6 K
32.                 /* 判断定时器超时时间 */
    : w6 c5 W4 ~4 v. q9 G/ M
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    9 _) Z# \* _0 s; t8 T& `
38.                 }
    0 \  e) x7 \1 ]4 _2 d
39.                
    
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    ) Q# @- h6 ~! r' @" {1 l
42.                 {
    
43.                         switch (read)
    
44.                         {
    
45.                                 case '1':
    % J3 g: j) m7 b* ^
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    $ s6 @8 H5 l+ Q8 H& U2 L$ m" `0 g
47.                                         break;
    8 ]/ E' z9 w( s% ]9 v" ^( ]5 d& y
48. 
    ; c7 W# z6 q2 m9 |2 o, e  {) X8 z
49.                                 case '2':
    + h6 }. s- J0 k1 v' w
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    ) r3 L+ S# q" g; w2 s
52. 
    
53.                                 case '3':
    3 m( X  y! G/ c
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    , f# m( S. i* m; _! W- [
56. 
    
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
      O* L" Y8 i9 e2 c- c4 N. L$ ?) Z
60.                                 
    $ z- v! e' ?8 K
61.                                 default:
    
62.                                         break;
    
63.                         }
    
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    ! D$ M+ y* N6 W8 {! l+ ?
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    - L9 j. X) R8 |1 {, K0 E4 L" v( q+ x8 h
71.                         switch (ucKeyCode)
    
72.                         {
    
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    ( }7 g% i! S; X5 {& p; K0 ~3 ^
75.                                         bsp_LedToggle(1);        
    1 r2 \6 |+ _1 u9 q( x2 G
76.                                         break;               
    
77.                                 
    , a* t6 `) h! _- f4 Z0 P
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    $ K$ V+ S. N4 h$ G
79.                                         printf("按键K2按下\r\n");
    7 e* h! m3 u. }& E4 O$ n
80.                                         bsp_LedToggle(3);                                       
    . K; `& {" c% p0 j% ]" k" n7 R
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    2 `+ m( a- D: ~$ r! z2 |; b' C* I
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    2 [# a  g+ D  F+ l1 Q; D4 ^1 W
86.                                         break;                                
    5 z9 ~2 J. [" _) h' o0 n( {( @1 |
87.                                 
    , k, W' i& {4 J3 z4 ~1 y
88.                                 default:
    
89.                                         break;
    
90.                         }
    
91.                 }
    # ]8 n3 y5 K; J% T+ J
92.         }
    6 u, j5 k, J7 p- Q( z
93. }

复制代码

30.8 实验例程说明（IAR）
配套例子：
0 m1 l) b: k, W: [9 i
V7-015_串口和PC机通信（驱动支持8串口FIFO）

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

. Z' |* E, O/ X) X9 u
- y7 g/ U, S2 v2 O3 l% X, H2 T) m! n% R/ {实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。


  J" W9 a3 Z1 G- k9 n实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
3 w0 j" H: b3 a2 ^, W+ ~$ K串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
! R3 B% e% i) v& O8 RK3按键按下，串口打印"按键K3按下"。
- O/ [: S! n# \, A3 X/ U上电后串口打印的信息：
9 w2 p; j4 u9 w& ]' f7 B
) x9 c$ g: ?9 b2 J6 D波特率 115200，数据位 8，奇偶校验位无，停止位 1
# l; R! Q( C4 G' k
/ K# M2 l  q( g8 f

程序设计：

/ n+ I  K+ B. y   系统栈大小分配：
& H5 }. G& |& ?6 U$ B0 b5 r5 x

   RAM空间用的DTCM：

; \# z- n  |6 ^% U
0 R* @5 _) W) u' h. T8 Y' U  硬件外设初始化
: p4 N* y& c% e' Y+ [: I/ x
硬件外设的初始化是在 bsp.c 文件实现：
$ N, s' P/ Z. z! l# L& r7 P
9 l# X" b* _. _; G2 n# f; B% L. T8 u' Q

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   $ D  z2 Z. G* [% J4 s  i
8. */
   1 h$ d: u, {" m) m2 V/ A
9. void bsp_Init(void)
   
10. {
    4 v5 y% r9 Z" I; t% _$ a
11.     /* 配置MPU */
    8 `0 ]9 o& y8 L7 `# E9 X3 D+ s
12.         MPU_Config();
    & v9 o, w6 F0 \" ^
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    # m9 d: q" j$ Z/ K- V
17.         /*
    $ L; E3 ?& z6 A0 O
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ; p' \+ t8 R0 n9 w
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    7 q- P& W( [; l$ O3 E+ g
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    
31.         /*
    ! P4 }4 g! y; \" Q
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    3 {8 T1 ]% A* N% w, ^2 b
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    3 g' v0 B3 y1 b- s
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
      Y7 B& U+ q0 v) G5 F  t
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    ( v: o! q: w; ~/ w3 L1 o
44.         bsp_InitUart();        /* 初始化串口 */
    ! {: f1 Q! F$ f0 Y' \4 j
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    ) V" [% E8 J& f9 `% b. W3 _
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：

: o+ g3 E. F  L+ @3 R数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
3 c8 u! {) X5 O% C" ~: x2 e

1. /*
   
2. *********************************************************************************************************
   0 C6 K2 q  [0 g7 Z; ^. ?! @
3. *        函 数 名: MPU_Config
   ' N+ l, d. M) a
4. *        功能说明: 配置MPU
   7 q) W$ p- g0 X4 j
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    : P4 _% `( i* X* L: @7 a7 A; N
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ! T6 j, z: x% `/ n
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;
    ) K2 S/ c+ W. V
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 |- L! r4 [; v
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
      H4 A: O8 E3 k% c
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    ! n* V( D, }6 W# g1 n* m
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 k8 b) Y7 c- Z+ y# k: T) L
28. 
    # ?1 ~* ^: M: u; I; f+ Y
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 J& }' [9 ~4 P6 p
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    3 i; F. K# e2 A: w: X
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 w$ i9 w! W! b5 q2 i5 L
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ; I5 p& P; J, T3 _$ T9 r
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    / S! F7 X2 h7 \- W' Y* q3 P
44.         
    ( }& i5 G- e8 L; T: K
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    4 o$ R2 m( w# P6 T* W, f. ^# H
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    0 z* S1 g  U( g  `% F% B3 ?
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    , }. Z5 y" q; x! Q, ?; q
55. *        形    参: 无
    $ s8 G# j1 c, {9 i
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    2 m; E1 V+ S1 ^/ o4 f# [
62.         SCB_EnableICache();
    * K, J2 k( x2 w# r% U; a1 D
63. 
    9 d% A% W. U+ x2 D% y, o
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    - g) q, S5 y" D+ L
66. }
    
67.   每10ms调用一次蜂鸣器处理：
    
68. 
    . e8 D+ G- R; ?9 H
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    - V4 ]) s7 A! J" i1 i
70. 
    , h, F* ~' P, s4 d: E2 M8 k: B: [" F: g
71. /*
    ( m! X8 X" h# d3 a" O. V
72. *********************************************************************************************************
    4 c6 T8 q% Y# E
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    . Z0 m/ y" e& ^4 y" m
78. *********************************************************************************************************
    
79. */
    & {0 \0 K  U. Z! q
80. void bsp_RunPer10ms(void)
    
81. {
    5 b  `  Z+ ~0 s7 \; S
82.         bsp_KeyScan10ms();
    
83. }

复制代码

  主功能：
& }" l1 {# M. c
主程序实现如下操作：
% ?/ G: m2 K; g0 C$ Y
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
. o- \/ _' I5 Z; P; c  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
0 |/ A) U$ ^7 c% E  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
3 ^) {, |4 l2 [8 _* n9 ^+ N/ a2 \  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。

1. /*
   
2. *********************************************************************************************************
   6 u) m5 j1 T* O# R2 X: S2 o
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   1 X& a: ]0 y: D  ~7 i" w
5. *        形    参: 无
   - n% W! L; h- c5 E" W3 o
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   - m0 S/ e; c9 A% i1 Z& D5 E9 x; }
8. */
   
9. int main(void)
   % @7 H! ~4 m/ a: ]5 G
10. {
    
11.         uint8_t ucKeyCode;        
    5 Y2 l9 }7 r4 h8 L+ N5 \& ^( z
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";
    $ r) \/ `( [  g( h& a
16.         const char buf4[] = "接收到串口命令4\r\n";
    9 Y; C/ @6 G, m
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    6 e4 d3 K5 @7 E3 i5 ^' m
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    $ _$ ~" X6 D3 ^2 a  x  ]
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    8 M1 Q4 a% Z! V& r$ J& d/ H& w
26.         /* 主程序大循环 */
    7 R* s, M" J3 c0 \( G7 F5 P/ L
27.         while (1)
    
28.         {
    7 x% b2 y1 {* D% F' V! N
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    1 F0 T2 N% W( g% X% Y+ e3 r
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    5 o$ I: {1 P1 m# ~
33.                 if (bsp_CheckTimer(0))        
    / R7 n, c$ E+ w, X! Q9 e
34.                 {
    # G1 i7 M( e( M  [
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    9 k( b& h: t; t7 G) r
37.                         bsp_LedToggle(2);        
      W( _# G$ T8 B1 b; r! |. e
38.                 }
    / Q& `" A' u$ S( A1 ?
39.                
    
40.                 /* 接收到的串口命令处理 */
    & Q' L/ q2 F9 W1 o2 W
41.                 if (comGetChar(COM1, &read))
    / R' Q0 ]1 X. X
42.                 {
    
43.                         switch (read)
    
44.                         {
    0 q: x) @# h' N( K; W4 R
45.                                 case '1':
    + S2 ]* r/ ]' q8 |- _2 _8 _
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    ) r9 t- i0 c' k# N3 V0 E/ ~$ ?
47.                                         break;
    & F) C0 G2 R' W5 j- c% B! R, O5 N
48. 
    
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    / }# V0 v& C' d- p% P: @, ^: Z+ d
51.                                         break;
    5 r6 M$ u# I1 p. \% |" y5 c1 Z3 P$ o) k6 H
52. 
    
53.                                 case '3':
    * O3 B3 Y9 x' z  A; E
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    
56. 
    
57.                                 case '4':
    - H5 @( T: S( G
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    . m/ y; n$ X+ S1 }9 @. M
59.                                         break;        
    
60.                                 
    
61.                                 default:
    
62.                                         break;
    
63.                         }
    2 }$ g! G0 r- ]3 h
64.                 }
    3 z; \7 c% z: g, Q" z8 o; G
65.                
    
66.                 /* 处理按键事件 */
    + W* u8 i' _/ b, ]1 K  U
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
      M( x. V9 V: k
71.                         switch (ucKeyCode)
      h4 c4 n+ w& ~5 y7 X* s: d
72.                         {
    . ~% J9 R9 Z4 o3 W
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    / m  u+ w# g) L9 r) z  p6 u5 G' ?" f
74.                                         printf("按键K1按下\r\n");
    ; g1 ^0 z% J9 \* B3 s5 z) a# s& x
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    2 U/ e4 G3 r, U
79.                                         printf("按键K2按下\r\n");
    6 c& Y, b6 {2 E6 u3 I' K
80.                                         bsp_LedToggle(3);                                       
    ( Z) _/ k  k5 ^3 D3 N. N9 s
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    3 u* R+ S8 L) B- q
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    , c5 Y0 i8 l* R$ n- Q' o- B- P
86.                                         break;                                
    
87.                                 
    
88.                                 default:
    
89.                                         break;
    % s! M9 Q# ], u8 }3 Z1 q
90.                         }
    
91.                 }
    0 t" v; z$ v& y. P% A4 r% J
92.         }
    
93. }

复制代码

30.9 总结
本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
4 t  S% }9 o1 ?7 r" P
" F# O+ X7 G5 M3 u: g2 N
' X9 V% G( t4 q1 K

4 p1 Q; V7 I& s) {7 L  a2 a
1 @( u' x' l! s, M0 n