30.1 初学者重要提示
0 o3 @1 l+ U3 t2 X2 G学习本章节前，务必优先学习第29章。
串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
2 n2 b4 J1 z: n$ j8 m, K本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
5 f( E: ]' j% J, F" H( V6 w  c大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
! P/ f. v4 p3 z, n/ V, o& L! v+ Q0 QCH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
' g7 _9 u* I* r; W' V5 Q0 t8 W30.2 硬件设计
STM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：

串口USART1  TX = PA9，   RX = PA10
( Z  E0 x  b5 O: l; a
串口USART2  TX = PA2，   RX = PA3
6 m: k0 M, N3 k7 F& o9 H$ ]
- z1 l( g1 Y) g1 ]串口USART3  TX = PB10，  RX = PB11

串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
. U1 _( D7 I" c
串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
( W) b/ S6 \: D+ g$ S( Q7 V
1 @! ^) w0 e. t8 y' x串口USART6  TX = PG14，  RX = PC7
( n+ _8 K; H$ W5 m  f
: A2 h: C6 _/ U: H1 t1 Q3 {串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）

: B+ l% {9 e. Z8 [) C6 ~# ?串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）

/ \, \4 D7 ^% m  p: Q) tSTM32-V7开发板使用了4个串口设备。
$ {0 k1 A0 p& {/ [8 b7 ~
: Q+ t; J" G5 V串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
串口2用于GPS
4 D( W/ H& v2 L串口3用于RS485接口
" t9 j* Z  D( @5 [' Y- G4 E9 c串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

关于232的PHY芯片SP3232E要注意以下几个问题：
, B6 j( ^  w; t5 T/ H+ e
SP3232E的作用是TTL电平转RS232电平。
电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。
5 ~9 s2 `* ~2 S+ N' F
7 k8 w" R4 T2 b9 s) b+ T' ~9 s

实际效果如下：
( x3 B4 G. Z/ ?6 E3 Y

, E' G# I5 d4 Y4 z& a
通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。
; D# e" v4 J% _+ [( J
3 n  A$ j) \' F8 D% Q3 _由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
7 K7 d8 h) T, _: @, h检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。

/ x. Z7 l" X- @5 h" q7 |4 E30.3 串口FIFO驱动设计
30.3.1 串口FIFO框架
为了方便大家理解，先来看下串口FIFO的实现框图：
8 A8 r& [4 i# ^

0 `  I+ w2 I& J5 f  D0 ]7 a- ^
7 E9 t  o# ]8 x0 C第1阶段，初始化：

& U2 Y$ l/ m( v1 N! H/ d通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
第2阶段，串口中断服务程序：

接收中断是一直开启的。
做了发送空中断和发送完成中断的消息处理。
9 b7 s# c  z$ P& f, \第3阶段，串口数据的收发：

8 z' a7 s( K! T4 C% P  y串口发送函数会开启发送空中断。
串口接收中断接收到函数后，可以使用函数comGetChar获取数据。
& g- U2 c, U. E8 U
. k7 U, ^. l$ W' r  N/ r30.3.2 串口FIFO之相关的变量定义
串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。
/ g" S& G/ ]8 H+ N
0 `( f' {, I( w" {5 \: `  l这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。

) p7 C" y3 J# b% j每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
& L, ~; S  B0 p3 O7 M' p/ j
我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

- z8 l* K7 F! {- u$ m& J

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   5 O8 M$ U0 ?* u) z- p' }- ~
2. #if UART1_FIFO_EN == 1
   
3. #define UART1_BAUD                        115200
   4 e3 {' g+ O0 C9 G2 \
4. #define UART1_TX_BUF_SIZE        1*1024
   / I) U4 u3 p5 s$ Z7 m
5. #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   $ @+ l9 t* s, D: c1 ?
7. 
   ! D3 V9 ^& G% y
8. /* 串口设备结构体 */
   : Y0 D' E7 p% ?7 ?' |( D
9. typedef struct
   / I0 P- H! ]- q; r! N
10. {
    
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
    
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    & ~# w+ i5 P2 l) q% I8 \( X- ^8 \
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    / @  r8 |. `: D8 @
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    % C( J/ d2 J- u  j  L: X
23. 
    
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    9 P+ R8 z4 b/ e6 d" A
27. uint8_t Sending;                        /* 正在发送中 */
    ; h7 T( m' A3 B
28. }UART_T;

复制代码

2 p; e6 x/ o2 R& R* i+ y( g" fbsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。

5 \+ {9 M4 J7 n; \$ Y& d4 a

1. /* 定义每个串口结构体变量 */
   3 o9 J- }0 x/ R! N( u' _. V
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   # U1 W" t- O1 w" b; @  L5 Y- a
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   
6. #endif

复制代码

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

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

1. /*
   
2. 
   ) `3 w% f, [$ u' F) @2 K$ |
3. ---
   , K& n. e4 R5 h- g1 t
4. 
   , P- v3 a# P/ F) N
5. * 函 数 名: bsp_InitUart
   
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   
7. * 形    参: 无
   
8. * 返 回 值: 无
   
9. 
   
10. ---
    + b7 {$ F+ }$ i9 m* {* u
11. 
    
12. */
    
13. void bsp_InitUart(void)
    
14. {
    
15. 
    
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    
17. 
    
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
19. 
    9 l  I9 B4 X0 I  l# Y7 u# I
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    
21. }
    ; ]+ m% Q! y8 d: M/ h

复制代码

, K( f. M, i/ l% c( [" `下面将初始化代码实现的功能依次为大家做个说明。

函数UartVarInit
) a5 y+ ^% S6 q) E  g, J. H这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
$ L* G' @' r0 g5 A5 L

1. /*
   ; \7 M# ~) b: G8 e" x
2. 
   
3. ---
   ( v# J" y* x& a
4. 
   $ R: r, c1 t( w+ y8 K) ]3 v9 m/ i
5. * 函 数 名: UartVarInit
   7 D5 C) B3 ?: h$ T1 c7 A
6. * 功能说明: 初始化串口相关的变量
   1 d* P+ O2 l, w  p4 v
7. * 形    参: 无
   ) _3 X( U1 r0 A3 d, s
8. * 返 回 值: 无
   , F) `; Z0 F) h9 j% h) A
9. 
   ( M: {  Y* A, U! ]
10. ---
    5 Z: P  }+ u6 f: h
11. 
    8 e6 G9 t+ G% v% O& Y$ ^
12. */
    
13. static void UartVarInit(void)
    7 s5 T/ ~+ J# }8 i% _& P5 k: T& {
14. {
    & F* q% f) h  _) ?* B  w* h) a7 m, n  L
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    3 E0 U, B0 d) j5 p
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读索引 */
    ; m# U" q( e, m# w
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
    
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    
31. #endif
    
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

& X* w7 Y$ |& F, J. I3 H7 q# m函数InitHardUart
此函数主要用于串口的GPIO，中断和相关参数的配置。
% g/ p! j. W, F7 m( {

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   0 Y- D% v/ z5 H. D; ^
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   
3. 3.        
   - |) M  W% r" H$ R  X$ Z& p
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   5 e8 s8 e$ c1 n( v1 O9 A
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   ; @2 Q( }; V% S' O, E4 a- F1 M$ U% `/ V2 z
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   3 J" q8 C) j" l* \' |* k4 D0 E
8. 8.        
   
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    ' w7 N2 f2 ?/ Z+ |; j% o- i7 \
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
      O* m+ c* [" o9 |  Z
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    1 r7 D4 E" d$ [: Q' S# ]  V0 o- c
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    
15. 15.        
    4 p. P: K/ L" C% |  ]4 S5 m
16. 16.        /*
    & W% }0 J6 |( h# V' z; [7 y: `+ ?
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    . |# g8 w$ p9 `& H  @2 G4 S4 T
20. 20.        *              发板
    # G- w& ~1 G) u6 ^' M. C5 ~5 s
21. 21.        *        形    参: 无
    
22. 22.        *        返 回 值: 无
    
23. 23.        ******************************************************************************************************
    
24. 24.        */
    
25. 25.        static void InitHardUart(void)
    3 r1 B* x- E* F6 s; a
26. 26.        {
    
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
29. 29.               
    
30. 30.                /*
    1 ]" ~& h3 y) G* z& P
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    ; W8 f5 J8 u  v! S4 b! ~# I& O' |9 i
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    * T* H6 a  c$ n2 {
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    ! _! M4 v$ E6 I4 U$ C0 L
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    7 X+ w' U3 @0 J0 U) T
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    * |. ?+ ~- c6 T( _( J* i- |
38. 38.        
    ' L9 V3 [+ M4 }" ^3 G- `
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    9 v) I3 n5 g5 |9 V) A0 Y
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    & x2 X$ r; Q  m1 K* y/ s9 `
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    , X  @7 J: ?$ z) w5 i$ @+ a9 }6 ?
43. 43.               
    " e+ Z7 K9 I2 m9 m. R% C
44. 44.                /* 使能 USARTx 时钟 */
    . g% `/ U& T0 y$ T
45. 45.                USART1_CLK_ENABLE();        
    + b, A6 T$ W& b$ F
46. 46.        
    
47. 47.                /* 配置TX引脚 */
    # O" W0 V, B$ O2 h$ B
48. 48.                GPIO_InitStruct.Pin       = USART1_TX_PIN;
    - l5 t  o& q' J$ V
49. 49.                GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
      t+ z/ h) V& j+ e, t$ _7 `) z
50. 50.                GPIO_InitStruct.Pull      = GPIO_PULLUP;
    ' a2 e2 ]9 Z- D6 v* K$ F8 ]
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    , ]+ c# c2 Y! O1 X. ^
59. 59.        
    
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    + N; B/ ~4 F* h
63. 63.         
    
64. 64.                /* 配置波特率、奇偶校验 */
    
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    + F2 u7 T! T' Q7 L1 u  N' P
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    & O$ s+ o; i5 Y$ N# A
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    * Q5 }3 x* b* ~
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
    
71. 71.        #endif
    
72. 72.        /* 串口2-8的初始化省略未写 */
      Z# s8 t- k# s4 ]
73. 73.        }

复制代码

第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
/ d% Y6 n2 I6 d                                                                                                                                                
! a, N. o- u- I* X6 c8 n9 `

1. /*
   
2. *********************************************************************************************************
   5 m1 E0 T8 A5 T# ]  I
3. *        函 数 名: bsp_SetUartParam
   
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   , p! F6 ^+ |( H8 c, G0 a' z% P
5. *        形    参: Instance   USART_TypeDef类型结构体
   - B+ z6 q" H, `) O' g* c
6. *             BaudRate   波特率
   ( @1 M* O, d! w4 }% P
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   8 u1 K  f8 w9 J4 D/ s+ ]: A% ?
9. *        返 回 值: 无
   3 O* r! u8 v1 i' b! Y9 p
10. *********************************************************************************************************
    ( w( L$ K* @4 A8 n9 R3 R0 g
11. */
    
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    % G/ @2 m. U3 A: {0 t  x
13. {
    % x3 D; c$ F6 Y- ^* N) i- Z+ V
14.         UART_HandleTypeDef UartHandle;        
    
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    
19.           - 字长    = 8 位
    7 R" b7 K; |' O/ Q& J  w
20.           - 停止位  = 1 个停止位
    : F& b, H7 o+ I) M; N
21.           - 校验    = 参数Parity
      g% X2 i0 E% c
22.           - 波特率  = 参数BaudRate
    . K3 Q' }4 K. V# {9 G8 U
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    ( n! i5 O2 B- E6 @8 e
24. 
    
25.         UartHandle.Instance        = Instance;
      J% b% O8 u6 m, ?; a6 V$ j
26. 
    0 p8 E- _7 b! j0 c# M
27.         UartHandle.Init.BaudRate   = BaudRate;
    
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
30.         UartHandle.Init.Parity     = Parity;
    
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
32.         UartHandle.Init.Mode       = Mode;
    8 P* u( I. u0 P8 S- b
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    5 c' P3 C( N, N! g- N/ h" }: i4 O
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;
    * U5 z2 }$ o; a* m' |0 A
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    3 t) c4 R6 t( C- }
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    ' R% K! y9 r3 s# N1 j
40.    
    1 K8 ]. f. z5 _: W* O
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
42.         {
    
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    
45. }

复制代码

) V( E' l' r  g" k5 W1 C/ f4 }8 p
函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：

1. /*
   # S" d8 {7 a: p  b7 O8 }& f
2. *********************************************************************************************************
   2 C% T6 n' P+ W5 J* |7 R$ C
3. *        函 数 名: RS485_InitTXE
   
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   5 [9 b2 l. M5 Y* F4 V0 [! G
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void RS485_InitTXE(void)
   , F, b$ u+ f! n, ~$ e
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    $ B# H" ?5 c! i" q/ v  M: l8 Q
12.         
    
13.         /* 打开GPIO时钟 */
    ! u* a# C/ O% }- A) u! q- U. p2 D
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    
15.         
    ) a6 A$ K6 z% q4 V
16.         /* 配置引脚为推挽输出 */
    : }6 S# c$ A9 E) D
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    3 h6 S( p( @2 v. s  y: }! Z5 W4 C  G
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    ; T+ a- B: [' N0 b$ d1 R
20.         gpio_init.Pin = RS485_TXEN_PIN;
    0 t- M6 Z* D1 e- F. l) F6 y7 U, V/ Y
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    9 r+ {& |4 L) W: ?
22. }

复制代码

30.3.4 串口中断服务程序工作流程
9 s3 g/ a0 @* Y- d9 V串口中断服务程序是最核心的部分，主要实现如下三个功能
/ A/ |$ y4 }7 _5 @0 _# a1 \
收到新的数据后，会将数据压入RX_FIFO。
检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
1 }3 `1 `* B0 v! d3 j) y, ~9 `0 {如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
0 V7 m( x8 ^- D! `& U8 k( o
, C4 A/ Z0 m# |- C2 |下面我们分析一下串口中断处理的完整过程。
当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

7 t8 M. Z( n- c7 m3 K  j. o2 C我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：
$ W) r5 T% {  g% ~$ X8 `

1. #if UART1_FIFO_EN == 1
   
2. void USART1_IRQHandler(void)
   
3. {
   
4.         UartIRQ(&g_tUart1);
   ( }. P' B4 q# J- R
5. }
   
6. #endif
   : w/ O# N8 L; G9 w
7. 
   
8. #if UART2_FIFO_EN == 1
   4 L3 F/ k6 e5 \' Y. |) ?3 M
9. void USART2_IRQHandler(void)
   
10. {
    
11.         UartIRQ(&g_tUart2);
      @" D/ H; l0 \
12. }
    1 a0 \* @9 o; k, x% i
13. #endif
    ! q/ W5 o0 [( d/ d
14. 
    4 O  \$ n! `- A  C
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    
17. {
    
18.         UartIRQ(&g_tUart3);
    
19. }
    
20. #endif
    
21. 
    
22. #if UART4_FIFO_EN == 1
    
23. void UART4_IRQHandler(void)
    
24. {
    
25.         UartIRQ(&g_tUart4);
    
26. }
    
27. #endif
    ) V$ m/ @: J2 O
28. 
    7 c" ^, ?7 V+ [8 n. a0 U
29. #if UART5_FIFO_EN == 1
    7 U  Y! G5 G( r5 f$ |
30. void UART5_IRQHandler(void)
    
31. {
    ; B0 R( V! O6 I8 ]
32.         UartIRQ(&g_tUart5);
    & ], B( d& u! z2 u/ G
33. }
    + j1 X! A$ M9 h6 _, X( t
34. #endif
    
35. 
    & r2 Q& h+ x0 \- o# B  ?' a
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    
38. {
    $ m( c& F* A) E4 L- O1 ]4 ~6 ]
39.         UartIRQ(&g_tUart6);
    
40. }
    
41. #endif
    
42. 
    
43. #if UART7_FIFO_EN == 1
    / I  v3 i: r' t: e7 K
44. void UART7_IRQHandler(void)
    9 j: v/ f! W& i* `
45. {
    4 g# n1 d, l% \4 ]1 ]& E1 @0 v
46.         UartIRQ(&g_tUart7);
    ' @- }$ i5 d3 n0 b, A
47. }
    ' r, m+ q5 r& Y0 j( ^7 s) q7 c
48. #endif
    , Y& ^& u- ]7 ?0 [* Q8 ], r+ F
49. 
    
50. #if UART8_FIFO_EN == 1
    
51. void UART8_IRQHandler(void)
    ; T8 {' }9 [" c
52. {
    
53.         UartIRQ(&g_tUart8);
    : v" k. Z& f$ F8 S1 T' G! I3 F
54. }
    
55. #endif

复制代码

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

! T5 q1 u' V, j2 w1 Q下面，我们来看看UartIRQ函数的实现代码。

; h% c2 e: C0 V- W

1. /*
   7 F, `; T* m2 m; x$ x7 c8 r2 K: ~
2. *********************************************************************************************************
   + B* ^, e6 N' q4 Y# v) w  l
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   
6. *        返 回 值: 无
   6 P% `$ h2 o+ ]& J) W5 H' _
7. *********************************************************************************************************
   - U$ @' z7 Z" }" u8 W- n
8. */
   : e) {+ ?, f( @: |4 c+ I& B& T) n
9. static void UartIRQ(UART_T *_pUart)
   " |4 }! N  j6 _- \+ A
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    3 g) B* C; i6 S. O: p
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    ' I- z0 E! x5 ~. n
14.         
    
15.         /* 处理接收中断  */
    9 r  P) m  R  _/ Z
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    / C7 C5 D* o7 I/ g& I
17.         {
    
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    ( @; w6 V( S" Y$ \  ?) X6 P% f, J
19.                 uint8_t ch;
    ! v$ g# G3 V. ~
20. 
    9 D. h" h4 ^) W+ H( D+ w# A
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    : H# ^$ w- r% d7 Z/ x; B
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    . z% I% H9 H  s, {7 B% l
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    8 Y" B$ G$ K1 @: M+ Y' n
24.                 {
    0 A( p" W) N( d# I4 l1 B% i$ z
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    ) V( K! n" g" G& R; C& U& O
28.                 {
    
29.                         _pUart->usRxCount++;
    ( V0 v# [8 W; V4 T
30.                 }
    & u& }) D: ^- F9 B" i9 @
31. 
    9 Z' ?* t) W& D% r3 B
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    
36.                         if (_pUart->ReciveNew)
    
37.                         {
    * w7 {6 `) z# I
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    8 q( ?- I- e) {9 q+ g
39.                         }
    
40.                 }
    : _3 G. a$ m( q0 z
41.         }
    
42. 
    
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    7 z& s" s/ i, D9 d* F  F# p, }
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    * j% t2 p$ A4 y# O0 u) i
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    ) |0 _% m" {& X2 b* K6 `" K- w$ p
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    2 C& L: ^/ ~2 t9 H+ v1 O: g8 }
52. 
    : s7 y1 X. N' c3 y  Y4 `" ?! Z
53.                         /* 使能数据发送完毕中断 */
    9 y$ w7 f9 p" g. L1 R# l
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.                 }
    " B% v& a' ?) x
57.                 Else  /*　还有数据等待发送 */
    ' i: D. V+ ^. l% P3 C& f" ?( ^
58.                 {
    . r+ k' a. C' B& z' ?. {' C2 v$ |
59.                         _pUart->Sending = 1;
    / B" r7 ^9 ^$ u  s
60.                         
    ! `' d+ G3 G# S; G+ d: s0 H/ h
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    5 k" y: h0 R# U2 B7 o
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    . L" q, |% f7 p
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    
66.                                 _pUart->usTxRead = 0;
    1 f: Q! [! K+ A9 s/ P2 {
67.                         }
    
68.                         _pUart->usTxCount--;
    % V$ ?7 U" M. k
69.                 }
    $ k7 l' T2 \0 j, _) T! ]' ]# R
70. 
    8 G4 m9 n: F! R( j+ N
71.         }
    
72.         /* 数据bit位全部发送完毕的中断 */
    3 H. h( A' R" X2 G# S
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    : m& a) ]5 O( M7 K; Q
74.         {
    
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
76.                 if (_pUart->usTxCount == 0)
    5 w8 e: S+ ^. R2 O6 `
77.                 {
    . o4 f, P+ {% |2 L! X: {
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    . p- C$ W- }' {
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    0 O! D, l/ m( s3 ~/ V: I
81. 
    2 K7 F& @' e9 }3 ~1 ~0 D6 m
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    
83.                         if (_pUart->SendOver)
    
84.                         {
    
85.                                 _pUart->SendOver();
    
86.                         }
    
87.                         
    
88.                         _pUart->Sending = 0;
    
89.                 }
    
90.                 else
    2 g* M7 E5 @6 U
91.                 {
    3 @  Q5 y$ Q+ i( U! Q, b; O
92.                         /* 正常情况下，不会进入此分支 */
    : M$ w: z2 e6 B% O7 V
93. 
    
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    ' T/ c! b8 K, a( G
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    ! e1 p* ^  _+ W9 a, ]; S, c
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.                         {
    4 m% Q% f1 e1 c  Z! J; ~/ P# w
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     3 ^& s' k7 Y# X. \" x, w* u6 h
101.                         _pUart->usTxCount--;
     
102.                 }
     ' ~( G4 @0 [, s  W* P
103.         }
     
104.         
     
105.         /* 清除中断标志 */
     2 |5 i$ {3 A/ z7 K) a5 ]" O
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     ! \# F9 f" B3 e5 s
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     4 K4 x3 c9 \( U& ^% m' U- [+ [2 Q
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     
117. }

复制代码

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

* c' u2 v% S0 a& \, d6 H/ |  接收数据处理
+ Z6 m7 D' ^! X& Q: t. i接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
0 {2 P# V$ j: z5 N) E9 Q  B特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

; S/ x" h1 E7 y, Y9 E' M- F/ w  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

30.3.5 串口数据发送
2 Q9 Q4 Z" P" D% Y' Z# w4 n串口数据的发送主要涉及到下面三个函数：
2 m5 d' [" J3 E; u5 v

1. /*
   # |  F5 H1 w5 i; z9 {
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   / z+ F* f+ I. S! L
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   - V. I+ s/ o* f$ \  A4 ?: B5 b
6. *                          _ucaBuf: 待发送的数据缓冲区
   ! n3 j6 g$ A* L: U4 R
7. *                          _usLen : 数据长度
   
8. *        返 回 值: 无
   
9. *********************************************************************************************************
   & y& h2 u1 c( g. f
10. */
    
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    
13.         UART_T *pUart;
    
14. 
    
15.         pUart = ComToUart(_ucPort);
    
16.         if (pUart == 0)
    # ?4 o6 D# B0 u5 ~6 K6 ]7 |( E! K
17.         {
    
18.                 return;
    ; _* j* `" _- F: b% Q
19.         }
    + @+ F: c; P! I3 }% Y- c; z
20. 
    
21.         if (pUart->SendBefor != 0)
    , M7 n5 m* T* H+ y
22.         {
    : k4 A8 C+ L# S7 K* C
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    " {  b6 e6 W1 C. k  k: r' F
24.         }
    
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    
28. 
    . a4 h% T) n( q) m# z
29. /*
    
30. *********************************************************************************************************
    ( S6 @* \" t% j4 j! y+ `
31. *        函 数 名: comSendChar
    
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    5 ^) _# [7 A, N+ O
36. *********************************************************************************************************
    + v: x+ W6 L+ w" u7 i! }
37. */
    ; U  v+ b+ Q4 K7 A
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    
40.         comSendBuf(_ucPort, &_ucByte, 1);
    
41. }
    1 r9 u' W3 `9 ?0 B$ A) t
42. /*
    3 @' [, J. t( `; U' R4 ]+ }
43. *********************************************************************************************************
    5 Q& k4 U/ Z/ Z+ x
44. *        函 数 名: UartSend
    7 O/ w, c7 i0 ~& P
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    , w+ m/ q5 ?1 M( e0 h* L2 L$ m( e# V0 b
46. *        形    参: 无
    5 z% `- j+ E3 d( n
47. *        返 回 值: 无
      q" p& h% E+ f4 o' S! j
48. *********************************************************************************************************
    
49. */
    % v% V8 L) p0 r
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    / V" M( J) K1 w2 x+ z
51. {
      H* A2 o+ E# _3 r
52.         uint16_t i;
    
53. 
    
54.         for (i = 0; i < _usLen; i++)
    ! K' Y# V7 c& U# H
55.         {
    ) ]% U: \: j4 N( n. J
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    4 E6 u5 ~* p7 ~6 P: p( z) E
57.                 while (1)
    
58.                 {
    
59.                         __IO uint16_t usCount;
    
60. 
    % k" g! S4 |9 B/ d/ \
61.                         DISABLE_INT();
    + |, _! ^: V" K0 q# D! ^
62.                         usCount = _pUart->usTxCount;
    3 A' \1 P. L0 O0 r# @& p- S, O
63.                         ENABLE_INT();
    8 L- J6 W4 `# b9 u% u' T
64. 
    ! l, J0 p, U& H/ {& [7 }1 {* y
65.                         if (usCount < _pUart->usTxBufSize)
    3 O/ T  d9 T& k% S8 x
66.                         {
    1 N+ \0 F1 }% }9 D
67.                                 break;
    
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    3 i5 _; ~( N+ A4 q' i
70.                         {
    
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    : R7 h/ q- X, J. ]7 `, B
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    % T2 y. ?+ A! \8 W/ X* Q3 Y
74.                                 }  
    ' N4 a1 N) K: r" h6 \! H
75.                         }
    
76.                 }
    & G: [# q  h1 B3 n0 A
77. 
    
78.                 /* 将新数据填入发送缓冲区 */
    ; i/ K3 g7 P% ~% o2 P" F) `
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    
80. 
    
81.                 DISABLE_INT();
    6 P" N3 n! y8 C8 c3 W
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    ! E  w) G& W6 [
84.                         _pUart->usTxWrite = 0;
    9 Q; A9 }$ u' Y- t- z6 C7 m! c
85.                 }
    ; S  \6 s/ {" ^" V5 W
86.                 _pUart->usTxCount++;
      r1 |1 \' I% d/ A( U* R
87.                 ENABLE_INT();
      ]0 a6 v- w% D9 o0 e
88.         }
    ( t3 T) {: j- q* a+ a. k! _+ f
89. 
    & P9 P" d& j. I, I/ h. s! m+ R* H
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。
8 K7 j, e; ~5 V; I
函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。
7 z, {: d. j+ G) k+ R
注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。

9 f) y" h' d) g0 ]1 Z' x函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。

1. /*
   
2. *********************************************************************************************************
   8 J7 x& x1 T) |( \! y, f- W
3. *        函 数 名: ComToUart
   
4. *        功能说明: 将COM端口号转换为UART指针
   9 T) P! f8 ]: J6 W7 J5 V& b) y" N
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   + a2 G  q" X1 N2 Q# A# Y  Y
6. *        返 回 值: uart指针
   6 Z) o5 Q( s/ \. n2 K/ u
7. *********************************************************************************************************
   
8. */
   ; }* L. {: E( P' g# I7 G, `; x* H. \
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   
10. {
    ) y0 D# w* w  Q* Q8 J  @
11.         if (_ucPort == COM1)
    7 \2 t! [- i. q
12.         {
    ' M; }! D% [% Y' ?( c- A# r$ h/ {
13.                 #if UART1_FIFO_EN == 1
    
14.                         return &g_tUart1;
    ( k1 E- J4 F5 O1 r. X
15.                 #else
    # }( `- ^6 P0 S- b8 B2 q/ N
16.                         return 0;
    
17.                 #endif
    0 O! D1 E8 T& z* O9 L0 O
18.         }
    0 H; v$ ?- M* o
19.         else if (_ucPort == COM2)
    ) E) ?7 I' M: R0 j8 a. ^( {
20.         {
    
21.                 #if UART2_FIFO_EN == 1
    
22.                         return &g_tUart2;
    $ W4 g: V# v$ S' o
23.                 #else
    3 l7 ^  e! c- g/ P# ]3 ?
24.                         return 0;
    . A! \) b6 l7 r+ Q* H; J8 y
25.                 #endif
    
26.         }
    
27.         else if (_ucPort == COM3)
    
28.         {
    % \$ e$ o- D$ f- |' s
29.                 #if UART3_FIFO_EN == 1
    5 ~  J8 v0 r  j$ R- A
30.                         return &g_tUart3;
    3 T% [5 K% N9 v* q! h
31.                 #else
    # j) {6 @( }" e% s
32.                         return 0;
    
33.                 #endif
    6 B6 w5 D$ e* Y! [
34.         }
    5 j6 U) }/ S" @- ?2 C0 D2 i
35.         else if (_ucPort == COM4)
    0 ?5 j8 S% q7 h, d) x; W
36.         {
    9 R4 L0 R' E  [3 ?
37.                 #if UART4_FIFO_EN == 1
    7 Z' W5 t& W. b4 m5 h: D
38.                         return &g_tUart4;
    , e' m1 C- ?3 Z; U  L- d  F
39.                 #else
    
40.                         return 0;
    
41.                 #endif
    6 O1 S/ J  n: B6 B1 F8 g4 |
42.         }
    - M4 R8 k8 Y4 q  e0 m
43.         else if (_ucPort == COM5)
    
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    
46.                         return &g_tUart5;
    
47.                 #else
    
48.                         return 0;
    
49.                 #endif
    7 I' q. m3 L4 I: P
50.         }
    1 F. \' @+ V! N" ?! [- e" F
51.         else if (_ucPort == COM6)
    / r" Y2 `! D) K. m- @" O% _
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    
54.                         return &g_tUart6;
    
55.                 #else
    / p% a. o; f  P  l$ s: y
56.                         return 0;
    
57.                 #endif
    
58.         }
    ( ^% l! E% S* F" h  U
59.         else if (_ucPort == COM7)
    
60.         {
    ; _' o2 A9 x( V/ l: B# J6 C$ p
61.                 #if UART7_FIFO_EN == 1
    ; B$ u- I+ V, e' s0 c+ I$ \
62.                         return &g_tUart7;
    
63.                 #else
    
64.                         return 0;
    * k) p8 S3 L# ^! K! e
65.                 #endif
    6 X. k. r; z8 Y2 ^+ r1 X6 h
66.         }
    , h  w, f3 o  `$ o8 g1 s3 H6 r
67.         else if (_ucPort == COM8)
    ( X: b  z2 e3 [- V& K+ [
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    ( `0 Z3 b! X$ a5 E
70.                         return &g_tUart8;
    - P: {% z. Y" P
71.                 #else
    4 ?( c) F1 U6 k: k( ^  b
72.                         return 0;
    
73.                 #endif
    ( b9 F$ H5 }$ ]( c: Z1 V3 i
74.         }        
    $ ]# Q$ O% Y) N9 T# J
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    
78.                 return 0;
    
79.         }
    
80. }

复制代码

& ^( _: r8 F  e5 w9 n2 \30.3.6 串口数据接收
下面我们再来看看接收的函数：

) C4 Z1 w5 p' q" f- S& t; K

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _pByte: 接收到的数据存放在这个地址
   
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   ' m1 N- G; N% o' ^" i$ D1 F
8. *********************************************************************************************************
   
9. */
   
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    ; o7 H9 [; Z# P8 e, ?
11. {
    
12.         UART_T *pUart;
    . ~* m$ F- z  Y+ t* K
13. 
    
14.         pUart = ComToUart(_ucPort);
    
15.         if (pUart == 0)
    + f: ^) }2 n, L. B) Z5 Y7 u) x
16.         {
    
17.                 return 0;
    
18.         }
    
19. 
    7 c" N5 y- i) m0 u- u7 y
20.         return UartGetChar(pUart, _pByte);
    
21. }
    $ ?$ C. a  |2 O( Q: ^# s  U
22. 
    6 r& O$ A9 Y+ B. m
23. /*
    0 f" b, @& W6 R5 c2 J8 S
24. *********************************************************************************************************
    ! J! @. y7 I! o, {8 U0 q) d
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    0 ^+ s  {9 d8 z& }& K+ g. D) y
28. *                          _pByte : 存放读取数据的指针
    5 @) j) m. @' n9 ^4 V9 P
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    3 u" q* ~; U4 v1 K( j1 l6 y
31. */
    
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    3 g7 i3 ]( }8 ^. o; q  [
33. {
    
34.         uint16_t usCount;
    : y/ o2 V: [; Q
35. 
    
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    3 Y8 F% _4 t% d. X& p# L2 G1 _( G9 f
37.         DISABLE_INT();
    ( g* ^: F0 ?* F
38.         usCount = _pUart->usRxCount;
    ) \- X# T# z% Y, g$ v) n
39.         ENABLE_INT();
    ; t" j9 q6 b5 |$ F6 d. H
40. 
    
41.         /* 如果读和写索引相同，则返回0 */
    " w. Z, e( Z# Q- z$ e7 x: D: N
42.         //if (_pUart->usRxRead == usRxWrite)
    . S- ^. {9 M. ^
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    
45.                 return 0;
    0 U9 J$ {; `* `+ I* `/ o7 D
46.         }
    
47.         else
    8 R/ e0 Q* G& I0 p
48.         {
    $ Y8 E! B- m. c$ d2 ~3 F
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    ) i" f+ v4 X- g  L$ x( F& r
50. 
    
51.                 /* 改写FIFO读索引 */
    ' T1 l+ q" w# q/ @4 k. U" J$ ^
52.                 DISABLE_INT();
    , u% m: _1 N, Z3 B. X5 T4 C
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    
55.                         _pUart->usRxRead = 0;
    * g  i# A7 t6 ^/ ~) F; s
56.                 }
    ) g8 s! A, i6 Z# M# H9 k  S
57.                 _pUart->usRxCount--;
    
58.                 ENABLE_INT();
    
59.                 return 1;
    & d" }  w* @+ [# Z
60.         }
    3 i5 M, W! F" R  |( M; v
61. }

复制代码

函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的空间调整。
0 h; a+ N* q2 k9 P4 h9 Q
注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

30.3.7 串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。
2 ~$ ?, b% ]6 v
为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
) s2 K1 E/ a; ?( H6 F) ], U0 H
实现printf输出到串口，只需要在工程中添加两个函数：

3 r. E) }0 e# S5 r

1. /*
   ) z7 b! D" q4 }2 y6 m$ u0 @5 R
2. *********************************************************************************************************
   2 o* h/ y* O; ~
3. *        函 数 名: fputc
   & i8 H! p/ A$ I% \; j
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ; U8 t% G. Q& B( g& k
9. int fputc(int ch, FILE *f)
   
10. {
    5 L1 r- M6 X) \
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    ) U0 M8 }5 T+ W: v. Y
12.         comSendChar(COM1, ch);
    " x6 l7 l( p3 o/ j3 X4 [0 U
13.         
    
14.         return ch;
    
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    
18.         
    
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    ; t/ R- \( H" B3 h  N/ r
21.         {}
    
22.         
    ' @: c" t/ A2 v, P8 O% d( H& D
23.         return ch;
    
24. #endif
    2 }% d8 g$ `0 H& N
25. }
    
26. 
    
27. /*
    * W! f' N+ A6 l  K. {) X
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    : b1 N- a4 ^2 J' `/ v
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    ; _( U& I: A. n% D
31. *        形    参: 无
    
32. *        返 回 值: 无
    5 V, [: t  T( }6 t  |$ ?
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    # N" _* p! j" ]" g6 k. D" U4 @
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    , b( @' |" j4 S: m4 F" q9 K( N
39.         uint8_t ucData;
    ! N- W8 c+ d8 l. H" z
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    & e$ p( w0 A: N" B9 a0 O
42. 
    ' ?! i% p1 e; \% g9 w
43.         return ucData;
    $ H1 a) L' Z) v) X% Z( \
44. #else
    1 f. z3 \& P' R! w: ?
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    # a- `) `! x) }; h; p7 ]
47.         {}
    
48. 
    * K* c6 m$ I' n* Y
49.         return (int)USART1->RDR;
    ! I# M! e. c% e; w  O
50. #endif
    
51. }

复制代码

3 K( p& A1 W9 M" E% N- Nprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
- b  G2 X9 {9 D5 z: E" |4 \
30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
# U2 b) M' Q! k串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：
, d9 f; y2 M& f& b5 W; F- f* f
  bsp_InitUart
4 e7 v) K$ W- I; a* P  comSendBuf
, r0 {' X+ ]! `& G6 L" \  comSendChar
5 b6 d  ^) W! a2 O: S, n  comGetChar
30.4.1 函数bsp_InitUart
函数原型：
9 W+ c. `! s0 o. n9 x' s# Y* I, Hvoid bsp_InitUart(void)
3 b' e2 L: x& w2 a( d4 T
函数描述：
% k( r' B! k1 O! i  h5 A/ D此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
" _( e# L' N/ M" R1 w2 u
使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
% x  p. r: v; p2 D4 q
30.4.2 函数comSendBuf
% z1 _' ]  U) |! k  ^' P3 ^8 z# c( [7 o函数原型：
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
8 w# _" r, T+ |# ~6 [
0 W. _" ]# x# G) J
" R0 U; t; P  c$ N; V! y( X函数描述：
此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
$ w# [) \- W+ }- a& t0 N3 \. c  第3个参数_usLen是要发送数据的字节数。

; d8 Z8 z. }4 J/ p7 c% `; \
注意事项：
  此函数的解读在本章30.3.5小节。
! I: z0 ^- V2 }/ ]; }5 _  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
5 f1 v* I6 x9 y# Q) A5 C
' B$ m% K# E8 R$ Y& p6 @
* B6 j* ^6 s* H3 w$ D8 M4 J' [使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
2 r& @- k& P/ W8 p' V6 x
$ }6 U* f0 f6 H- n9 Q4 Cconst char buf1[] = "接收到串口命令1\r\n";
comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
' z  E, Y& I: l( J7 C

30.4.3 函数comSendChar
函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);


函数描述：
, X0 }  D' K- u1 \
5 B+ y& p& o3 {, l* ?& K' O, E2 k此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。

+ q3 t5 l! Y- L( _函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucByte是待发送的数据。

7 }8 R+ L4 i& ?+ M/ F! U3 _. T  @
注意事项：
: s! O( [6 H) C& |7 B  此函数的解读在本章30.3.2小节。
3 R9 O. x6 y3 ]' u) \. M+ q

使用举例：
% }" J% d. d2 t$ \- F1 Z调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
6 r. O' K* Y7 z% R% L比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。

% D+ i. R5 ^, ^# a30.4.4 函数comGetChar
3 p7 W& j/ Z3 F4 v函数原型：
/ Q' ^' a* \+ d! {8 A  E' tuint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)

, z6 j' f% V# A( X+ c# x. H# w
函数描述：
此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
4 l$ m- G; I1 B  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。


注意事项：
& Z, Z# Q+ i* V  N8 {$ ^3 D  此函数的解读在本章30.3.6小节。

" K! V) q5 G( t, ]3 K+ m% E- \
使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
8 p2 B  H3 H% O
& D* ^7 Z0 G" c比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

$ [! m' t8 p& f' ]+ r30.5 串口FIFO驱动移植和使用
3 Z% V4 D% l7 c3 |5 j4 ^串口FIFO移植步骤如下：

  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
* Y' g# r- ~' n3 ~% `" w* \  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。
. z/ U+ K: u1 T0 A0 x, b% G

1. #define        UART1_FIFO_EN        1
   
2. #define        UART2_FIFO_EN        0
   ' U- H( _* J" {: Q" C1 t5 `2 ]$ Q
3. #define        UART3_FIFO_EN        0
     D7 L9 E+ t* N2 p" B: {2 e
4. #define        UART4_FIFO_EN        0
   , ]3 s; M6 |; V7 M
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   
7. #define        UART7_FIFO_EN        0
   
8. #define        UART8_FIFO_EN        0
   
9. 
   " ^2 O( `1 G  @
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
      A2 R4 P1 K! m4 v' D4 I
11. #if UART1_FIFO_EN == 1
    8 k' E4 o- W/ P) G/ V- N# o9 ~6 M
12.         #define UART1_BAUD                        115200
    ! I" j. F# {! X$ y3 N
13.         #define UART1_TX_BUF_SIZE        1*1024
    
14.         #define UART1_RX_BUF_SIZE        1*1024
      E9 K5 P* x; p
15. #endif
    / j0 \$ j3 z. O+ Q
16. 
    + T1 C. _' d; c3 h- @0 ^* {  h: T
17. #if UART2_FIFO_EN == 1
    
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    0 W* U2 ?+ R9 g2 v# r+ a' i9 ~
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    
22. 
    
23. #if UART3_FIFO_EN == 1
    + m" T6 ~* A' f
24.         #define UART3_BAUD                        9600
    # h8 n( G1 h4 y
25.         #define UART3_TX_BUF_SIZE        1*1024
    
26.         #define UART3_RX_BUF_SIZE        1*1024
    / i. }9 m. n) R
27. #endif
    9 J* R$ |* z9 E2 J2 F/ _
28. 
    
29. #if UART4_FIFO_EN == 1
    : |/ k4 h4 r" X) `; B% j
30.         #define UART4_BAUD                        115200
    
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    
33. #endif
    
34. 
    
35. #if UART5_FIFO_EN == 1
    6 _6 H( K" c+ p7 d
36.         #define UART5_BAUD                        115200
    & y% u/ B9 l4 b& _/ r9 v7 W
37.         #define UART5_TX_BUF_SIZE        1*1024
    / q/ h7 D( w( d3 v5 S3 Q7 e
38.         #define UART5_RX_BUF_SIZE        1*1024
    
39. #endif
    3 H& A& Z" S) o$ R
40. 
    $ `* J. d. O$ h$ t% @% t: x5 M
41. #if UART6_FIFO_EN == 1
    # W. Y* l+ k$ E! ^9 d" I
42.         #define UART6_BAUD                        115200
    
43.         #define UART6_TX_BUF_SIZE        1*1024
    + j. l2 i; y' c0 e' f' i" L
44.         #define UART6_RX_BUF_SIZE        1*1024
    ) R! w- L4 Z$ B% \# S
45. #endif
    
46. 
    
47. #if UART7_FIFO_EN == 1
    . D9 \! z, n1 ?; U# e' j
48.         #define UART7_BAUD                        115200
    
49.         #define UART7_TX_BUF_SIZE        1*1024
    ! }7 O- p! G4 l  C; g9 ]7 n
50.         #define UART7_RX_BUF_SIZE        1*1024
    $ `  G( N; k1 L& h9 n( Y2 U
51. #endif
    , e( q6 a. M# t+ D9 V/ o
52. 
    0 b- d- O7 y2 [6 j; R. K
53. #if UART8_FIFO_EN == 1
    * E7 |7 _0 F' E, {
54.         #define UART8_BAUD                        115200
    * K! F1 ]" x% e) \# v1 A
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    
57. #endif
    

复制代码

- k* q  a8 B* i- I% [4 s/ a
  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
$ S9 L. P$ ^- k2 @9 s* l7 _3 u
1 n$ R; g0 k8 s( e. Y3 M30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
" u5 X; q0 ^* j6 s& b8 S

% e' m5 \) {& j1 R% ~% m
  第1阶段，上电启动阶段：
2 ~  A; g% }  d' D5 U7 t
这部分在第14章进行了详细说明。
  第2阶段，进入main函数：

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

30.7 实验例程说明（MDK）
2 c2 j3 W9 `* Z$ f配套例子：

V7-015_串口和PC机通信（驱动支持8串口FIFO）

* K. C' A9 [: |+ b$ B6 R3 h: o# g5 C实验目的：
学习串口与PC通信。


实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。


% H. u8 G9 E/ j实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
+ {0 ~$ t+ k9 Z4 ~4 L0 g9 _串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
" c9 l1 `* W+ }" B5 oK1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
+ x6 n* E7 m3 m( t* `K3按键按下，串口打印"按键K3按下"。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
2 T) D0 Q7 q; y0 R: Q* l% m) o/ _

3 b4 ]7 [5 T# Q
程序设计：

  系统栈大小分配：

2 f9 y" ~" K, S+ X! t  RAM空间用的DTCM：
3 o* i) X3 o+ N8 T3 F! n' C  G

% ^4 `/ A& a& I" q" F; p
& V. G# L6 Q( I( A  硬件外设初始化

* v4 g( W- j8 W. g. D# _9 U硬件外设的初始化是在 bsp.c 文件实现：

9 d+ q: Y' \9 @7 K& M' R

1. /*
   7 w. k& K2 w/ S, Y
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   4 J: T, H; }* C8 V" z
5. *        形    参：无
   : Y9 e# J) _5 s1 e" ]
6. *        返 回 值: 无
   1 @7 Q% p8 ?- K0 p  q
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    $ j& E- d" F" |9 M6 o4 t$ K9 I
12.         MPU_Config();
    ) U! a% ~0 X9 t  Q
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    % W" C' r* D! l/ Q" Q
16. 
    # B0 Y" |" z( O: F
17.         /*
    ; v' L+ _9 x0 M
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    6 J: W% X4 t8 b* N8 Z) l% W1 q
23. 
    : D$ Y2 \7 n9 ~) h7 {8 P
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    / I! j0 o- h2 ^& C. b
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ) {3 d+ ]! o, j7 T; {* X+ g
29.         SystemClock_Config();
    
30. 
    & e, v( q( a; v  a9 D" m
31.         /*
    4 i" y* I# N9 d+ W$ ?) h
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    9 j, X1 T4 n" @+ U5 o) P* [0 m$ b) p
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    4 d7 z8 b2 x, C7 W6 U
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    1 |- o7 B6 U; x- h; w9 u
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ; Z% w, ]$ [) V  H/ d' a
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    / @$ K6 a/ o- p5 ?; O7 s* D4 D: N2 K7 n
44.         bsp_InitUart();        /* 初始化串口 */
    0 C# m5 b) Q5 B8 k
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    : |6 T5 l$ l( i9 n/ ]1 Q8 v2 A
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

8 p5 q- c1 D% T4 q: o3 ?  MPU配置和Cache配置：

$ h9 A# V* R5 t9 f# t* }数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
: @, U& C# c% w
: w. l7 |8 P! A" t) F9 U& F* Y- Z, z

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   * ^6 h* j/ U; t$ Y( f0 f
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   # d, R' ^5 k" h5 ]; h, T# e( [" ?
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   ; i8 N! p3 N$ P7 u* D- j) O
10. {
    7 k6 O$ o. r: y/ Z
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    " q3 X& f& C: i2 q& Q& s7 p/ P% i
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    3 U; `1 M" f7 W+ n/ B1 U
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    8 _5 `4 A$ B4 K7 ]
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    6 I" x2 |: B! u# G: M8 [
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ' B- o2 I8 k7 U9 a" t. R# {  k" F
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    + T% h5 h' ^/ }+ G
30.         
    8 `, a, f+ o0 d0 m% J
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    9 a' X- B# r  u1 h# F  t5 L$ E
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;
    # C2 s4 w4 ?. \" j- o9 c
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    8 }6 a' Y! Z! R% v, k$ s
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    # U! K( i( B; i0 ]1 a' l
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    % {9 w* ^+ _; D8 s+ h3 d
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    4 b4 W+ A( d2 f/ z/ ~( D& o- v! H* @
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & g# N( N: h( |4 S, s
44.         
    9 f3 B$ g4 k7 `) I6 n  E6 I' _( y
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    ' a7 Q9 T$ ^# Y; [
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    2 i/ v& d1 [' \7 [0 u$ E
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    ! h  S" P  w$ _+ Y  o9 s
56. *        返 回 值: 无
    . d! u7 c; O3 c& Q# T1 a/ V" h" H
57. *********************************************************************************************************
    . x% V% s5 [, Q' j! P0 g
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    ! O; |; W6 \* M! ?; U
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

% J0 R/ G6 d8 q  S6 e  每10ms调用一次蜂鸣器处理：
6 Z; z% w* `* H, S
8 T" C& ~$ H) d" m3 Z2 }蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
9 _* ^# }7 R% w1 [" O1 K

1. /*
   
2. *********************************************************************************************************
   + T  Q2 ]3 ^& s. {
3. *        函 数 名: bsp_RunPer10ms
   ! q/ H! `$ g9 x% P. p6 V$ x" B
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   ) B# l# X9 _. C: l
10. void bsp_RunPer10ms(void)
    8 N+ c9 J, v8 }- B. z3 K6 V  j
11. {
    9 Q  a" W6 a# \$ S7 P3 f
12.         bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

主程序实现如下操作：
' f( q3 u- Y% {( @; U4 r% m
' e* g2 W0 B8 m  启动一个自动重装软件定时器，每100ms翻转一次LED2。
1 [3 H  n. W9 W1 W# ?6 w  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
/ ~5 d  O( N2 j- O/ n- P  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
3 W: n, n( e) V  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
& D1 o/ O8 K9 ^: `& r+ E# e  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
- U  I& G/ b, \7 B/ v+ S+ v$ W$ E; e- X  K3按键按下，串口打印"按键K3按下"。

1. /*
   : D: w* l9 _1 t- E3 G
2. *********************************************************************************************************
     P2 f, h/ r* X9 F# W3 D
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   * [6 z9 ?+ ~3 f, T8 {% u
5. *        形    参: 无
   1 A. P4 k. f* e6 n
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   : Y) O3 d! s4 M, Z2 _
8. */
   - g. r- R4 X- ]1 e" M2 ^  L5 ~. q
9. int main(void)
   
10. {
    7 C  B) i, @& Z) {4 U0 O
11.         uint8_t ucKeyCode;        
    3 Y9 i1 j' r" K! ]$ @6 f4 P
12.         uint8_t read;
    5 B! F2 X8 ~$ N5 ^# E& |
13.         const char buf1[] = "接收到串口命令1\r\n";
    & c  Z# i/ m( E& |1 ~9 K+ a
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    " a7 Q& I3 d; o  m
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    
18.         
    , o& G: e/ E: t$ a2 j
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    ( `6 X7 p+ \% W% s) E! k
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    1 w! e3 Y# @# W$ K' ]5 `
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    , V- J2 g$ k3 |! X) Q6 X3 F; f
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    5 b! N+ O* a+ s% C! E
25.         
    ! W& C" }: N+ I  }* f6 ^( b
26.         /* 主程序大循环 */
    * f& I) Y9 x( j3 u6 |1 [  \5 ]
27.         while (1)
    0 i' |3 N. n7 C2 o: Z/ R
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    ) K( P9 U% o  f0 \7 E6 i
31.                
    , i: ]8 o% w/ a  F
32.                 /* 判断定时器超时时间 */
    ( S6 H; z8 T; b0 _& T
33.                 if (bsp_CheckTimer(0))        
    : n: a+ C) I" A4 J) c
34.                 {
    ; _5 t  O6 |  t  v3 c& ]
35.                         /* 每隔100ms 进来一次 */
    1 {' X2 i( \7 i7 R: [
36.                         /* 翻转LED2的状态 */
    3 B3 D7 N; ^1 p) \, r0 t7 }# P2 r6 A, R* \
37.                         bsp_LedToggle(2);        
    
38.                 }
      _8 g: y, O8 F" H
39.                
    $ m" h. x( ?! |- X# R# I
40.                 /* 接收到的串口命令处理 */
    # P4 U$ j8 a1 L# E6 u
41.                 if (comGetChar(COM1, &read))
    7 E) W7 X5 d; H! W4 j# H  q7 B
42.                 {
    # j. S9 E' z0 T. q% {/ h0 J7 j' x+ P
43.                         switch (read)
    ' `7 W- f) \8 S( U  N" W# K+ s9 `+ W
44.                         {
    
45.                                 case '1':
    
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    
48. 
    + n5 c. V$ c& Z# k; F
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    
52. 
      ]9 X8 g5 p. F
53.                                 case '3':
    8 `) o& D) _  E9 l6 u: a5 `
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    ( z. j% U  K' p0 E
56. 
    $ B8 {5 e( ^* I) V
57.                                 case '4':
    $ X" v! u  x3 l9 |
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    , r3 ~% l2 O* r
60.                                 
    & D5 c- G# b% |" f
61.                                 default:
    
62.                                         break;
    0 O' _) o0 S5 K
63.                         }
    ; T2 Q* v9 U6 F* J# @+ N
64.                 }
    
65.                
    / r2 h% i0 f' A& Z* S5 X) R5 r
66.                 /* 处理按键事件 */
    / W5 X  |7 @+ J$ W1 _- [: R
67.                 ucKeyCode = bsp_GetKey();
    , x. r3 y, E# K; G1 l- p
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    7 y! v) K' Q! _9 j7 B, a# u
72.                         {
    8 q+ {) |' C* x# b: r) `& g
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    1 B; }1 B. n) B8 J$ o4 B6 c5 f
76.                                         break;               
    7 k; s! _+ m. Q' w( I
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    * g+ q+ N4 C1 }3 n! D; v* @
86.                                         break;                                
    
87.                                 
    8 C9 M* `% X/ f3 `) ]( c2 b
88.                                 default:
    : v& d/ w- G) H0 E$ q+ M& W
89.                                         break;
    , r' a6 i7 r- S* @7 _' d
90.                         }
    ! p; A! }! M+ A+ a4 E) b; j
91.                 }
    * J. C8 g: Y& x$ m& D0 i9 C
92.         }
    
93. }

复制代码

30.8 实验例程说明（IAR）
配套例子：

V7-015_串口和PC机通信（驱动支持8串口FIFO）

: ^( M1 Q$ s/ C实验目的：
学习串口与PC通信。


实验内容：
/ E% B" t8 q" M; ~* V6 I; O5 k启动一个自动重装软件定时器，每100ms翻转一次LED2。
  A' O( Y9 M' L% O7 ?. Y# w" J

  |) y, x) Q+ k; g; {' Q) Y  k实验操作：
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
; F  c& F# M, |  g! N* B串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
' I0 q6 r; _9 }. _( R3 T6 `; G' n$ SK1按键按下，串口打印"按键K1按下"。
9 i, ]/ b1 ?; wK2按键按下，串口打印"按键K2按下"。
6 o8 A1 I) ^0 o, o* DK3按键按下，串口打印"按键K3按下"。
! W; w( h2 G& e( S: h( r4 b上电后串口打印的信息：

1 ?2 m$ F, [# s. d$ i& r5 ]8 J$ ^! O波特率 115200，数据位 8，奇偶校验位无，停止位 1
+ ^5 P/ |$ d* T( o
' B7 i& ?1 i8 I- c2 Y

! R$ m  i1 A* u  Q% v
* ]) X/ G& X0 R! k2 p  a3 l程序设计：

   系统栈大小分配：
  T2 K" u+ L1 E) r0 O: t3 e
5 K9 E# o0 n+ B+ b

5 f" |- B. ^; `& K. }2 ~7 `3 h6 D
! L8 U6 z0 A) `+ a7 `   RAM空间用的DTCM：
) ]3 d' v% \( u' f) S0 U- B
; V7 {3 E9 i, M, N- x. ^$ V

! ], M6 {; `4 E& X) @' L  硬件外设初始化

' x2 E& |* x+ B6 s- [硬件外设的初始化是在 bsp.c 文件实现：
) g/ m: o2 y8 E, |$ B
! x& r$ c) N1 B/ F" N0 G

1. /*
   ( h. f; _9 T8 H; t( T& f4 d
2. *********************************************************************************************************
   1 W4 y2 V6 ~. O7 t+ h/ [' z
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   7 F% P( Y1 P, |1 H$ j1 s
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   5 v, x7 y7 K% ^
8. */
   / A# J9 i) d* o( k7 H
9. void bsp_Init(void)
   
10. {
      @9 F: x/ O" |# q; }
11.     /* 配置MPU */
    
12.         MPU_Config();
    9 @9 Y( c7 ]8 ?: z6 F, i' x
13.         
    
14.         /* 使能L1 Cache */
    ( a) `8 m) C' ?1 y* }6 q
15.         CPU_CACHE_Enable();
    # v( T8 J% ?5 X2 s
16. 
    
17.         /*
    : d0 ~! ~) X* H- [
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    - S% f. V" n5 m1 e  ]
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    4 [* y! i5 D  l$ W2 t
22.         HAL_Init();
    % r# I8 i: r8 b( A
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    5 R$ L) m6 X% e. ~
26.        - 切换使用HSE。
    5 L/ a6 K  ?% p! [( K
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    & E8 N8 ^: Q/ i; c
28.     */
    / L. S' S& t$ I4 ]7 j$ ?
29.         SystemClock_Config();
    
30. 
    
31.         /*
    . B. }5 ^/ f: _) _3 a
32.            Event Recorder：
    & Z  T) S0 A. C
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ( b: z' {$ d  P- o( |5 r
35.         */        
    & r* C- h; u, D; j5 f* U5 n) H
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    4 n% {8 G+ g# o0 b2 z8 W3 z
38.         EventRecorderInitialize(EventRecordAll, 1U);
    0 }* c) a9 a4 [& {% x2 @1 [
39.         EventRecorderStart();
    - Y( J7 t5 r3 D; J
40. #endif
    ; v: b! n. l" \5 B% O
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ( ^. s% t+ [4 Z- ?# K3 R
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    " U6 X/ v' {, s! G6 s
44.         bsp_InitUart();        /* 初始化串口 */
    % _& t& T5 a7 H* O& R$ W+ I
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    & w% [7 e' z# _1 j0 G2 b# V4 i! g
46.         bsp_InitLed();            /* 初始化LED */        
    ( [  D7 f/ ?1 j# V- A9 Q9 H
47. }

复制代码

7 i" y& U* z; r, H( C, t  MPU配置和Cache配置：

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

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   8 j& U9 B! c* b1 x
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    & H3 p1 s" g) S) Q: U
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    : ~0 w" Y, U8 l
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ; |; W8 c" I& T! f; C3 {. Y; n/ F
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    , _% N$ ?4 n3 C. \, X2 S4 d
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    5 N+ U5 V; m" c3 B% @+ {, F" Z
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    5 v0 b2 s& j5 j3 Y( F7 t
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : t5 }# ?9 j, U( I1 Y$ r
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 N1 I$ i5 }6 O8 x
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ; U3 T* y9 `2 h  g5 h' X1 R
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    3 R; l! m  u2 R% l* g/ |
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    & r' V: S- P$ k3 c0 v8 ?
31.         
    , b7 i7 D( b2 ?7 C9 l
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    2 S+ P+ a8 M$ e6 V
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    3 h) Q& r/ t1 G6 Q
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
      P- K/ ?" }, _
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    ; N6 i; |  O* n; W* _$ B
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    8 A- R8 ]( z' |+ ~: v
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    $ ^* K5 W- [( g( ^1 [, X; i/ L
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    : x  x' Q- ~( R7 K1 E* j8 e
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    : O% [) P) m/ u* C5 Z( @
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    - @( [  d  \: z% z/ Y1 z9 a
49. }
    
50. 
    $ H& |9 U# e( h9 X
51. /*
      R! w4 l  {% i2 G* V
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    : ~1 D* {+ z3 _3 y( _# D
55. *        形    参: 无
    & [7 a1 _7 q1 V0 T
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    & j' C) h" E) {( L( Y
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    0 I9 Y0 b8 [. j$ q
64.         /* 使能 D-Cache */
    2 c8 ?4 J! {: w9 H5 K& _* [9 n- w+ T
65.         SCB_EnableDCache();
    
66. }
    
67.   每10ms调用一次蜂鸣器处理：
    
68. 
    
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    
70. 
    
71. /*
    
72. *********************************************************************************************************
    
73. *        函 数 名: bsp_RunPer10ms
    : d  R! t$ o0 K/ z7 @
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    
79. */
    * B* h% e3 a! K- N+ q: `
80. void bsp_RunPer10ms(void)
    ! Q# x+ M: a" _; U! f$ L) m' o
81. {
    
82.         bsp_KeyScan10ms();
      C- i' _& }+ D% p. r+ A# b  {
83. }

复制代码

* V* w/ i6 p( k% U" ?" A8 s% E  主功能：
6 Y( S4 Y. ^& d& r! V, Z. z  d5 P
( q2 [3 {3 c% V$ e. A/ g' \主程序实现如下操作：

6 V* O( K, o- j, @3 n$ Z  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
# v6 i% \, s. d4 p+ N# b& ~, @3 {  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
# J, Z# J2 d* `' m: [+ f( D. {  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
8 f; Z7 `* j" O  T" ~$ ~- G$ q  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
3 N& \% E- [3 {: M( t* {% S  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。

1. /*
   
2. *********************************************************************************************************
   2 E2 m) i- P) K1 m, ~
3. *        函 数 名: main
   ! g7 [+ t. H7 Z4 |0 y
4. *        功能说明: c程序入口
   $ F0 T( e0 [! T. M( I: H
5. *        形    参: 无
   * @* I0 ^( S2 j) U
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   0 R8 s3 x' i/ r1 V5 `
8. */
   
9. int main(void)
   
10. {
    , T* r- _) w8 Z3 X, L- J8 o& s
11.         uint8_t ucKeyCode;        
    " Q0 c* `- P" F& K+ y5 @/ d  K0 n+ f
12.         uint8_t read;
    ! u2 j, S* G9 y6 N' g# c1 Z$ A
13.         const char buf1[] = "接收到串口命令1\r\n";
    1 E1 `1 `5 P" k$ l. K; m, ?
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    $ i+ T3 v; R2 C" B$ J6 }
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    0 i2 j7 w3 c9 N& R, p7 ~: g6 n# ?7 |
18.         
    . j6 O9 M4 O5 P) ~, ?0 r, M# b  Y
19.         bsp_Init();                /* 硬件初始化 */
    $ Z/ k2 K! b7 z0 o; F+ \" p
20.         
    
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    $ }; S2 j1 c! P  O$ M
27.         while (1)
    
28.         {
    , e4 z. l/ R& _/ f
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    " \& G% V  J9 w/ c% E/ p! R
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    ) S5 K% q7 d: N6 \
34.                 {
    0 N- ]- I8 x5 k  l
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    : P! h0 V- w. \2 ?( w
37.                         bsp_LedToggle(2);        
    # H/ z4 O7 o7 R$ R* e. b6 u# K
38.                 }
    
39.                
    6 m+ R, U- b: s: C$ R9 A* L# ]
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    3 R9 i, C! s8 q& G9 G( M) w2 y5 q
42.                 {
    
43.                         switch (read)
    % J0 ^/ y" {0 v: o0 x7 }
44.                         {
    
45.                                 case '1':
    * I2 y* z2 T  v: z* U  i! t
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    0 s0 y- i& d2 l) Q2 D
47.                                         break;
    ) |+ v) N& A+ o7 V- s% x0 D8 T/ w
48. 
    
49.                                 case '2':
    . e( W1 z0 V6 \% t) V! E
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    # ^  [: K- a. |& H
52. 
    ( i% w2 g' m7 C$ \0 N2 c
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
      V. `! }/ r2 E- r+ ^
56. 
    
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    2 H3 e! E2 B( I+ i* m
59.                                         break;        
    
60.                                 
    " O2 Z/ K# S& N+ ^& X0 W8 m
61.                                 default:
    
62.                                         break;
    
63.                         }
    ( x3 ~- A( Z! V6 g8 z
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
    9 h; h( i$ Y" B1 K- A
68.                 if (ucKeyCode > 0)
    # @' L: s) i: b& v
69.                 {
    3 J! U4 h, E; {! P- A
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    - _* B$ ~, B" d  k
72.                         {
    9 i$ q7 V7 N% F4 v) O0 s: [
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
      E+ A. g' S, J2 B# U5 W
74.                                         printf("按键K1按下\r\n");
    3 U# ]1 h" F8 Z6 G" h9 J
75.                                         bsp_LedToggle(1);        
    
76.                                         break;               
    8 \" ^* G: U4 S/ a' W" R; d' v
77.                                 
    % G& g5 |3 ?, z/ H1 k
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    - l. t+ _- z3 N0 O( w
79.                                         printf("按键K2按下\r\n");
    7 G4 s, G5 X. f0 ^: ]2 N- G
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    0 D, K) p  i3 A
82. 
    1 K$ ]$ g+ ]4 ~+ A( h
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    6 e# }" \( A; \" N# T7 d5 ?
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    ( s' [; V* |1 k1 o4 S# @
86.                                         break;                                
    % W: S$ F( F) Z: g8 y( `. x3 k& k
87.                                 
    2 k1 C! z5 p/ d) [- ~
88.                                 default:
    3 W+ u& ]! J2 N; _9 b, A) Z4 E
89.                                         break;
    
90.                         }
    3 l$ D$ [) f8 {4 A
91.                 }
    
92.         }
    
93. }

复制代码

30.9 总结
/ n# w. Y( M4 W0 v. c5 K  x, F本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
  w0 z9 z- f' ^4 ?& L



5 H* }  [( ~) E% l- r) a  C. T8 Y