30.1 初学者重要提示
0 n8 A( `: R% n1 f5 ]学习本章节前，务必优先学习第29章。
7 j+ k5 K$ e& x: S: h' h串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
3 {$ \6 C+ K0 f  F" [% \本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
# M- i- w) ~4 _. \3 ~' ~大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
! k8 R) P" z7 K% q$ x8 A! [) t. a% [CH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
1 u- Y$ x8 n" y30.2 硬件设计
, H& a  g; z+ [, iSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

1 N1 K/ Z+ c6 S# e串口USART1  TX = PA9，   RX = PA10

串口USART2  TX = PA2，   RX = PA3
; I4 j6 _" q+ O. r9 @
* N2 ~$ H( W3 A1 L9 k8 m9 A串口USART3  TX = PB10，  RX = PB11

& q4 n. F7 b9 O8 F5 \6 D4 V( `串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
, k) ^# H/ o  q1 C3 H. z
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
3 }* b  d$ Q1 {& Y) g. D
8 i/ b) N; H/ n串口USART6  TX = PG14，  RX = PC7
8 s- |! X1 Z- [- S; h( s
9 y. F4 ^; @( Y4 n6 `  H* |1 e串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
, Y8 J: j0 g! d! A3 y( b
串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

* P0 f/ L' |1 j: q0 k# I8 {5 NSTM32-V7开发板使用了4个串口设备。

串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
3 ?7 b# V$ M9 L, G" u4 [& b串口2用于GPS
# R- i2 X/ \4 K- T4 e串口3用于RS485接口
串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

  C  b7 N# e7 h) L- {8 e! F+ `

关于232的PHY芯片SP3232E要注意以下几个问题：
/ Y+ \: i' p8 R7 r
, \/ @! J" X0 B$ X' CSP3232E的作用是TTL电平转RS232电平。
电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

; W  Q5 u0 ~3 y2 t; A实际效果如下：

通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
! j' e) a$ y: y- M. X2 p: Y
由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
$ p, i5 O! f' _6 F# y( `检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
- J4 ]6 t+ h1 D5 G
/ X' T/ i0 d, t" C: P30.3 串口FIFO驱动设计
30.3.1 串口FIFO框架
) n6 c9 F! S9 k4 \- j9 p; I# [为了方便大家理解，先来看下串口FIFO的实现框图：

9 k4 |. G; Z1 U" y9 W

! Q! V) D2 W/ x( H. v" J5 T
$ W# S/ I- o) `9 [/ \; Z$ v第1阶段，初始化：

% |0 B5 g# p9 r' A; T3 m通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
% @! E! X7 v& Z1 o' Z9 C! E第2阶段，串口中断服务程序：
1 j$ O) u/ F8 R( I/ B: A$ X  Y
接收中断是一直开启的。
; ?; s' y. W6 ~  l做了发送空中断和发送完成中断的消息处理。
0 u* }# W$ o6 Q+ e1 N; K; G9 c7 A第3阶段，串口数据的收发：

串口发送函数会开启发送空中断。
0 [0 N! J+ o7 B* w/ ?. D7 F2 v# Y* R串口接收中断接收到函数后，可以使用函数comGetChar获取数据。

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

6 J( \; C7 a4 }+ B8 n% d- j这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。

每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。

我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。
, v0 V/ w5 i: @% s2 F

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   ' r% u8 c0 U  l/ c$ F
2. #if UART1_FIFO_EN == 1
   
3. #define UART1_BAUD                        115200
   2 }2 k6 h* V$ _- o
4. #define UART1_TX_BUF_SIZE        1*1024
   6 S8 U. k+ Z9 Q
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   % b% F6 a8 C2 S1 H7 O2 n* F
7. 
   8 P, n$ m- ]/ w+ Z1 M
8. /* 串口设备结构体 */
   . p- X$ h% ]* H  c
9. typedef struct
   $ E: \, t$ P/ x! l
10. {
    
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    . a. a% Z% S7 [# [* p+ Z- z
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    3 Z: k' B! c2 |8 q
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    6 A7 e3 A, t$ S3 w$ k
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    6 I4 t' S/ y2 Q/ C3 n
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    8 E: o- j$ e% O6 K/ l* R( [2 c
19. 
    # c3 L6 t( E1 p0 f
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    1 _1 D% F7 j; `# u5 V- s
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    3 u( }' j. [/ z. w9 k3 C6 O
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    9 w8 n& W! _" B7 w
23. 
    7 S3 U: p  ]( n3 B7 y
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    / F/ p# z% \. c4 I) I3 c: S
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    : y1 E( i+ w0 _2 u2 M/ Z
28. }UART_T;

复制代码

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

1. /* 定义每个串口结构体变量 */
   
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   6 t" n4 g% J7 w
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   ( R2 a& V$ m, J- d  Q
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   2 D! L3 j0 V2 i4 T' L, N" n% a: m
6. #endif

复制代码

关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
/ d9 {, P, g# R/ L% ?: T% E6 ?
7 @2 R. \+ h8 M' J( J0 O30.3.3 串口FIFO初始化
串口的初始化代码如下；

1. /*
   3 }9 I1 U! X- r' ]% B, f3 x0 ]
2. 
   
3. ---
   1 ]" j& E% [6 ]0 \6 ?" U! N+ h) M# |
4. 
   1 d1 R  ?9 ^) S1 C* T: b4 X9 e
5. * 函 数 名: bsp_InitUart
   ' t6 ?) V. ^1 G9 o- [( Q6 K1 O
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   : [6 h0 s- j4 M* @) j
7. * 形    参: 无
   
8. * 返 回 值: 无
   # }8 j' p% C0 m$ N* A6 \* n
9. 
   
10. ---
    
11. 
    : H$ r( \8 M- ~- }' R/ b0 t
12. */
    
13. void bsp_InitUart(void)
    
14. {
    0 H6 D% @7 S$ O/ B8 f
15. 
    
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    8 t( t1 l, X2 w8 C& J$ G
19. 
    
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    
21. }
    7 l7 N# `% J5 i% t* n7 j$ i/ b

复制代码

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

函数UartVarInit
1 c, E  X( @+ Q1 z% S# h9 y8 y" q这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

' c2 w( E+ [' ?. v( k( R% B; Z5 D6 |

1. /*
   
2. 
   % G+ Z# j1 m: P6 A
3. ---
   
4. 
   
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   % h4 O1 L) K. M/ `2 h9 n) v
7. * 形    参: 无
   
8. * 返 回 值: 无
   
9. 
   $ J+ a$ \# n7 \+ p( F  F% A
10. ---
    / H9 I7 n2 Z- Z9 r" S
11. 
    
12. */
    ; q0 l" I6 g$ N7 J
13. static void UartVarInit(void)
    
14. {
    3 K: R/ F8 h( `5 x# A- j- i
15. #if UART1_FIFO_EN == 1
    4 ~, G2 J) F. Q! S  q  i% ?# _
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    & ^1 [' M1 }5 a: t9 P% J8 e! {
18. g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    : D+ w! d- w4 y& b* N
19. g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    6 B. F0 o# P: g5 @; P6 s
20. g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    / G$ n4 M( l3 }$ t
21. g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    8 j% N6 P: k" s! ?, p" l7 ]
22. g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    1 t$ W% U9 w! W5 q
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    2 t' f- u  u2 q) s3 B6 Y  V
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    / A  g$ i9 f, v) m0 y  L) p
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    " v3 n% F$ j% f/ U6 a; @8 c
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    & w4 c+ {6 Y3 x
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
      _# g7 b( s, F  W6 `4 ?
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    $ G1 m" z+ |/ |- L/ L. F
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    ; n( a: j' I" E" x2 h# K
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    9 y" F. p, ]9 e, k6 h  M+ ^
31. #endif
    ( S+ P! h8 K  r) G! \
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

0 H: P- _$ Q9 t* C$ t' y函数InitHardUart
此函数主要用于串口的GPIO，中断和相关参数的配置。

& V8 Z' m2 [5 L( r! ~

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   $ G6 ]. X' I2 P3 T, U
3. 3.        
   
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   , w  V$ E# r; U  X+ E/ J5 H$ S
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   : W) g2 K/ k. }* E: f' b. q* q
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   - r% i9 W) R! n2 j. |) R
8. 8.        
   
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    ! m; ~* e& y8 D2 d2 t) o( ^- `4 a
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    
13. 13.        
    4 W% Z1 h- L7 {- E* V( j% J7 E* X
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    & ~; c4 g4 V" s* G3 p- g
15. 15.        
    
16. 16.        /*
    9 R/ N# t* i# }( b( h4 P& J/ p
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    
20. 20.        *              发板
    
21. 21.        *        形    参: 无
    3 V; s2 h+ ^8 |* E" M* I
22. 22.        *        返 回 值: 无
    ; ]; o2 g) p' P% A- I! L8 v: k
23. 23.        ******************************************************************************************************
    7 X- n: f5 d# W# `+ S
24. 24.        */
    
25. 25.        static void InitHardUart(void)
    
26. 26.        {
    7 \( ~  T- r: t5 u9 l& k- U
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    " K( u0 C; p  q8 m  j9 s
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    # l) N9 [6 m. ^. G9 r' }
29. 29.               
    
30. 30.                /*
    : \" g2 [  F/ V9 B& h3 {% n3 T+ E
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;
    % ]* C9 k, Q# D$ ]' X
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    + s) D9 _! P! d8 ]
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    
38. 38.        
    . V5 z. x$ _. \
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    3 s, m4 y8 M: d
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    & l' J& R3 |0 A% u
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    3 m9 N4 x2 k, P" g8 k! e5 w  I* b
44. 44.                /* 使能 USARTx 时钟 */
    3 Q' @! q# L+ o+ E& {
45. 45.                USART1_CLK_ENABLE();        
    : P" c0 s( `" M8 y& [
46. 46.        
    
47. 47.                /* 配置TX引脚 */
    
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    ! l; S5 @9 G  y+ \' x; T
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    0 G9 ~6 _) z+ g$ z: h& a& w
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    
54. 54.               
    , K; h/ e8 S' S0 a0 ?5 [& N% N
55. 55.                /* 配置RX引脚 */
    ; K) J2 F. D1 s1 V; F+ s9 s  f: M( l
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    ; c( B& f. E4 B# j
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    3 L  Q3 w$ `/ Z* K1 a
59. 59.        
    
60. 60.                /* 配置NVIC the NVIC for UART */   
    " V3 r) H) O( p, }3 G9 v5 [
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    + h( c+ i/ I$ \% L; F( ~
63. 63.         
    7 p9 \4 ~: R2 O5 X
64. 64.                /* 配置波特率、奇偶校验 */
    
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
66. 66.        
    " N" o* _! i8 y3 S0 p5 ]7 x3 I
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    # R5 Z' a1 u5 f' \  ~
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
      m" p$ I4 r" {  T# u! e" d' `9 w
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
71. 71.        #endif
      f( W9 b( w+ g' m) m" {+ G
72. 72.        /* 串口2-8的初始化省略未写 */
    7 r7 y9 v$ \. t3 k# t/ S; N
73. 73.        }

复制代码

: Z# ?+ o- v" x) z第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
/ g9 h" A" @. I. g3 i                                                                                                                                                

1. /*
   $ K  r+ d% e( @
2. *********************************************************************************************************
   6 n2 V/ n/ G8 P8 ^' t" ]" q7 O' a
3. *        函 数 名: bsp_SetUartParam
   ' m! k( i! ^! s% \
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   , G+ n" y. ?. C; N5 H
5. *        形    参: Instance   USART_TypeDef类型结构体
   
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   . Z  c" a; f9 u& x
8. *             Mode       发送和接收模式使能
   . e, N' f$ [  H6 H0 g1 S, j3 \2 P
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
      L& f& g. B! _  [2 P" H
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    7 x) ^  u: N/ |3 |8 K' e
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    8 @2 U) D& M6 p$ b% g, n( {7 _! ]0 Y+ x8 j
19.           - 字长    = 8 位
    
20.           - 停止位  = 1 个停止位
      \( d4 K1 p4 Q
21.           - 校验    = 参数Parity
    
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    
25.         UartHandle.Instance        = Instance;
    4 Y5 Y* O+ S- _9 n% y# Y  ~; w7 o
26. 
    ; ~) d& F3 U0 A) L+ W3 o
27.         UartHandle.Init.BaudRate   = BaudRate;
    ; o0 J% U& a" p$ \! _2 Q
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    3 F9 Y/ U* ]$ _6 Z5 p$ B
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    $ F' y3 I) L. U9 t1 G
32.         UartHandle.Init.Mode       = Mode;
    
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    
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;
    
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40.    
    
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    2 N0 |. Z$ ^2 m. T, O
42.         {
    
43.                 Error_Handler(__FILE__, __LINE__);
    , |0 J$ ]+ {$ A- m, T
44.         }
    
45. }

复制代码

( ~- s0 s( [! g8 l) c4 s
函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：
+ k$ Q0 h. @8 u* G5 H
( m* k  z0 n- h

1. /*
   ) J; Y7 Y! H: k2 X6 C8 P
2. *********************************************************************************************************
   " b6 j# y( ~% @' }& a
3. *        函 数 名: RS485_InitTXE
   
4. *        功能说明: 配置RS485发送使能口线 TXE
   6 r; e; p7 j, C* p. ~3 H
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void RS485_InitTXE(void)
   / c9 u& ~! r0 e3 m0 `
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    5 B" [0 X& }) L, M: l
12.         
    / \) v4 z1 l! [' b% U
13.         /* 打开GPIO时钟 */
    % c2 k, c/ i; O" f
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    ( }% x- E8 w) |5 h4 s6 \
15.         
    4 E" Y% l- l: R9 [; B
16.         /* 配置引脚为推挽输出 */
    0 X$ a+ K* }( [
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    0 u$ ]7 }6 O' z3 y
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    ! I3 s2 y! B+ [6 g
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    3 ~7 P  t; |* w4 ]+ {
22. }

复制代码

30.3.4 串口中断服务程序工作流程
5 @* _! O% [& f+ Z* a串口中断服务程序是最核心的部分，主要实现如下三个功能

$ ?! Y6 e- X' L( u5 }# I收到新的数据后，会将数据压入RX_FIFO。
6 E: d6 q6 u9 i% ?+ L. l6 U检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
6 `6 `4 I- B7 E
下面我们分析一下串口中断处理的完整过程。
2 y  d! u! Z0 i% {9 y当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
+ y, @+ j3 ?1 E- G8 j. R6 m
+ j. @" [2 O+ I6 c/ E我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：

1. #if UART1_FIFO_EN == 1
   - h& a$ j& Q3 O6 R5 c; m
2. void USART1_IRQHandler(void)
     W# _1 g% E- p& }, t# q  G) i
3. {
   & m/ W7 q* K/ M7 x: p
4.         UartIRQ(&g_tUart1);
   2 Q! \, H5 f4 y. }9 t& K* G
5. }
   ! n  `1 B9 c8 T1 @# u0 G
6. #endif
   
7. 
   
8. #if UART2_FIFO_EN == 1
   
9. void USART2_IRQHandler(void)
   ( Y- E; h9 Z8 G& F1 |
10. {
    
11.         UartIRQ(&g_tUart2);
    1 q/ p1 n/ ^! A" w3 j
12. }
    
13. #endif
    ( p  p) O: p6 V1 {* k/ j( I$ y% W
14. 
    
15. #if UART3_FIFO_EN == 1
    3 p0 y7 j; G% P. C. }/ N
16. void USART3_IRQHandler(void)
    
17. {
    
18.         UartIRQ(&g_tUart3);
    
19. }
    # p: G3 a' T  f: X$ y# J, ~
20. #endif
    : j0 b" R9 l  L
21. 
    ) \8 a7 ?% L3 S
22. #if UART4_FIFO_EN == 1
    
23. void UART4_IRQHandler(void)
    ( ~- ]; k8 S* p
24. {
    % ~3 q' i1 X! A' X  E8 [
25.         UartIRQ(&g_tUart4);
    
26. }
    ( n% l$ ^$ t9 `) t3 _# W
27. #endif
    : r4 f$ S- h, q0 x+ W2 m9 s# Y
28. 
    
29. #if UART5_FIFO_EN == 1
    
30. void UART5_IRQHandler(void)
    
31. {
    ' J' I$ q* i. x3 D* e- G! s' s; D1 z
32.         UartIRQ(&g_tUart5);
    ) X& ~/ r# k$ t& z: u  b
33. }
    
34. #endif
    9 r: S( Y4 X. K+ }; M1 N
35. 
    
36. #if UART6_FIFO_EN == 1
    ' S) u* E/ T! N% P6 g! w
37. void USART6_IRQHandler(void)
    ' v  ?! c, n1 L8 T& I3 I* `: Z
38. {
    9 c' l" E  e* X8 e( z
39.         UartIRQ(&g_tUart6);
    
40. }
    8 K+ z( ]9 L! @& g. u; T- K
41. #endif
    * L8 y: h6 s. U# y8 X) ~5 V
42. 
    
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    
45. {
    % K" {# ]% x# j, C+ @3 C! i
46.         UartIRQ(&g_tUart7);
    
47. }
    
48. #endif
    
49. 
    
50. #if UART8_FIFO_EN == 1
    
51. void UART8_IRQHandler(void)
    
52. {
      `* ?7 k% O  q# \  f, b
53.         UartIRQ(&g_tUart8);
    
54. }
    0 e, f* o! @  R: N
55. #endif

复制代码

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

6 m1 p; @& @5 j$ w' ?' f; X下面，我们来看看UartIRQ函数的实现代码。
1 m  l" `& U4 `2 f3 L- i$ z/ l- H8 I

1. /*
   4 u. s6 Y) p8 W0 k2 n& f
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   2 g5 l9 t/ F. l7 I. J3 P
7. *********************************************************************************************************
   : e1 f% N" L: V# F+ ~
8. */
   4 b7 r" J% J6 _, I
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    4 u3 \$ S' k- G9 H. I1 `0 X3 k
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    6 F, B- I/ j1 c8 d- k5 F. w" Z' n
14.         
    
15.         /* 处理接收中断  */
    1 c& I/ V  _) |% f
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    - C5 x: [9 R8 Z9 s8 ]! I
17.         {
    8 }9 M% c# I; Y( m5 E- ]
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    + `! c0 j' m! b4 A/ S+ w, S
19.                 uint8_t ch;
    
20. 
    8 C$ P( q7 W* F2 x( ?+ \
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    9 h1 A6 K' ]8 U9 I  ~' I7 Q
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.                 {
    ! j8 m5 s* m6 ?+ R; N; h
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    ; v$ P. e$ G5 n9 `) B6 ?: [
28.                 {
    , e$ i* R. T. |4 ]' A& P/ L& p
29.                         _pUart->usRxCount++;
    
30.                 }
    - E0 {' g3 J3 \. K# U, [
31. 
    / |  t( I& C' M+ z
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    & S, D$ q2 a, C% x2 s+ R% r- O
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    ! `" m6 {3 ~& D. J! `# ^! a
35.                 {
    
36.                         if (_pUart->ReciveNew)
    5 R- ^  q5 e! @. t* ]
37.                         {
    ! a4 R2 W# l* W( W
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    
39.                         }
    8 m) v: C4 x8 @% n# ~/ E
40.                 }
    
41.         }
    ) ^2 i2 \' A7 z$ E) w4 o2 B! H
42. 
    9 p6 d( D5 y7 R" [) h6 K
43.         /* 处理发送缓冲区空中断 */
    0 C" `/ l8 b' e+ P! s* R
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    " [' N! m' l" j8 u* z
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.                 {
    8 l+ N4 x0 Q, w
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    # R* Q# K, i8 E; U
52. 
    
53.                         /* 使能数据发送完毕中断 */
    ' B* \  {# }6 h) m' J4 C3 M
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    5 J/ h; g5 `+ a1 I7 [
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    4 {& H; O7 I! P! q  n
56.                 }
    3 w* M* ]+ \; k6 O8 ?# ?( |& y. ~
57.                 Else  /*　还有数据等待发送 */
    3 R0 a' q$ m5 {# B7 T- D% D
58.                 {
    
59.                         _pUart->Sending = 1;
    
60.                         
    6 s7 j/ i! h8 z% l$ Y, x
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)
    1 L$ }# [1 S; J9 L- {1 G% A
65.                         {
    
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    
68.                         _pUart->usTxCount--;
    
69.                 }
    $ s4 i8 j7 U. z' N) k( }7 _7 k9 L
70. 
    ! P: f. ?: k/ }6 u) A/ n
71.         }
    
72.         /* 数据bit位全部发送完毕的中断 */
    
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    8 P! K- u2 r2 B& U( _
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    
77.                 {
    : A  E2 Z4 d( q* E6 y0 F& U
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    . I9 G# u( e" l# s: s8 m
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    8 }6 s0 L: w0 Q8 {
81. 
    
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    ( }7 C+ G( P' @
83.                         if (_pUart->SendOver)
    
84.                         {
    6 ]* S/ a/ N  U$ m1 \
85.                                 _pUart->SendOver();
    
86.                         }
    
87.                         
    
88.                         _pUart->Sending = 0;
    
89.                 }
    2 E) \& A& k- X, b: Z' V
90.                 else
    
91.                 {
    
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    5 ~) H6 {7 c8 ~& _" z- T& |7 x: |
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    , ]# K( m5 d- E+ m$ U$ f5 u& c
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    0 f6 G; r9 U) ]# j/ c! E0 @/ p5 l
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    + p8 g; f$ T. ?
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    7 z5 `4 \( L9 }0 P
98.                         {
    
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     
104.         
     # F5 B9 k0 q8 ]5 b
105.         /* 清除中断标志 */
     
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     " p; N# B5 H8 O3 F
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     " J1 b$ K- Z- l+ a6 Q7 N0 K! y
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);
     - x7 {; L) P% I9 v6 h& `$ d
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     % `1 n# G) Q' L
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     , T/ P) C6 \; Z: N8 v
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     ' P( J1 x6 I2 [2 W" H0 n
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
. |! C+ G/ h5 G, F5 v- y
  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

  发送数据处理
, u: m. S6 q: D7 @. y9 T+ Z- Y  ]* H发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

# a7 a7 L. F8 k7 x! @  x$ }5 _30.3.5 串口数据发送
, Z8 H2 J! p, w4 w串口数据的发送主要涉及到下面三个函数：

: \' y5 N3 c: S# f

1. /*
   ! R0 h5 G7 A- G# K0 H
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   0 v8 O1 e* P( n8 M, Z
7. *                          _usLen : 数据长度
   . y2 m6 z7 X+ Z# u' a
8. *        返 回 值: 无
   . V; {0 m1 v% X. W6 ^
9. *********************************************************************************************************
   
10. */
      D2 r& o; K" L
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    : i$ c) i) p9 Y. P+ w. Y0 b
12. {
    ! M, |) \8 v4 P7 c" V/ |
13.         UART_T *pUart;
    
14. 
    % ]( t* Q% C9 J; M) _
15.         pUart = ComToUart(_ucPort);
      w/ ~8 U: `+ f" e) w4 i  D
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    ) L4 e) j1 b* n
19.         }
    % e. N$ n. r- L" P8 c$ y) @% B. q
20. 
    
21.         if (pUart->SendBefor != 0)
    , b! d' Y" G. _
22.         {
    4 [( ]0 j9 q" ?2 ]
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    2 G( l% H1 W/ T
24.         }
    ) k( ^# |8 v& e, g; H! k
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    ! k$ y& L& B' G* {9 o
27. }
    
28. 
    ; U" M! F; H! {* |
29. /*
    
30. *********************************************************************************************************
    / c. H9 K8 W6 q$ c7 r  n
31. *        函 数 名: comSendChar
    & C- l: E, ~/ J2 j0 y
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    
36. *********************************************************************************************************
    
37. */
    ! ]. n" d( L' g; t+ h0 H
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    " Q. `, W* R' B6 I# @# ^
39. {
    / v$ l, ?5 X) Q+ \7 s) O; @
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    1 q: T9 K# W. U2 c6 c
42. /*
    ) K( R2 w/ |6 L! [8 B
43. *********************************************************************************************************
    , r0 G- C; E) Z2 @- a9 T# X
44. *        函 数 名: UartSend
    3 `, n; K8 S4 \" c
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    0 B+ n0 P* a" g2 _0 V
46. *        形    参: 无
      q1 y  V2 `0 }0 Z" v$ w8 [1 d% @
47. *        返 回 值: 无
    , i3 @1 O2 _/ {8 Z9 ]' k
48. *********************************************************************************************************
    
49. */
    & B( g  `- t- K2 _  Q0 W1 U2 h
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    / W$ g1 Q. ^; w! a. T1 \8 P
51. {
    2 Y+ s& M7 W  F2 n6 J# a8 R
52.         uint16_t i;
    
53. 
    
54.         for (i = 0; i < _usLen; i++)
    6 v2 o& D+ `: b6 f
55.         {
    ( J. S; L, G% T# g+ ~
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    
57.                 while (1)
    
58.                 {
    % R% g, `* j5 c  C: M! s
59.                         __IO uint16_t usCount;
      b2 y1 m/ L9 M; X2 ?9 |
60. 
    
61.                         DISABLE_INT();
    5 y  z' {4 a1 x( z/ r# Z
62.                         usCount = _pUart->usTxCount;
    0 `3 ?0 U. b! {" b$ f" g
63.                         ENABLE_INT();
    
64. 
    ; A- L( Z8 v% x. }+ s, j! N
65.                         if (usCount < _pUart->usTxBufSize)
    
66.                         {
    
67.                                 break;
    
68.                         }
    7 K1 u; T9 d3 C+ g  O) g9 k
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);
    6 l: {% M) i2 N. q) {" J8 E. O( A) z( i
74.                                 }  
    
75.                         }
    
76.                 }
    
77. 
    
78.                 /* 将新数据填入发送缓冲区 */
    
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    
80. 
    
81.                 DISABLE_INT();
    
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    + g( {6 f% k( D6 ^2 ?6 n6 R$ h: z
83.                 {
    + N% w; I6 l. H% v) T6 B
84.                         _pUart->usTxWrite = 0;
    6 f& t' E! o4 c7 e/ C/ i
85.                 }
    2 K: A5 L: z" E# S) Q  N
86.                 _pUart->usTxCount++;
    ) |) K1 i2 w! z4 D7 e
87.                 ENABLE_INT();
    ( ~" ]2 D2 d% ]8 c
88.         }
    
89. 
    
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

5 p4 C/ o. E( z6 H  {4 h$ g; P+ N函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

: W4 A9 T7 H# T+ O; }0 t' o, U  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
* h$ n$ [$ e7 l9 l* w" I( |  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
7 z( `4 V* v7 g* ^0 b
注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。
3 L* z# T6 O' X. d
5 C; ]- r0 e1 f- i- J8 e; b. ?函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

" O& I' j1 ]8 m* @

1. /*
   
2. *********************************************************************************************************
   0 I6 w/ T: R3 S! F' S
3. *        函 数 名: ComToUart
   
4. *        功能说明: 将COM端口号转换为UART指针
   ( k4 O& h2 E5 {8 A5 {& w6 c
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   / K6 e% s! Q. Z) q3 I9 s6 R
6. *        返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   ' @$ q  B6 h5 j3 e0 i7 j
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   ! X* N$ q& x4 I0 P, o
10. {
    & w* u1 N/ f. i5 Z; x" M5 G
11.         if (_ucPort == COM1)
    7 p- J+ o+ z& [8 U% E( O
12.         {
    ) p" o9 c+ ]( m0 q' p2 E
13.                 #if UART1_FIFO_EN == 1
    9 U% Z3 I8 \. f, h2 {( `- n& ~
14.                         return &g_tUart1;
    
15.                 #else
    
16.                         return 0;
    
17.                 #endif
    3 n& E) M9 i* N" z+ W. S  i
18.         }
    , e2 E3 K$ |3 Y" |" v, u6 b
19.         else if (_ucPort == COM2)
    5 R( S; Q: E/ k/ g9 P
20.         {
    
21.                 #if UART2_FIFO_EN == 1
    - f7 t$ z6 g( g) n1 Z  ~
22.                         return &g_tUart2;
    
23.                 #else
    
24.                         return 0;
    * A( P$ s8 h0 z5 U
25.                 #endif
    4 z7 r  o7 c/ T" p
26.         }
    % T% ^5 k; z8 r" O" ?
27.         else if (_ucPort == COM3)
    # [$ P! f4 y: r* k7 K2 o  \
28.         {
    
29.                 #if UART3_FIFO_EN == 1
    . W, V: @; s+ q' e$ b
30.                         return &g_tUart3;
    4 P5 E7 k* q& H; o; G
31.                 #else
      a, ?! d/ w4 @# e
32.                         return 0;
    ! b" n3 W. a) ]' R. M" `4 g2 [
33.                 #endif
    
34.         }
    
35.         else if (_ucPort == COM4)
    0 U" R) o: M5 v2 V
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    6 v$ n) B, ?6 t7 `" }% W! b
38.                         return &g_tUart4;
    1 w0 A. O1 z6 n3 v  h
39.                 #else
    
40.                         return 0;
    0 ~& x. T( ?1 X! v
41.                 #endif
    
42.         }
    
43.         else if (_ucPort == COM5)
    8 c' Y% M' j: Z" q  g, e5 Y& F
44.         {
    : A0 q, y( b! H: h4 h) R/ b, c+ u
45.                 #if UART5_FIFO_EN == 1
    8 X/ ]9 Q& t7 k6 G! E/ X6 G& i" l' @: Z
46.                         return &g_tUart5;
    
47.                 #else
    5 I! T+ J& [6 X" m
48.                         return 0;
    
49.                 #endif
    1 v% g3 J2 `0 }! }5 x9 v( C# F& |
50.         }
    
51.         else if (_ucPort == COM6)
    
52.         {
    6 \: ?  \9 d: W3 `/ _$ n; l
53.                 #if UART6_FIFO_EN == 1
    5 F4 [! e  {) b" ~2 @( ?/ e
54.                         return &g_tUart6;
    
55.                 #else
    
56.                         return 0;
    
57.                 #endif
    # f" F/ `- K6 Y/ ?5 ^, M
58.         }
    
59.         else if (_ucPort == COM7)
    
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    
62.                         return &g_tUart7;
    
63.                 #else
    - m* r6 l. U' j
64.                         return 0;
    
65.                 #endif
    
66.         }
    " G2 k& W3 P* g* I  `+ x- l
67.         else if (_ucPort == COM8)
    4 j$ T6 V- S( ~( U* ?: L
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    4 p- f8 o* I: {5 }$ @+ O
70.                         return &g_tUart8;
    
71.                 #else
    
72.                         return 0;
    ' X3 t% |( X9 \+ H
73.                 #endif
    7 c) U- A# _: J
74.         }        
    
75.         else
    . U( d) i$ l; W$ J& G' ~
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    
78.                 return 0;
    ; ~0 t6 Z/ f( W9 v" n+ y& L
79.         }
    , m! E3 t- j  M  Y* R: B
80. }

复制代码

0 G/ d* s8 M' \7 s3 P6 g& n) m30.3.6 串口数据接收
下面我们再来看看接收的函数：
/ _5 {% h1 A$ z

1. /*
   
2. *********************************************************************************************************
   2 p7 q' ?  N* Z4 \
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   8 x: z. y' ~, H% Q$ `
6. *                          _pByte: 接收到的数据存放在这个地址
   . }( ]9 J4 X4 Y6 [) _+ y+ N
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   ! l8 E1 |* {# g* o* k
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    7 z* }) Q6 Y  }1 v9 ]2 b
11. {
    $ e' |$ X( Q8 i9 J& B
12.         UART_T *pUart;
    : B' ~+ X/ I$ C! L1 a  r' D
13. 
    8 B7 }5 w- x0 ]+ ]- M
14.         pUart = ComToUart(_ucPort);
    ' Z) M6 F# d$ i* G/ S3 a9 o
15.         if (pUart == 0)
    ) b2 b  ~+ q6 f6 [
16.         {
    * @  u# T, n7 c* I( V2 k8 L
17.                 return 0;
    + Z3 O# B( i1 i1 |: r; \
18.         }
    
19. 
    
20.         return UartGetChar(pUart, _pByte);
      Q# `$ K" p9 a' T  j
21. }
    
22. 
    , y' @6 `$ G, d) G% l6 r1 H
23. /*
    7 l) ?: N3 u! i( h; [) g2 C; c
24. *********************************************************************************************************
    
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    ) R6 F1 n( u6 o& q  n- u; @
27. *        形    参: _pUart : 串口设备
    ) m- R' m5 I( Q# A* H
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    + }$ `0 M+ i) p$ c# {
31. */
    * x7 {$ {9 i# U! |8 a
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    
33. {
    
34.         uint16_t usCount;
    
35. 
    7 {1 w! b# y/ o) e9 V( M
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    % G% J3 i5 o: Y2 q
37.         DISABLE_INT();
    8 x: V# X- L- I; m5 J
38.         usCount = _pUart->usRxCount;
    ( ~) |3 n3 a. B, A% D
39.         ENABLE_INT();
    
40. 
    5 T' j; I  [3 h% J
41.         /* 如果读和写索引相同，则返回0 */
    ' j. e' M: _, h6 M/ v* G
42.         //if (_pUart->usRxRead == usRxWrite)
    - u8 x6 W2 _7 C0 P/ @: g: \
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    
45.                 return 0;
    
46.         }
      _2 X8 L3 [1 W
47.         else
    4 I( z- ~% n- Y1 h/ U8 m, s
48.         {
    
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    % k- B. Q. e8 ]3 m" p
50. 
    2 ]9 _# x9 f5 Y' e6 x- d
51.                 /* 改写FIFO读索引 */
    
52.                 DISABLE_INT();
    
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    4 n7 j2 [+ I( ?5 v: y3 F
55.                         _pUart->usRxRead = 0;
    
56.                 }
    2 _" U4 K2 S( M, `3 J2 E
57.                 _pUart->usRxCount--;
    & V  a- v0 Z. V, }; A: N
58.                 ENABLE_INT();
    
59.                 return 1;
    
60.         }
    7 p: i4 s! ]& B* j5 J% L
61. }

复制代码

6 i3 A/ K. L1 O( o; G4 T3 Z函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
! u% N( Y! J+ J/ a! }  W
注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。
! s4 F. z6 x, `$ W) y4 T5 e
30.3.7 串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

: [" |1 f+ P7 z* Y' p; f- ^我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
# G0 i/ ?* ^% H
  X7 f+ A( c5 C4 c' u实现printf输出到串口，只需要在工程中添加两个函数：
4 P4 o# v" y& _7 t2 [

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   3 `  Y& e$ z6 U6 x# g, {4 Y
7. *********************************************************************************************************
   - n# t% l* G+ I! f' H
8. */
   
9. int fputc(int ch, FILE *f)
   
10. {
    
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    ( @5 {+ G$ `( j3 E
12.         comSendChar(COM1, ch);
    
13.         
    
14.         return ch;
    , A& W- O+ S" Q1 q2 I( O+ q1 x
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    ! `$ F- Z4 I8 d. w, x+ R
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    - T* G2 f+ p: n* h9 r$ [
18.         
    0 b! Z- ^; o, S
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    4 V3 t, n4 e( A$ o" m/ a3 }/ R; o
21.         {}
    : ]& E8 h: _" q. J% {- L! n  O
22.         
    2 {! ~" u$ F; }
23.         return ch;
    0 L, J0 p# f8 I+ l
24. #endif
    
25. }
    
26. 
    
27. /*
    
28. *********************************************************************************************************
    / z, [, m0 i2 p
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    # ?% m/ v' K& U8 y
31. *        形    参: 无
    ( \' d+ T( Y/ H& f. j  N
32. *        返 回 值: 无
    3 R8 \1 x/ @+ M# x$ I+ ~
33. *********************************************************************************************************
    + E, V0 T9 Q" ~- B8 H  O
34. */
    4 L2 a$ l! O3 s( p1 r
35. int fgetc(FILE *f)
    + Y$ L( o9 l; O# G9 W# h
36. {
    ( F; G+ f& q8 L( ]0 k% ~, c0 g
37. 
    : u% t8 _+ Q* ^, p. D: r4 v
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    + o3 ^  x; q6 x' c" B+ K, ?
39.         uint8_t ucData;
    
40. 
    ; V- }0 j: h: a' `
41.         while(comGetChar(COM1, &ucData) == 0);
    % M0 I2 U! ], L7 G- T
42. 
    1 S8 S5 j- p/ z- N, i+ ]1 @
43.         return ucData;
    
44. #else
      K8 Z' D1 Y* q0 @
45.         /* 等待接收到数据 */
      |7 Y2 z9 N, |# m$ z8 `0 j
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    ) y8 E, q/ `6 z' V) M  ?( R  j
47.         {}
    $ @) K  q7 m) H0 b
48. 
    % p* {. I- J& x- t
49.         return (int)USART1->RDR;
    ) B! X2 n' x& I8 i4 {
50. #endif
    + A& w; j% p  O; `" X6 g, O  H
51. }

复制代码

3 r" `, C3 V" j# |1 [8 `6 j* o  z1 kprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。

& Y& `2 m4 o! E! k7 J0 s30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
, W; N$ \) J% I* u- {串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：
$ x" U( W1 [1 J# a6 |
. |& Q: e) s3 [2 p  bsp_InitUart
6 n, y. k9 ]4 {7 g: w- D  comSendBuf
  comSendChar
. }$ `" t( t6 D/ v% h  comGetChar
8 }1 |; N( K8 R3 |30.4.1 函数bsp_InitUart
) z+ N- K$ _# ]: X) u% G0 N函数原型：
9 A: J5 J6 q; U$ O4 U7 zvoid bsp_InitUart(void)
8 d* M% F5 d+ K9 A  H
函数描述：
8 Z! ^$ ^# w9 T+ g* O此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

30.4.2 函数comSendBuf
% w( S4 _% C: N' C* s6 o% Y) N. X函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
- ?* }; c2 Y& M3 l. Z9 n* y
: ~4 G4 T0 t( \1 O4 k7 P
! b0 u/ K& @3 G# m3 h函数描述：
8 V1 q4 F3 Y" f5 }# _, F此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：
. n( ^+ E# L8 v2 E( F  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
' V  {  ?- t* u( w6 O: _' _

- o4 x- M: l! i4 `8 z) h注意事项：
7 q  G: t2 l3 c  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
4 t) c& v+ o3 ]) g4 H, V" s. r

8 k  c; \% Q7 x& G) Y使用举例：
) s2 [# e$ q8 f, ~0 V1 L/ U/ e2 G调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
3 J* }0 C: B$ A3 y
7 v9 J. H( B8 ?' Hconst char buf1[] = "接收到串口命令1\r\n";
$ l# T3 o1 x7 v3 k* ocomSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
# v' T7 h- k+ k$ G
2 f- B5 r2 A6 _, t: Z4 p: K( P8 y
30.4.3 函数comSendChar
: G5 e) d) z# |3 u& U7 |  f函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);
! t6 I6 I( I1 i/ T4 N: J/ v
& M7 k, e, @: j) r; p* Z
# _3 A. N+ Z$ D0 z4 e0 ^9 A( _( X函数描述：
3 d5 U( S' A# l# b2 G- B
此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
! D3 w$ x& B, O  H" l* S
函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucByte是待发送的数据。


注意事项：
  此函数的解读在本章30.3.2小节。

6 ?7 k" l' j5 C
使用举例：
4 V+ z) K' u3 E% K调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
) s1 }( E2 c& ?: u8 {, K比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。
7 r- ]4 {: V: F' a% r4 r
$ k4 i2 c" C. ^8 i, [% |! }1 t% ]8 z6 Q3 @30.4.4 函数comGetChar
函数原型：
- _; q4 r3 ^* b9 t" s; w4 suint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
6 O9 k' T3 V9 j, I7 G7 b

# n7 q% M1 _/ G) x! y, n; O: f1 c函数描述：
- R0 O5 p/ [; X! m/ G7 ~. C  C* s0 D此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

  r3 T4 ?0 i% ~5 m/ e" u函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_pByte用于存放接收到的数据。
  f6 j5 c( N# E) b  返回值，返回0表示无数据, 1 表示读取到有效字节。

0 V7 X8 N# G# E8 C
( f% h; t: [! @  ^注意事项：
: U3 O9 I/ ^, V9 h  L  M8 Y  此函数的解读在本章30.3.6小节。


: z+ e  ]. E! D9 Y0 S5 z; `使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

) a. j' x" {: T$ Q# U比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

, ]9 U. ]) }2 o# h$ p30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：
. \$ L% O; a# ^4 v
  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
2 q- s8 j1 q" [/ |  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define        UART1_FIFO_EN        1
   ! K2 e+ A; a7 w4 H) Z: t( X; q
2. #define        UART2_FIFO_EN        0
   8 h* V: N0 }% P/ j3 `  G' s
3. #define        UART3_FIFO_EN        0
   3 f; F' w3 z+ l* j! W
4. #define        UART4_FIFO_EN        0
   9 L- _' O; k% p) O* r' D9 b$ C* o
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   1 r* d* F8 g' U! u% P! R
7. #define        UART7_FIFO_EN        0
   
8. #define        UART8_FIFO_EN        0
   
9. 
   
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    : G' j, Z! c5 N: Y1 ~& q
11. #if UART1_FIFO_EN == 1
    ; j" D1 y1 T. B2 s/ K
12.         #define UART1_BAUD                        115200
    ; d! w' v  m. H4 L5 |! ~1 f  ~
13.         #define UART1_TX_BUF_SIZE        1*1024
    ' `6 _7 N' S$ \# G
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    ' [5 c; P( w9 @! k3 u
16. 
    $ u8 i. y& ]# m$ Q& i9 Q1 u
17. #if UART2_FIFO_EN == 1
    % ?$ _; Z" Q0 F2 ?; Q# _
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    * m0 }: v# n' j, l* j
22. 
    ' }! C* [9 ~% Y; E6 X
23. #if UART3_FIFO_EN == 1
    ) \  @) D& k) B6 P
24.         #define UART3_BAUD                        9600
    
25.         #define UART3_TX_BUF_SIZE        1*1024
    
26.         #define UART3_RX_BUF_SIZE        1*1024
    / P0 U9 [# b# P) s
27. #endif
    
28. 
    
29. #if UART4_FIFO_EN == 1
    
30.         #define UART4_BAUD                        115200
    : W* G) b. k2 d  N: c0 G
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    
33. #endif
    2 h% E5 G# X/ x3 B9 A/ \
34. 
    
35. #if UART5_FIFO_EN == 1
    
36.         #define UART5_BAUD                        115200
    
37.         #define UART5_TX_BUF_SIZE        1*1024
    $ U$ [$ y+ a! v) t) {& m4 F2 b
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    % c3 _( I2 i1 K
40. 
    
41. #if UART6_FIFO_EN == 1
    8 m1 X. C5 T7 h9 L
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    0 H' k6 s4 T+ ?% L
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    ( L" G% l+ A$ H3 Z
46. 
    
47. #if UART7_FIFO_EN == 1
    - K# j4 x+ C; W' @  g1 A, X  T
48.         #define UART7_BAUD                        115200
    1 G/ z: O$ O% b# q" L
49.         #define UART7_TX_BUF_SIZE        1*1024
    
50.         #define UART7_RX_BUF_SIZE        1*1024
    # u! Y: S! X1 H' e0 |
51. #endif
    ( [+ u) ^% J: O9 _) |/ j
52. 
    + c& E2 o7 k4 o, {" r# R
53. #if UART8_FIFO_EN == 1
    
54.         #define UART8_BAUD                        115200
    8 \: b. S2 S+ U, |- H4 z
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    ; p" E6 s0 C. }5 o( N
57. #endif
    & P3 F; ?( ~8 ?" u# F( R2 ]  z0 C

复制代码

/ |% k9 h' I. C( B& M9 }  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
. J9 }- ]* a* ~2 N  第4步，应用方法看本章节配套例子即可。
% P* |! j0 o3 @: F1 Z8 |7 k8 `
30.6 实验例程设计框架
! p$ i' s6 Q! j- l! r0 Q通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
3 {" y) o" F# T1 p
( K/ d3 d2 _& q* r

. S& ?, ^% L$ f% k  第1阶段，上电启动阶段：

2 t7 j4 x* @- ^+ l( A" M6 v1 z; v这部分在第14章进行了详细说明。
* l# J: }& P' d% _  W4 s( I  第2阶段，进入main函数：

1 R/ b( b+ s3 |. ]/ e: J1 y! j/ N  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

8 u8 Q2 Y' Q- [8 y30.7 实验例程说明（MDK）
配套例子：

; m6 D/ q" ~" ^' F. M% BV7-015_串口和PC机通信（驱动支持8串口FIFO）

$ q6 S, h4 e) [; r实验目的：
; ]% P% \2 W* i学习串口与PC通信。
$ v6 D. Z* T' @, e$ u
+ C4 [. J* ?# |, s/ `* a
实验内容：
' L- }- d. ~( d3 }启动一个自动重装软件定时器，每100ms翻转一次LED2。
1 q! [) j) L; b5 b$ N% y
; C" A$ {. [* v
实验操作：
! J4 f7 b4 ?% U  b( s* G: S串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
; J' b( `9 I0 R7 E% T+ kK1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
; u% ?* ^8 z) M; x6 W8 dK3按键按下，串口打印"按键K3按下"。
: F. z8 {$ }: G+ s% P+ r, c上电后串口打印的信息：

- y5 i5 D& V! y6 {+ d8 e5 ]. L+ g波特率 115200，数据位 8，奇偶校验位无，停止位 1
$ A. Y2 a7 X, N/ h+ J
# w/ w/ k3 c3 S4 `1 G

3 S+ H) J+ v2 {$ S; `8 [
9 z4 C/ g0 }8 q- s; a* u程序设计：

  系统栈大小分配：

* \0 {8 J$ l% _( @# @

; i' @: g4 ?+ G7 g) h2 r5 a  RAM空间用的DTCM：
! p% |+ G3 g. J. }8 K6 G  x

! ~+ r6 m! m& O) I' F, x  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
; H* D! M! M3 @1 J& C+ Q

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

复制代码

  MPU配置和Cache配置：
6 ]5 \/ W# I5 A/ h& Y# E. ?
/ e" [* J" `' V; c. N  {6 d5 u数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
* }0 @8 i, o/ i+ M, V7 B0 q

1. /*
   
2. *********************************************************************************************************
   ' @: O) P; B+ P- F" f1 S
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   4 v7 y4 q# j) H3 ^% [* q3 z
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    & r9 `% _* D$ h. Z3 [) z) m
12. 
    
13.         /* 禁止 MPU */
    5 b+ z$ N) E) N, B6 E, C
14.         HAL_MPU_Disable();
    $ d$ i/ s8 W) z& I/ m9 d
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    # o! i# {( c& t$ @& h
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    " {$ T! e6 Y/ g% V2 G, ?2 N, q
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    9 M. f' f' P8 M$ e* S
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    5 L1 Z3 S, ~: C: _! o! P/ \
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    6 ?# ]' l' g, r; E0 _
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
      Z8 a& g8 s% U% r
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    8 G3 k8 ^9 R; H4 t
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    , M. J" |1 |6 n* @- J6 \2 V" i
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ! z7 @* I# L' `6 p8 C( a- C9 G* c
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ) U, }2 `$ m  u' i; Y% K& U% h7 [! P5 F
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ) v9 d# C* h% L% P
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    & T/ S, O- ?8 y* B# A- d) l3 I0 G
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    3 o6 D5 I+ O7 c1 e. {
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    * _- |! X4 `- D/ Q
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( Z1 O& a$ M% ~5 G& l
44.         
    5 m3 n" @; ?! L6 d9 l. j2 _
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 f9 F4 L6 z( u( d8 n: v
46. 
    
47.         /*使能 MPU */
    7 ?9 e; K# q0 H& g4 H# W8 o
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    4 H: T3 x) O* l1 V+ x
50. 
    # y& U! Z; I) ^  C8 S, l
51. /*
    ) l0 {( a: E6 ?; G# x+ m
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    ' y/ ]: I$ ]0 c- c6 {# R
54. *        功能说明: 使能L1 Cache
    - |  x& F  f+ {2 |% ]
55. *        形    参: 无
    6 g; o. B" \. O6 m( O& T. W9 D1 e9 m! @
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    : b" J$ `) I# ~9 |/ i- `3 w, N
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    + R# `; i& b2 G) S4 a7 {' B
63. 
    0 F+ H. v: e' p% _) n
64.         /* 使能 D-Cache */
    1 p9 A% y4 o! C4 t: W
65.         SCB_EnableDCache();
    " V. ^! A6 _: f6 M2 u" y
66. }

复制代码

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

蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
8 `. ^- i( g. `: n) T( s
7 f% }" ~, x/ o+ C

1. /*
   
2. *********************************************************************************************************
   ' b: j5 Z2 h1 M+ c& W; x% J- [/ z
3. *        函 数 名: bsp_RunPer10ms
   $ e( o' N6 c/ A  N: Z, ^% l& R- q
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   0 w$ e" V! y5 C% G1 }1 N7 z: p# f
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   : B/ n5 {3 O( A, ?+ ^2 w$ |, b
6. *        形    参: 无
   
7. *        返 回 值: 无
   + T# R" G: v6 m
8. *********************************************************************************************************
   
9. */
   . v- ^1 J* k- m' d4 V
10. void bsp_RunPer10ms(void)
    $ m1 u7 q, `+ K! o0 D4 |
11. {
    1 L4 v  a. F0 |2 u# i
12.         bsp_KeyScan10ms();
    % P3 ?. }/ m8 Z3 T& m0 n
13. }

复制代码

/ c, \" G' Q3 B. |: Y  主功能：
% K. N9 x3 ]# {) w
主程序实现如下操作：
$ Z' F: T3 i2 I! o$ ?
  启动一个自动重装软件定时器，每100ms翻转一次LED2。
5 s* _6 M, {( [0 H  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
; ^8 `% y  V  R! e0 ?  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
/ ]) g- x3 a& E) N  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  W' H  a* p7 ]  K1按键按下，串口打印"按键K1按下"。
$ l) j% f& k% ?  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
* ~2 s' e, o2 }- J' b

1. /*
   . F' B+ ]7 r% D0 D, D
2. *********************************************************************************************************
   " I& D0 h$ B# ~; U* ^( I
3. *        函 数 名: main
   ( g, l1 a% O0 O  C
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   + }' ^6 h; W/ ]
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   ; T! F% v% C9 ]! R
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;        
    9 o. U$ j0 _; k2 Z3 b- l; C, F
12.         uint8_t read;
    0 N( o# H* S6 q0 M
13.         const char buf1[] = "接收到串口命令1\r\n";
    2 ~% _: @% `7 j3 J6 Q' Q# I5 C
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    7 `+ L. ]% ?; O4 A3 Y  I
17.         
    1 L) L9 n  ~% U3 \
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    4 Z2 E- u' Z& v. T4 {: V
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    ; N( B2 @  N3 P0 q# t5 C4 a3 f
26.         /* 主程序大循环 */
    
27.         while (1)
    
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    7 V2 ?! U6 p. i( r9 E/ F
30.                 bsp_Idle();               
    
31.                
    8 N3 b0 H# G: M- l3 Q4 S* c
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    1 D  x" j) R: u
36.                         /* 翻转LED2的状态 */
    ; I% |( C0 p* d! u
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    
40.                 /* 接收到的串口命令处理 */
    " L9 x* K2 I8 q: V5 O
41.                 if (comGetChar(COM1, &read))
    5 w( {% d- A. Y
42.                 {
    
43.                         switch (read)
    $ M5 I! Q; l8 v7 f% ^4 {
44.                         {
    0 b5 @1 _0 v8 |. K* D+ Y
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    8 _3 ^4 f( e$ `6 A
48. 
    1 c5 g% T1 ?! a7 B
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    1 k4 K6 v: V5 H0 A1 k
51.                                         break;
    
52. 
    
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    9 v! _+ N0 V7 `) b# `
56. 
    
57.                                 case '4':
    6 `: y4 d  `6 K- S9 p+ W
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    % \. i# A! y3 K7 }
59.                                         break;        
    
60.                                 
    / L7 ?. k' ^* L0 e
61.                                 default:
    
62.                                         break;
    ! }  D% H) U" X5 L' o4 ~
63.                         }
    
64.                 }
    : a7 {6 F3 y2 p
65.                
    . ~% S3 Q' N$ Q/ F9 \
66.                 /* 处理按键事件 */
    " w( y1 d( y8 v7 i. Z
67.                 ucKeyCode = bsp_GetKey();
    ! u: w1 ]+ i- W) b$ D
68.                 if (ucKeyCode > 0)
    * x* B; x5 \( S9 P4 J3 g
69.                 {
    
70.                         /* 有键按下 */
    # p" F" @5 @" J8 R) _
71.                         switch (ucKeyCode)
    
72.                         {
    , @* r8 Y4 g7 H5 ]2 C/ Q$ d. \
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    % U, D( i+ t! E( Z5 V0 D
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    # \$ v9 X! J* j
77.                                 
    & u2 @( ^0 p2 o6 i  R- G  H( j; Y/ C
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    ' s1 r% H- T) o7 F0 R
79.                                         printf("按键K2按下\r\n");
    6 }8 U1 E+ ^9 A& ^2 t
80.                                         bsp_LedToggle(3);                                       
    7 h/ k* L5 O. F  Z" z) x. ?& r
81.                                         break;
    4 e8 K- Y$ g4 O+ n) W
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    1 K$ _4 _2 `# z  W# |
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    + u) z& N# R2 c2 a( z, @
87.                                 
    
88.                                 default:
    5 y% ]/ ^8 r+ N& u8 `# M) Y: D
89.                                         break;
    
90.                         }
    
91.                 }
    0 ]' C+ p1 ?1 T/ I3 v( _
92.         }
    
93. }

复制代码

( U" E3 A7 I2 M; v, e# R+ N' q30.8 实验例程说明（IAR）
/ v; w  f( C1 Y0 _& v* S! A配套例子：
. q* [8 M0 m) l, h/ W2 \# R3 ?
V7-015_串口和PC机通信（驱动支持8串口FIFO）
+ f1 T; L/ \7 u! n; C
6 q+ z3 g2 }! _8 p实验目的：
学习串口与PC通信。
7 T- H6 g6 i. x! ]8 k7 t
1 O' D, ?8 U. V6 E  q3 O% t  L# g
6 C+ D4 m+ K2 m5 `  U& q实验内容：
- B7 w& w, T- w' D. X. ?启动一个自动重装软件定时器，每100ms翻转一次LED2。

* C8 ^+ |" \; ], Y/ |1 q
实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
3 R- f6 k) V: R8 _% e' E/ |串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
* `& v0 p0 a# BK1按键按下，串口打印"按键K1按下"。
( U9 I# J- x- ]/ F$ l' y2 k2 ~K2按键按下，串口打印"按键K2按下"。
* \, W* d: A  IK3按键按下，串口打印"按键K3按下"。
$ }" i3 A- |. A, y; D5 K8 ^% A上电后串口打印的信息：

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

# J) Y5 [% }& q
* k3 p% Y; X) z  l6 J程序设计：

4 w8 A$ W9 x+ d! b; v   系统栈大小分配：
4 D/ b; O* q0 g- W+ E5 p

9 i" \/ }$ P6 Y, p   RAM空间用的DTCM：
# X0 i/ D$ t! U8 J- b7 g" Y
- F4 I7 N/ h* u6 n1 q) S9 R

. `; F1 C' ^5 r8 l1 T1 [  硬件外设初始化
1 \; u' m& j+ a5 u# _& }
* U! f: T/ b' I3 q0 g& j硬件外设的初始化是在 bsp.c 文件实现：

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

复制代码

  MPU配置和Cache配置：

# y( D  k) X. W' l# k数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   " y  e) ]$ {9 b0 D
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   + T2 H# N+ _3 P) A7 C
4. *        功能说明: 配置MPU
   ; I4 K( ]- G& V$ V
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   - V8 n. O; T) |  `6 V
9. static void MPU_Config( void )
   ' S- C  Y4 w1 |! f
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    3 y- h- K9 T# _+ z( t
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ) {; H, }6 D( V0 \7 J5 v
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' g8 X7 `% p1 l* v0 {% k
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    # G& R* ~3 U8 `. e" L
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    8 d- P/ f( m. R
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    3 J- v$ i/ K2 x+ {0 }0 z
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    7 k8 }8 W* w$ ?9 L  o
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    * o% p5 E+ R: }! j3 w$ w
28. 
    5 A5 j% A& [7 }7 D; g
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    7 v* m- W# Q' a
30.         
    
31.         
    ( Q8 A8 Z( L" r+ K
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 E) m& x$ q8 F6 W- h: U+ h5 _
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    . ]& k, h  |" M1 E" J0 o
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;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    3 h( h) v; c2 A: {
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    / G: V5 c' B9 Q& H0 u/ Z5 o
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    + r1 }" U5 d( n: r( j
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    5 I: s+ ^) [0 v- X
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    / D6 X5 B8 g; l6 n  Q
46. 
      f! v  H3 j7 o/ `& i+ r
47.         /*使能 MPU */
    - [1 n- @& G+ y  w0 k. {, `" G
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    % K$ `/ _: Q9 d& h2 E$ N5 T
49. }
    
50. 
    
51. /*
    - ~" A6 B8 o2 t
52. *********************************************************************************************************
    8 {: \5 {  @+ U' V( G# e) V
53. *        函 数 名: CPU_CACHE_Enable
    # G  c( a+ ]& `
54. *        功能说明: 使能L1 Cache
    . y% ^$ H: W$ S) [  q; M* V# @, a
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    1 C6 O! M0 V5 S0 P
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    ! o% R8 J1 e; Y2 k) ?1 G
63. 
    
64.         /* 使能 D-Cache */
    " C0 q. N3 O" a. k% f; Y6 C! w
65.         SCB_EnableDCache();
    
66. }
    ! Y. E  |; ]8 S) [2 _+ c  v
67.   每10ms调用一次蜂鸣器处理：
    , }- @. V# V* j4 s! @' K
68. 
    * X% V% s$ [+ u, R* v4 Q! ?# S
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    6 x  D; o' a$ V* G* h9 A% n
70. 
    
71. /*
    
72. *********************************************************************************************************
    ; c* _# }1 e, s0 b6 S
73. *        函 数 名: bsp_RunPer10ms
    
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    - _0 D* R/ o2 T
79. */
    
80. void bsp_RunPer10ms(void)
    
81. {
    
82.         bsp_KeyScan10ms();
    2 T+ D8 Q$ e" C( s# Q
83. }

复制代码

  主功能：
3 j( e- z9 Z, N
5 h6 Q( R1 @1 @5 w( n- A3 |主程序实现如下操作：

% q+ z' |! [7 Y0 ^  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
; Y3 H1 F7 q6 d  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
/ I, a# ^0 i) u$ _/ E  L6 ~  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  H/ h& O' ^1 M  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
6 b) `0 _# {5 t% [

1. /*
   
2. *********************************************************************************************************
   ' A7 p) Y$ s9 o- n6 z9 b
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   - ^! H/ H$ l" f
6. *        返 回 值: 错误代码(无需处理)
   & c! k4 w; y4 C" ?
7. *********************************************************************************************************
   
8. */
   5 {- E+ u+ {# O$ \& w6 v# c2 W
9. int main(void)
   0 Q' a9 `/ R  \6 |) }" ^
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    - {. M5 S. f8 u  D- q# ?' A
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    $ `% |' {1 u7 {: p8 M0 _1 @- s! B
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    ! w: ^1 y& i: y
20.         
    3 l0 G* O( M- ~, b
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    , d& w! W3 E, P
22.         PrintfHelp();        /* 打印操作提示 */
    " a4 N) U/ J" L: x/ O
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    7 g) ?8 {! x$ w. @9 b
27.         while (1)
    " u5 s. p4 O0 q) Q
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    + n: y. D4 V" l8 R( L+ O3 n
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    $ \' l; K4 P0 U' B$ e4 t/ r
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    & s5 y8 M+ T3 F9 K5 Q2 A
38.                 }
    
39.                
    ) t! n7 B; @8 E& `5 J& U
40.                 /* 接收到的串口命令处理 */
    : _6 r, ?% h# F. c: `' |
41.                 if (comGetChar(COM1, &read))
    ; h$ ]; [% K+ @
42.                 {
    
43.                         switch (read)
    
44.                         {
    
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    $ ]! [5 j( I& [' k
47.                                         break;
    
48. 
    + X' M+ c% O2 L0 u0 D. d' ~$ C3 j5 U
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    ' s- R4 Z/ c9 e6 w8 {1 ], }
52. 
    
53.                                 case '3':
    2 h  X8 }7 i7 F* y- o
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    
56. 
    ( E  \, h$ B4 V6 W
57.                                 case '4':
    : Q2 Z: a) h( s( R2 [9 m3 J
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    . n- B) J. k$ A4 y5 W
60.                                 
    
61.                                 default:
    " A  g2 o' w% a
62.                                         break;
    , ^/ R- h5 ~# b
63.                         }
    / Y1 ]/ x5 w# q
64.                 }
    
65.                
    8 N/ C7 H- K, L
66.                 /* 处理按键事件 */
    ) j0 F2 P% c: E2 \  P  B3 V( R' h
67.                 ucKeyCode = bsp_GetKey();
    2 D7 C4 Q# V: V2 @, p5 K4 b
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    
72.                         {
    * Z! F" E% d% z
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    / J8 x! |. C" t
74.                                         printf("按键K1按下\r\n");
    2 W# }% f. {( D, L
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    9 x6 X5 d4 y! P) b3 s
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    3 \* k0 l" `+ H
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    2 k/ e, W" |$ O2 k. O. X. T# N, ?
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    4 G% ~8 ]& h7 d& J2 E
84.                                         printf("按键K3按下\r\n");        
    ; Z5 q7 G2 \; S7 t9 u4 F
85.                                         bsp_LedToggle(4);        
    & y6 r$ ~. [& a  |* Y
86.                                         break;                                
    
87.                                 
    9 M4 J, x+ k% L" ]9 a
88.                                 default:
    
89.                                         break;
    
90.                         }
    
91.                 }
    
92.         }
    
93. }

复制代码

30.9 总结
( O" A/ @9 @/ ?( L) C: ^0 |本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。

2 j$ r0 b7 x6 W, }0 D* B


' l' y/ P4 }- M0 J
: f. D- o# j8 g* d- R3 K. {