30.1 初学者重要提示
" t# \+ `; b! n学习本章节前，务必优先学习第29章。
% t( k1 e& N4 ^0 G串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
+ K: w9 c1 }+ i$ H本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
: k8 L( X( j) O( u0 yCH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
30.2 硬件设计
' K+ J- O7 E" \( K0 l% k0 PSTM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
# W  j( |$ F4 y9 z
串口USART1  TX = PA9，   RX = PA10
; y+ G% o5 v) [' o( N+ R
+ S" N+ ~4 ]: [0 p0 J+ }& j  d串口USART2  TX = PA2，   RX = PA3

4 p7 T5 b: b7 F8 M# R串口USART3  TX = PB10，  RX = PB11
- D7 u! ~$ ^% }7 g9 {# v2 M0 Q
0 ~0 W% n$ ~5 \) `- D/ x串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）

0 E4 w) F" K8 ^- l* }; ~. Y串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）
0 k/ `; q: @. C, U# h
2 L9 z; J: A/ S' q) W8 w1 T串口USART6  TX = PG14，  RX = PC7

* G7 \: h" r/ D: Z! _% P3 N) i串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
7 h8 O, N6 `6 w) }+ ~2 o* O2 i- d2 g/ \
串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
3 |2 }. z, i+ [$ m
' B8 G) |9 i8 t' ~STM32-V7开发板使用了4个串口设备。
7 t3 G1 B$ `4 O+ W
" N5 i: O# A( @, I8 X% d串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
( `8 N- @2 X9 V4 s% R' P2 q7 Y* e4 l串口2用于GPS
) e7 ]* b0 j& f串口3用于RS485接口
& m3 N) V: W  |5 \+ X/ a# H7 W: A串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：
' J- Q- F# l$ A3 }6 U
% l" C' |" }- {  k- b( C' x

0 l2 e1 {( B( A" a( g关于232的PHY芯片SP3232E要注意以下几个问题：

SP3232E的作用是TTL电平转RS232电平。
( L7 q' r3 S# H% o5 e5 ]电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
- D, W* J3 D4 M. L7 `5 I. v检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

* J/ C6 S6 d. }: B

- e% J) \4 T/ V5 A) L+ x8 j
( R3 |2 |7 D# Y7 {7 |4 x实际效果如下：
5 }/ C) {$ u+ N

' O* Y! N2 \, [) `! u' Y
通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。

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

30.3 串口FIFO驱动设计
5 F2 K* ?0 i5 ^+ P6 ]' G$ C30.3.1 串口FIFO框架
' a$ N3 r& m' i- ]/ `( V为了方便大家理解，先来看下串口FIFO的实现框图：

/ x- |, Q( L8 ?7 A3 D

* [0 S) J- R& S4 ]' @% N第1阶段，初始化：
: Y* }/ s0 Y1 V$ `" c* q
+ a0 D$ j3 w3 h' t通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
第2阶段，串口中断服务程序：

# r" X$ g/ V& N- c接收中断是一直开启的。
+ C3 g, H* k% R" [( V: v( `做了发送空中断和发送完成中断的消息处理。
第3阶段，串口数据的收发：
7 t/ E$ J% A* N7 I, V
串口发送函数会开启发送空中断。
" Y. {6 f& ^$ U7 m1 \' c串口接收中断接收到函数后，可以使用函数comGetChar获取数据。
: }6 M: ^$ b$ m* {
30.3.2 串口FIFO之相关的变量定义
串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。

1 `! m3 l4 Z, u这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。
# G6 ]3 I: `: m; S2 e* @
每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
+ l& I% ?; L  l1 w
# _' x8 P1 T4 y6 G/ j7 ?1 K我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。
! z+ b* A) K8 Q' ?2 r4 V
' F1 K0 P% o3 c

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   7 ~: [6 z# ]) l" W, u7 e
2. #if UART1_FIFO_EN == 1
   0 y1 t5 z& l* V3 X; F9 a  P* U
3. #define UART1_BAUD                        115200
   1 Q: N7 {3 Z5 t* P
4. #define UART1_TX_BUF_SIZE        1*1024
   , {- R0 U& B5 Y& Z' Y3 Z
5. #define UART1_RX_BUF_SIZE        1*1024
   ) |/ B& H3 e; F  A
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
   
9. typedef struct
   
10. {
    + p( N- P3 ^) a6 d5 a4 e  S1 A
11. USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    
12. uint8_t *pTxBuf;                        /* 发送缓冲区 */
    - p% Q& C5 @3 v, l/ D6 x
13. uint8_t *pRxBuf;                        /* 接收缓冲区 */
      S& R* F: N: l. p2 ]* t- N9 ]
14. uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    , B1 m( j1 Q6 K/ M9 R7 D/ O
15. uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    
16. __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    . l1 \' Q8 y* q0 g# a) y: c
17. __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    & z. h) ~, t7 i$ t( v) @5 e) W3 H
18. __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    ; r! F& b4 _! Z( e# r& G7 U3 Z+ [
19. 
    6 H' m; ]0 Q2 ^
20. __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21. __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    0 w+ C+ S, Y! U" d, b
22. __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    / d; K' q1 u2 c: T
23. 
    " y* N3 e% n, J3 q% X: P: p
24. void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25. void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    
26. void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27. uint8_t Sending;                        /* 正在发送中 */
    : f2 m4 _  ]. Z% A" N
28. }UART_T;

复制代码

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

1. /* 定义每个串口结构体变量 */
   
2. #if UART1_FIFO_EN == 1
   
3. static UART_T g_tUart1;
   ) G# s7 _  W( @  j
4. static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   
5. static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   
6. #endif

复制代码

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

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

7 P  O) T1 N) O4 p- ^- v

1. /*
   2 H% Z+ E0 M3 B1 l
2. 
   # ^+ _7 p& y: X
3. ---
   
4. 
   . b8 X# v( Q- G9 R7 P
5. * 函 数 名: bsp_InitUart
   $ ~& K' v& ^8 p
6. * 功能说明: 初始化串口硬件，并对全局变量赋初值.
   ! S$ I0 T9 T! \$ X  i8 X
7. * 形    参: 无
   
8. * 返 回 值: 无
     }! Y. P; ~1 C' P9 C' V
9. 
   
10. ---
    & E/ {; R9 ?! s0 d( `1 H
11. 
    
12. */
    - `6 v: ?( ^* e& [
13. void bsp_InitUart(void)
    
14. {
    7 T0 b& L# f+ b; H
15. 
    0 \& c* l2 W9 n+ [, V6 Q" U
16. UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    & C! D# ]1 m' P+ b
17. 
    ; X/ d  m8 C, j
18. InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
19. 
    2 `  E$ F7 K' I8 Z% R0 e: X
20. RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    , i) X. v0 u3 ]" {
21. }
    " B" \) q  z6 D3 d

复制代码

2 J$ U( ^* ~; s下面将初始化代码实现的功能依次为大家做个说明。

, M) e3 a1 r* I  J* _" H. v函数UartVarInit
- k8 ^1 G2 q0 c8 C0 ~这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：

1. /*
   
2. 
   
3. ---
   ; H/ {. U+ i% `2 g' q- U' H' c! e
4. 
   
5. * 函 数 名: UartVarInit
   
6. * 功能说明: 初始化串口相关的变量
   + f/ M0 i6 c6 q
7. * 形    参: 无
   6 _# ^' ^, X- Q& X# T& Z
8. * 返 回 值: 无
   : C0 R' g0 U$ }8 A1 s
9. 
   2 {; [% n, O: b/ D" _: B
10. ---
    
11. 
    4 H( O# U1 }4 Z: C% n" F$ I
12. */
    2 {. d( N4 o0 g- g- p2 s" E
13. static void UartVarInit(void)
    - M$ F5 ^% r$ ~6 B6 n7 K
14. {
    6 u( C8 _' b& v1 d) Z. q
15. #if UART1_FIFO_EN == 1
    
16. g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
17. g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    ( K4 X# Q  f5 r4 q9 c2 G  k
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读索引 */
    " `$ O" w+ F0 |* s; L; @& i* F
23. g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    
24. g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
25. g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    
26. g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    / l4 k3 c  _5 m4 s  Q4 E) z
27. g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
      u7 Q. x0 o2 {5 h
28. g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    
29. g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    
30. g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    / o% ^$ m4 S0 |
31. #endif
    + @6 D, T! w, u( b+ g
32. /* 串口2-8的初始化省略未写 */
    
33. }

复制代码

; c! N: R* Y5 a5 e' x函数InitHardUart
  z9 z& _# ]9 L: M0 w' |  Y此函数主要用于串口的GPIO，中断和相关参数的配置。
) j# P/ Z3 r' p

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   1 a' a  b) o2 C0 |2 e" R
3. 3.        
   4 E! F. c; |. t' ~7 Y4 S) t3 U
4. 4.        #define USART1_TX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   
5. 5.        #define USART1_TX_GPIO_PORT              GPIOA
   
6. 6.        #define USART1_TX_PIN                    GPIO_PIN_9
   3 l  ~" C5 X6 r0 ~7 s
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   
8. 8.        
   # n+ h' {% |( Q2 i% \7 a, }
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
    * y5 s0 O' o* D7 ^# B3 `6 u5 D
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    ( r! f: \+ O0 g+ f0 `
13. 13.        
    
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    ( M" U# x3 r5 S2 S8 v/ a, ?0 u
15. 15.        
    
16. 16.        /*
    
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    . ~  ?! R/ y) U. y7 c5 S
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    & C) I% c4 g, q* h: j
20. 20.        *              发板
    . _5 U; `2 R) A. q' L
21. 21.        *        形    参: 无
    / H' m0 B7 C/ x1 e$ }/ ~
22. 22.        *        返 回 值: 无
    
23. 23.        ******************************************************************************************************
    
24. 24.        */
    
25. 25.        static void InitHardUart(void)
    ! u4 L. M2 E. r& T* {
26. 26.        {
    ) V; }# |, w! s1 ?( j9 C/ k% o& u7 ]5 W
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    * M2 W* R' x) n# }6 T
28. 28.                RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
    
29. 29.               
    
30. 30.                /*
    
31. 31.               下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
    
32. 32.               默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
    
33. 33.               USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
    
34. 34.            */
    
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    0 x2 \# G# W# E$ J
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    ' ~  b5 j- E# s5 q) `: ]
38. 38.        
    
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
      ]/ w7 G3 G: P: z2 Y
40. 40.                /* 使能 GPIO TX/RX 时钟 */
      K" q! \8 ~% R" V1 v3 N6 {' ?
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    ) |- U5 V# T! d$ o, W4 F' c
44. 44.                /* 使能 USARTx 时钟 */
    ; _3 x7 Z: d8 m: t
45. 45.                USART1_CLK_ENABLE();        
    9 d9 s/ w7 ?$ [9 _/ r) R; U
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;
    
51. 51.                GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    1 C+ V9 P5 h9 ?' p0 V. A
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
      P7 Y% U2 ?9 ]3 e7 N9 h( t
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    1 d$ W$ A1 ]2 c& s- B# Q9 O# q
54. 54.               
    
55. 55.                /* 配置RX引脚 */
    
56. 56.                GPIO_InitStruct.Pin = USART1_RX_PIN;
    / }8 c  L. q& P4 j
57. 57.                GPIO_InitStruct.Alternate = USART1_RX_AF;
    
58. 58.                HAL_GPIO_Init(USART1_RX_GPIO_PORT, &GPIO_InitStruct);
    - d/ G$ x! \6 H* c
59. 59.        
    9 Z* q- ^8 v0 G7 }4 d  L" S
60. 60.                /* 配置NVIC the NVIC for UART */   
    8 h5 b$ G" f8 a* v- D) j
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    
63. 63.         
    8 v7 F3 w* z* _& y; m! e
64. 64.                /* 配置波特率、奇偶校验 */
    9 v4 \& h: o$ x0 u  \  q# z7 P0 m
65. 65.                bsp_SetUartParam(USART1,  UART1_BAUD, UART_PARITY_NONE, UART_MODE_TX_RX);
    
66. 66.        
    
67. 67.                SET_BIT(USART1->ICR, USART_ICR_TCCF);   /* 清除TC发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    & L& a% b; Y" u$ Y3 c3 U: x3 M
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    9 b- |1 \, T6 f8 l) E: B
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
      B% Y8 C( h, F  a$ d3 e
71. 71.        #endif
    % d, k+ {3 q/ {" E% f$ `' J) e
72. 72.        /* 串口2-8的初始化省略未写 */
    
73. 73.        }

复制代码

第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
1 l; J& W, D* U7 N2 O+ s/ }第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
第65行，配置串口的基本参数，具体配置在函数里面有注释。
, C4 D! s8 Y. V- z8 L                                                                                                                                                
+ m/ @( J) }3 f; ^6 G8 ^# [

1. /*
   3 |" B- \% o& @8 C1 W* m5 P
2. *********************************************************************************************************
   $ {. \) X. ?0 i" T
3. *        函 数 名: bsp_SetUartParam
   * t* p2 }% x/ n4 l
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   2 L2 F' ^- R3 ?$ w% m& B
5. *        形    参: Instance   USART_TypeDef类型结构体
   & _5 m0 R3 m8 p$ I
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    ; \/ P+ j" B. A, l6 V# C9 U3 H8 r
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    ) i0 X: M& r% p8 p$ E' @2 ~0 y
13. {
    
14.         UART_HandleTypeDef UartHandle;        
    ; t3 p- r0 a/ Z# v, c
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    
17.         /* 异步串口模式 (UART Mode) */
    
18.         /* 配置如下:
    
19.           - 字长    = 8 位
    + I* w; }. [/ v1 j% d
20.           - 停止位  = 1 个停止位
    
21.           - 校验    = 参数Parity
    
22.           - 波特率  = 参数BaudRate
    
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    
24. 
    & k  {/ L4 N1 P! W/ H. ?
25.         UartHandle.Instance        = Instance;
    1 c+ F! W  e: t
26. 
    ' w: W5 A( K- k, b
27.         UartHandle.Init.BaudRate   = BaudRate;
    
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    $ ?1 t0 D. l# J0 L
30.         UartHandle.Init.Parity     = Parity;
    " l0 k% a% T! I) w2 l% `7 m
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    
32.         UartHandle.Init.Mode       = Mode;
    ; S$ x, i- a% E9 }
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    " T2 k0 c8 q; ^, h4 k7 @
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    4 v: |! C6 e* ?- w. X7 Y) N
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    6 f2 x; e" r2 q2 ?6 ]
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40.    
    ; P7 i# b" W  g9 ?) X
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    
42.         {
    & c$ g* Q' @' m. p
43.                 Error_Handler(__FILE__, __LINE__);
    ) P/ g; c1 E3 }  y' g
44.         }
    7 o4 ]: M& ?% g! {2 C' u
45. }

复制代码

函数RS485_InitTXE
此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：

1. /*
   1 m: o# S0 j" Z) d# W, Q7 M6 t& T4 s
2. *********************************************************************************************************
   & \6 z7 @; c3 Y! }4 X
3. *        函 数 名: RS485_InitTXE
   # F  ^: M% j- v; E
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   : d9 Y' l+ \0 y5 t9 n
6. *        返 回 值: 无
   ; v2 M3 v. h! k, y% N: @
7. *********************************************************************************************************
   
8. */
   
9. void RS485_InitTXE(void)
   
10. {
    7 V5 j+ k0 \$ g9 @; q" Z  c- l$ h, R
11.         GPIO_InitTypeDef gpio_init;
    
12.         
    
13.         /* 打开GPIO时钟 */
    2 T9 X' B- g/ J* {4 _/ |; i* s
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    ; s# Y, y5 m% a, Z2 l
15.         
    / q  z& Z( V) R; ?5 c/ B; [
16.         /* 配置引脚为推挽输出 */
    
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    % W" n9 f( W) ]! |1 V. Q* F% O3 j
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    
22. }

复制代码

. s% z+ n6 f7 O30.3.4 串口中断服务程序工作流程
9 g/ L+ b' z3 J% Y  Z串口中断服务程序是最核心的部分，主要实现如下三个功能

收到新的数据后，会将数据压入RX_FIFO。
检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
% \+ Q5 Q$ r+ I3 ]如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

5 q8 c4 r) F. V下面我们分析一下串口中断处理的完整过程。
当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);
% y8 L$ F7 y" u8 R
我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：
+ B5 z9 O  w0 V0 n- S/ h9 c9 V
% }* F7 `: m( B5 |  B% ?% y

1. #if UART1_FIFO_EN == 1
   
2. void USART1_IRQHandler(void)
   ' k. q! b8 u) W2 u. O0 n! J
3. {
   
4.         UartIRQ(&g_tUart1);
   
5. }
   3 _  I0 {3 n! H! ?
6. #endif
   2 g! T* p/ b, b# D2 e  `; A7 z, {
7. 
   
8. #if UART2_FIFO_EN == 1
   ( X, H2 C0 X( L6 [1 c: o* ~
9. void USART2_IRQHandler(void)
   
10. {
    
11.         UartIRQ(&g_tUart2);
    $ `1 t% n3 c2 p1 ?9 u- G
12. }
    
13. #endif
    ! t9 N; s- b7 l6 R3 K+ s
14. 
    
15. #if UART3_FIFO_EN == 1
    
16. void USART3_IRQHandler(void)
    
17. {
    
18.         UartIRQ(&g_tUart3);
    
19. }
    
20. #endif
    
21. 
    0 J1 v( g2 m' u0 h
22. #if UART4_FIFO_EN == 1
    9 V3 w8 z* g7 q% O
23. void UART4_IRQHandler(void)
    9 Z% h$ a1 [4 P2 e, d5 V
24. {
    + n. C6 w- ?# O; t' b0 i
25.         UartIRQ(&g_tUart4);
    % m: z* N# {' f+ G6 ~4 `9 B: e( B
26. }
    ( t  z1 J& \8 Q3 D' w7 B6 V# Z
27. #endif
    2 A" K  D& ~* M/ j
28. 
    6 g$ g  @& |0 \; w, T, M
29. #if UART5_FIFO_EN == 1
    9 V1 D6 U: J$ d# Q4 C
30. void UART5_IRQHandler(void)
    
31. {
    
32.         UartIRQ(&g_tUart5);
    
33. }
    # o2 [) W3 V$ N4 }9 x/ M5 a
34. #endif
    * k$ q2 e7 \! c1 i
35. 
    5 b8 i- U7 N2 f' z, T- _
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    0 h" W# N# e- F, i5 S* M; b
38. {
    - [! j% L7 X4 Z% X0 X& k
39.         UartIRQ(&g_tUart6);
    ) \5 F2 \7 f) x' E8 q- J
40. }
    
41. #endif
    : I3 S% W8 {$ D  N
42. 
    ' h1 u3 ?* M, B9 ~. T& D; B
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    
45. {
    
46.         UartIRQ(&g_tUart7);
    
47. }
    
48. #endif
      d, U. q  ?: Z5 b" A
49. 
    ! w! p& I6 A) R7 W+ ?, h" I8 L) I
50. #if UART8_FIFO_EN == 1
    : \& h' v, t1 P; ~
51. void UART8_IRQHandler(void)
    9 X7 `& W& k. e2 D1 }5 ?' B
52. {
    
53.         UartIRQ(&g_tUart8);
    * }5 M0 F7 ^+ |4 U% \+ j
54. }
    4 X  V, p) y4 [) w. h5 S
55. #endif

复制代码

: i/ K! C; Z  L$ F2 \大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。
- S$ j5 i7 b1 Y0 {/ O0 e- ?, T' B  F
; c- R# I3 G0 f! s4 q2 }/ D# L下面，我们来看看UartIRQ函数的实现代码。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   
5. *        形    参: _pUart : 串口设备
   % V& k) m8 @. {+ N! r
6. *        返 回 值: 无
   & }* `1 T* y) I, c& n2 P
7. *********************************************************************************************************
   
8. */
   
9. static void UartIRQ(UART_T *_pUart)
   
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
    7 O( e3 ^& l8 T8 c& R
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    8 `$ {+ d' t# h
14.         
    
15.         /* 处理接收中断  */
    
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    ' s% N2 v0 W7 z( n7 k
17.         {
    6 W; l$ h$ L$ i% ^
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    $ l# B; u) @8 H, m
19.                 uint8_t ch;
    . g, c7 l0 Q+ ^1 n8 K6 z
20. 
    4 M  O6 q4 N; Y. q* U) B1 V
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    ; Z- }4 m/ e/ Y0 Z" m  g
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    
26.                 }
    / f6 p0 \! v% X# H. ^
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    - ]. f8 z" p; w+ ^0 p5 b+ ]% M
28.                 {
    
29.                         _pUart->usRxCount++;
    2 y5 ?3 i6 D1 I
30.                 }
    9 c3 t7 B0 X. w
31. 
    
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    
34.                 //if (_pUart->usRxCount == 1)
    
35.                 {
    . k6 j9 E* e( i( o% }9 O
36.                         if (_pUart->ReciveNew)
    
37.                         {
    % m2 w1 M( t. c- `6 }: c6 g
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    # U# r5 Y# B1 {* ]
39.                         }
    + t7 m7 M* q3 b: V% c& z
40.                 }
    
41.         }
    + t! N; t% z% G& O# p. Z$ @3 p
42. 
    7 K5 G% s7 }; s, a7 l
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    0 X$ u/ F9 w* r1 o+ A0 Q* d
48.                 {
    
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    : a: K4 I- W8 y9 K6 n
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    $ Z; _% R0 o- n1 e! H# @
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    
52. 
    9 x9 k9 G: y7 D6 C
53.                         /* 使能数据发送完毕中断 */
    
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.                 }
    ; \) P: H* n. u0 E. V
57.                 Else  /*　还有数据等待发送 */
    5 S- U0 V4 ~5 y5 V% ^1 \2 _7 ~
58.                 {
    
59.                         _pUart->Sending = 1;
    8 t: R! n: C. }
60.                         
    
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    : ]5 F, F5 h9 `$ ^/ X
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    # ~5 e% |4 w% ?
68.                         _pUart->usTxCount--;
    
69.                 }
    # f  D  H- F% z' S4 L% _
70. 
    
71.         }
    3 O  X' B- v! @) v% E, M
72.         /* 数据bit位全部发送完毕的中断 */
    $ |- I- p: u0 b
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    3 J$ j' ?9 @4 j2 s1 E) W
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    % l  z0 }3 b! ~. W
76.                 if (_pUart->usTxCount == 0)
    ' U( M! i# J* x1 p& ?/ l0 }
77.                 {
    ( X& U- @( G" g
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    / v  @, v5 h0 g% ^6 i
83.                         if (_pUart->SendOver)
    
84.                         {
    3 D; n6 a5 W% d% E# Z+ ?+ x
85.                                 _pUart->SendOver();
    ' Y6 Q; T# s2 N' u" L( f' `# a
86.                         }
    
87.                         
    
88.                         _pUart->Sending = 0;
    
89.                 }
    
90.                 else
    
91.                 {
    ; M# P# N, y2 u) v0 O5 i
92.                         /* 正常情况下，不会进入此分支 */
    
93. 
    
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    + y  L0 f6 u" p" g
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
98.                         {
    
99.                                 _pUart->usTxRead = 0;
    " `" W5 z/ J0 e' w- W
100.                         }
     
101.                         _pUart->usTxCount--;
     & i% @, |/ q: T
102.                 }
     
103.         }
     ' n9 ]0 o+ I2 ?% G
104.         
     ( b3 X, l8 X- B$ _8 ?# @" M
105.         /* 清除中断标志 */
     / S+ {4 h: L7 N7 M3 w
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);
     * \0 G& j9 u' T$ |% i. L" x; L
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     . ~# T* R, Z6 }% B: F+ W
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     + O6 v1 m. f  ~/ U' Y
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     3 S" e) X9 o# m
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);
     # F) A4 j. `8 p: u+ [- J' @
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     $ @1 A: e1 c2 [+ P; [
117. }

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下。
+ I: B$ ^; @0 p6 v6 K1 u" c" `. n1 P
  接收数据处理
+ ]* w- J* ?5 s6 I% q/ W接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。
特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

  发送数据处理
( V& A& |2 o3 j; k; C# M1 z发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *                          _ucaBuf: 待发送的数据缓冲区
   
7. *                          _usLen : 数据长度
   # k- m5 j2 S3 L1 a; j) {' P
8. *        返 回 值: 无
   2 K4 S" h  Y  P# Q5 L: b  B
9. *********************************************************************************************************
     Y9 ]3 f( \* \. B4 U1 W/ C
10. */
    + Z3 ~& \4 B2 ?* o' o) q' V& o
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
    
12. {
    
13.         UART_T *pUart;
    - O$ |# q: k  @2 d
14. 
    
15.         pUart = ComToUart(_ucPort);
    * k) K+ K( O. v( d
16.         if (pUart == 0)
    . _% P# @8 D5 X
17.         {
    
18.                 return;
    / p; {/ q+ X- J7 _* F* @2 T
19.         }
    0 F9 `! A! C! V; I5 J& n8 [
20. 
    - [- Z6 K1 \" i" j: B
21.         if (pUart->SendBefor != 0)
    
22.         {
    
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.         }
    6 o! f' _7 A# V
25. 
    
26.         UartSend(pUart, _ucaBuf, _usLen);
    
27. }
    2 \/ G5 X% r+ Q0 t( E) W
28. 
    / D( @" A* `" j+ v( ?. o7 N1 c3 i
29. /*
    2 \5 y6 }8 K/ h$ _9 V$ E. G2 X
30. *********************************************************************************************************
    
31. *        函 数 名: comSendChar
    % b% Z  H5 x3 r
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    - {* [) l# S, t; B! `  |
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    ; Z& @' t, m( X( b4 Z' C( E
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    # b3 y& @1 F7 C! z) Q% L* |! T
36. *********************************************************************************************************
    
37. */
    
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    
39. {
    / x' Q' f; x! f$ V) w5 m# v( f* ]
40.         comSendBuf(_ucPort, &_ucByte, 1);
    & b2 [, f  E/ c6 s$ j& y
41. }
    2 f2 F6 ^2 }8 Z. o  M$ A
42. /*
      X" n) [- b/ ?+ J8 \: e3 d9 w
43. *********************************************************************************************************
    
44. *        函 数 名: UartSend
    ' [5 S6 o4 \! d' A2 @: I0 i
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    7 }3 o* }+ V4 J" S( L! A4 N; T# e
46. *        形    参: 无
    ) A3 z8 b" M" m
47. *        返 回 值: 无
    ( }0 U$ c: N. G) d6 R
48. *********************************************************************************************************
    
49. */
    , _& B2 C6 b% \7 v$ |
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    
51. {
    
52.         uint16_t i;
    % ?+ g8 `0 Y  q7 x. q
53. 
    
54.         for (i = 0; i < _usLen; i++)
    . f; g; C/ L& Q
55.         {
    4 Q" C) G2 e7 B" U
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    - N9 H/ B0 L  H
57.                 while (1)
    5 a( r1 B* O- k2 }- a' Q
58.                 {
    1 b; i1 C. P# O9 }6 z, J
59.                         __IO uint16_t usCount;
    * H' N5 B0 x# ?: H( ]
60. 
    # R9 @4 Q6 U! T) a2 |3 ?
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    0 P, o) p, I% n( }
63.                         ENABLE_INT();
    
64. 
    
65.                         if (usCount < _pUart->usTxBufSize)
    " I: ^  S2 e- C* S! l
66.                         {
    
67.                                 break;
    
68.                         }
    1 C9 f1 _$ `; H; b2 f  g3 r* {
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    ' R8 U' u# H$ i! \
70.                         {
    
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    4 M: _4 i" n/ t# m, P- w$ x
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    . A9 k" r7 D) g( v7 F( _. P
74.                                 }  
    4 \( R; ?7 N' C9 s# {# w% h
75.                         }
    
76.                 }
    
77. 
    : Z+ r) h  e, m' j5 H5 a
78.                 /* 将新数据填入发送缓冲区 */
    
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf;
    # J  F9 p9 a# \# ]3 o* \
80. 
    
81.                 DISABLE_INT();
    # l, ^% G8 `  X* B  a; q
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
      S: v- g( k7 n& @4 D5 k
83.                 {
    , ]* y7 Q) M* @
84.                         _pUart->usTxWrite = 0;
      C1 |. O7 L5 _  o: J
85.                 }
    
86.                 _pUart->usTxCount++;
    8 h2 o$ d8 X9 h
87.                 ENABLE_INT();
    ! U" u: |- h- B
88.         }
    " `. b: W3 X: ~  D$ X5 D# o
89. 
    + q5 a8 D! `: N9 K7 Z% U8 L
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。
. C6 E) ^* i2 y/ o" Z3 t
函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

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

函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。
7 x: g+ [& a$ V( A" h' i, d' p2 ~

1. /*
   
2. *********************************************************************************************************
   & Z' x) ]* W* R5 d" U5 e, r
3. *        函 数 名: ComToUart
   
4. *        功能说明: 将COM端口号转换为UART指针
   . @, j; `5 I, [' H5 U* H" X
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *        返 回 值: uart指针
   
7. *********************************************************************************************************
   
8. */
   ! ~+ G) V3 @" ^
9. UART_T *ComToUart(COM_PORT_E _ucPort)
   ; r3 ]9 \- }. @
10. {
    / ^$ O5 x3 t" R& H
11.         if (_ucPort == COM1)
    " O. Q/ a4 i  [
12.         {
    
13.                 #if UART1_FIFO_EN == 1
    $ w4 T5 i2 j* B0 E6 R
14.                         return &g_tUart1;
    7 o8 }% Z& K+ b0 X$ [
15.                 #else
    
16.                         return 0;
    $ C0 ?6 z, A$ q0 O: j9 Y* z( ^$ q1 V7 {
17.                 #endif
    
18.         }
    9 n$ \' @, @7 E' |& {8 B
19.         else if (_ucPort == COM2)
    3 N3 X, O1 L! z' d, E
20.         {
    , {0 d2 w/ C7 ]6 }5 P; A
21.                 #if UART2_FIFO_EN == 1
    
22.                         return &g_tUart2;
    / o% h$ Y( |% ~2 W0 Z/ n& H
23.                 #else
    
24.                         return 0;
    : m$ a% x3 u/ D
25.                 #endif
    3 A! A4 h: K5 ?9 g, S9 d
26.         }
    
27.         else if (_ucPort == COM3)
    
28.         {
    # k' V$ U. z" b+ ~3 n
29.                 #if UART3_FIFO_EN == 1
    
30.                         return &g_tUart3;
    
31.                 #else
    
32.                         return 0;
    - ?* [* \0 x; h' M" Z
33.                 #endif
    * E. f/ u* m$ R, A) Y
34.         }
    
35.         else if (_ucPort == COM4)
    ) n4 y9 ^7 G8 Z3 Y5 h- ?; n
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    ) Q' O5 ^! E$ A" z! H
38.                         return &g_tUart4;
    + k! C3 t5 s! M
39.                 #else
    ' B) A( v3 w% ~
40.                         return 0;
    0 v; `5 \/ e! P0 {0 x
41.                 #endif
    
42.         }
    " N& F- ^, ^/ |* {  r2 }9 ~) ?8 g
43.         else if (_ucPort == COM5)
    2 T/ J" v5 J  k' F' a& ^
44.         {
    
45.                 #if UART5_FIFO_EN == 1
    
46.                         return &g_tUart5;
    # @) G# m; V- p' I) d& ]2 W% j) u
47.                 #else
    + f! Z, Y( Q- l
48.                         return 0;
    
49.                 #endif
    5 j( \  D" ~3 d# e
50.         }
    , y, p* S7 M+ W3 G
51.         else if (_ucPort == COM6)
    . W, M4 C/ T; @) c6 l: }$ D6 F! {
52.         {
      r" ?8 v* y% B7 w( |6 B
53.                 #if UART6_FIFO_EN == 1
    2 D+ D* l! ~) a
54.                         return &g_tUart6;
    * P( k/ D+ `* r
55.                 #else
    
56.                         return 0;
    
57.                 #endif
    
58.         }
    
59.         else if (_ucPort == COM7)
    
60.         {
    
61.                 #if UART7_FIFO_EN == 1
    & r  u- }( d! o7 S, Y$ r
62.                         return &g_tUart7;
    
63.                 #else
    & S. U1 O, s; ]' d$ T% N! `
64.                         return 0;
    
65.                 #endif
    
66.         }
    , t/ m# w" r8 Q$ a+ I! K5 u
67.         else if (_ucPort == COM8)
    
68.         {
    
69.                 #if UART8_FIFO_EN == 1
    
70.                         return &g_tUart8;
    6 C" f/ Y9 O0 g
71.                 #else
    / {0 I7 z7 p6 P+ |6 j; d9 M
72.                         return 0;
    
73.                 #endif
    
74.         }        
    4 j  K8 j2 z3 y4 I" Z( l' i* |
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    3 k7 C; U. p6 ]1 P- f3 [; J
78.                 return 0;
    
79.         }
    5 y6 _, B% l: A- G1 b6 x
80. }

复制代码

. I% q# i% i+ S: O& |/ o" L30.3.6 串口数据接收
下面我们再来看看接收的函数：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: comGetChar
   
4. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
   
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   . \9 v$ E5 T" E2 K# _
6. *                          _pByte: 接收到的数据存放在这个地址
   8 t' P  G9 ^4 Y7 q! q- H7 b
7. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
   
8. *********************************************************************************************************
   
9. */
   
10. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
11. {
    
12.         UART_T *pUart;
    
13. 
    
14.         pUart = ComToUart(_ucPort);
    # `; ?# F0 k' U( Y( S7 _
15.         if (pUart == 0)
    
16.         {
    - b4 w5 T; A1 ^! r3 t
17.                 return 0;
    
18.         }
    6 u1 V1 z9 O/ c! e
19. 
    9 s" o) M+ T# l- I  `
20.         return UartGetChar(pUart, _pByte);
    
21. }
    
22. 
    
23. /*
    * D3 Q7 H4 Z3 K2 s! R
24. *********************************************************************************************************
    , H8 d6 @1 w+ ^% |& P; x4 A7 F
25. *        函 数 名: UartGetChar
    
26. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
    
27. *        形    参: _pUart : 串口设备
    
28. *                          _pByte : 存放读取数据的指针
    
29. *        返 回 值: 0 表示无数据  1表示读取到数据
    
30. *********************************************************************************************************
    
31. */
    ) ?7 f5 V  j& j1 V1 `7 o+ |% G
32. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
    $ j- W# c2 C9 k
33. {
    
34.         uint16_t usCount;
    $ }- J, }7 N, F5 ~
35. 
    ' {9 n$ q! u. C2 C& K2 ?9 a
36.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
    
37.         DISABLE_INT();
    
38.         usCount = _pUart->usRxCount;
    
39.         ENABLE_INT();
    * t* |& Q% }  p. m2 k0 r, l
40. 
    4 H9 L5 }3 \' F( X# o5 o/ q
41.         /* 如果读和写索引相同，则返回0 */
    
42.         //if (_pUart->usRxRead == usRxWrite)
    % _  e  B  J* ^9 W+ T
43.         if (usCount == 0)        /* 已经没有数据 */
    
44.         {
    + J0 m- m* ~8 h
45.                 return 0;
    
46.         }
    
47.         else
    ; v% k* M7 \  a; ^7 n( S
48.         {
    " K2 c$ u- h9 T) D
49.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
    
50. 
    8 F4 i. \8 E* w5 ~( q
51.                 /* 改写FIFO读索引 */
    
52.                 DISABLE_INT();
    9 t, u; a/ T! l
53.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    
54.                 {
    
55.                         _pUart->usRxRead = 0;
    
56.                 }
    " b- x$ B$ m: R8 o5 h
57.                 _pUart->usRxCount--;
    
58.                 ENABLE_INT();
    1 f$ n* R6 _+ M. y" u* N6 |
59.                 return 1;
    
60.         }
    ( D$ t+ _3 M' h; \- F7 Q5 k
61. }

复制代码

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

注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

30.3.7 串口printf实现
, M- ]/ m  N+ V1 e% J+ f% wprintf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

, ^3 O/ T# _. a) D8 i, @为什么要用printf函数，而不用串口发送的函数。因为printf函数的形参功能很强大，它支持各种数值转换。比如将整数、浮点数转换为字符串，支持整数左对齐、右对齐显示等。

我们设计的很多裸机例子都是用printf函数输出运行结果的。因为如果加上显示屏驱动后，会将程序搞的很复杂，显示部分的代码量超过了例程本身要演示的核心功能代码。用串口做输出，移植很方便，现在很少有不带串口的单片机。
  s; q/ t$ M- t4 u
实现printf输出到串口，只需要在工程中添加两个函数：
9 K$ ~* X# \! {
: K/ n! s6 T% m  n' X* c

1. /*
   * ?- N4 g( `9 ^- R7 ~9 q/ Z
2. *********************************************************************************************************
   ' g$ [) J5 Y  C- C- y, p
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   
5. *        形    参: 无
   7 ~' A, Y. k" x0 b
6. *        返 回 值: 无
   & e. O4 O# B) r
7. *********************************************************************************************************
   
8. */
   - L1 T% l) D! ?1 p# Z$ ^3 ]* C
9. int fputc(int ch, FILE *f)
   1 c; E  q3 X) J
10. {
    5 Y6 R5 M# P0 g1 V' y6 S4 x
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    2 t- i' r& U( w( }0 b# r6 e
12.         comSendChar(COM1, ch);
    8 N! g$ Y, M( h- ]- y- v* k* n
13.         
    ( a+ i! B" @( O4 j' _- d2 V/ o
14.         return ch;
    : t- s+ I$ ^% h& s( e1 n/ [
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    
16.         /* 写一个字节到USART1 */
    ! X1 ^( _5 f4 f% r* T# ^
17.         USART1->TDR = ch;
    . D' {' K8 [3 X$ i& y
18.         
    
19.         /* 等待发送结束 */
    4 r# q; q6 V* j9 e" \
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    
21.         {}
    
22.         
    ' B5 j0 V: Y4 A+ T1 y- l5 Y! K
23.         return ch;
    # j) S/ I1 a; S5 X4 ~& \( ~# c( ]
24. #endif
    ) c$ w1 z3 j! \0 {/ k
25. }
    
26. 
    
27. /*
    4 O; |  b7 E& {& l$ j" {' \3 z
28. *********************************************************************************************************
    
29. *        函 数 名: fgetc
    ' Y3 ]5 n/ n/ g# V' L6 H( ?
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    
31. *        形    参: 无
    
32. *        返 回 值: 无
    
33. *********************************************************************************************************
    7 n& n; i& }# C8 @
34. */
    / X( U$ k9 c% P: f& M
35. int fgetc(FILE *f)
    7 Y5 x+ T1 G/ S( U  X
36. {
    
37. 
    
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    
39.         uint8_t ucData;
    
40. 
    
41.         while(comGetChar(COM1, &ucData) == 0);
    1 c: D8 e# L1 K
42. 
    
43.         return ucData;
    
44. #else
    
45.         /* 等待接收到数据 */
    
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    ' i3 s2 a6 i6 F" @1 x7 }1 g  F
47.         {}
    # E- f% M5 [% w; I
48. 
    
49.         return (int)USART1->RDR;
    8 ]; f3 u7 b" z+ N3 P+ o
50. #endif
    
51. }

复制代码

% j3 e& ]% ^/ {- z4 @, yprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。

. N1 w& O+ D5 h5 R' g5 i+ U7 u; T* v30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
+ |, Z5 o/ ?" a9 N, ~* T串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：
  N4 s# A) n5 A- e
  bsp_InitUart
  comSendBuf
" ^$ w" c0 i+ R6 P  comSendChar
  comGetChar
$ Q- v& l) L' g  {& q: t30.4.1 函数bsp_InitUart
函数原型：
void bsp_InitUart(void)
: V; U% K, W- D9 y
函数描述：
* c2 z/ p3 e* h+ w9 A! B此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
) \) `5 ]7 C' o8 i* q6 `
0 L3 y2 {$ h' Y使用举例：
串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
4 \3 F+ U2 C: Z; n
! F& Y. d' b* _: c) ~30.4.2 函数comSendBuf
- i* p& I* n, G; H% N函数原型：
5 S& X6 F6 \2 V$ l: s4 M# U) avoid comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

# `, s  O) J9 _6 A1 p
函数描述：
( g. D# G8 a9 c: O* c此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。
+ D+ h7 w7 ?& f' f
函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
# |3 @; ^+ F3 M' K5 t  第2个参数_ucaBuf是待发送的数据缓冲区地址。
6 L4 N1 W# F7 y7 w1 ?0 u; g) z  第3个参数_usLen是要发送数据的字节数。
: T8 k" @' ]5 \% E" K% j! v" K1 `3 h3 ^
3 g- y! q7 N- \5 ~
9 h6 K0 Q  }6 V# z注意事项：
  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
1 s' @+ N$ L, }% ?" `9 l/ |/ i

使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
  L6 ^- k# i6 N* i, W
% R" W4 v' J1 p' X9 p5 qconst char buf1[] = "接收到串口命令1\r\n";
comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));

, l! b; W- w8 F7 d- z* r5 |
30.4.3 函数comSendChar
函数原型：
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);

( k1 l6 M9 D  |6 c% @1 c/ a
( |. _2 a& u6 W( o函数描述：

此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。

函数参数：
  第1个参数_ucPort是端口号，范围COM1 - COM8。
% g, w& N. u/ M4 }  第2个参数_ucByte是待发送的数据。


! ^  K1 B/ V  Q, V% t注意事项：
  此函数的解读在本章30.3.2小节。

6 J+ u/ p0 k% X2 O2 }) U
% J+ e, ?& [2 Q" F使用举例：
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
比如通过串口1发送一个字符c：comSendChar(COM1, 'c')。

30.4.4 函数comGetChar
$ N! f& ~, J' W/ v; m% h函数原型：
, F0 x8 v% e, uuint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
: u, o/ e% H& l; @* i

函数描述：
, e( h9 B8 _; U% h9 \* X. d: U此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：
9 R$ f) R3 w8 _  第1个参数_ucPort是端口号，范围COM1 - COM8。
3 O  a7 k' H) M% L1 t7 b7 h5 U  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。


注意事项：
  此函数的解读在本章30.3.6小节。
7 _  d' A4 f0 u7 A/ H
3 E6 m/ d! A! j5 O2 n: N" ~* v
" k0 O5 k5 s- c4 m* P( |使用举例：
+ s  s; w" v$ Y* y调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

0 |$ X, M) n* o- D- q比如从串口1读取一个字符就是：comGetChar(COM1, &read)。
. x6 Q6 V; s8 b" r% @# i
1 k2 x" F$ p) U# y/ ?5 H30.5 串口FIFO驱动移植和使用
串口FIFO移植步骤如下：

  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
- N# k& E: }" U8 R# C! }1 W, A  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define        UART1_FIFO_EN        1
   2 ?; l/ z8 {2 z' j
2. #define        UART2_FIFO_EN        0
   1 @2 |3 z) k; d' }' E
3. #define        UART3_FIFO_EN        0
   
4. #define        UART4_FIFO_EN        0
   7 ~' m  p7 i% k6 {* q! f: j
5. #define        UART5_FIFO_EN        0
   8 \' [4 f% }7 E5 _/ R& G% z
6. #define        UART6_FIFO_EN        0
   & `( K' z9 D* _3 o+ D8 ~) j# z- k% `
7. #define        UART7_FIFO_EN        0
   * T* k4 k. N: q7 a) @
8. #define        UART8_FIFO_EN        0
   
9. 
   
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    6 P( E0 Y# @8 k
11. #if UART1_FIFO_EN == 1
    
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    , k0 U4 V8 b" d& X
14.         #define UART1_RX_BUF_SIZE        1*1024
    ; ]0 D7 H1 t( o! d4 I+ D
15. #endif
    $ h( |% [1 ^) F8 K4 v
16. 
    - [2 J# X7 Q* x% |( I; {$ e
17. #if UART2_FIFO_EN == 1
    
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    & v: y, }8 j$ o4 T/ `1 Q
20.         #define UART2_RX_BUF_SIZE        2*1024
    
21. #endif
    
22. 
    
23. #if UART3_FIFO_EN == 1
    
24.         #define UART3_BAUD                        9600
    
25.         #define UART3_TX_BUF_SIZE        1*1024
    & @" x8 G0 H* b5 P# R
26.         #define UART3_RX_BUF_SIZE        1*1024
    7 Z3 U7 ^3 n' e/ a6 a
27. #endif
    + {: \* u- f9 g( P9 q
28. 
    
29. #if UART4_FIFO_EN == 1
    
30.         #define UART4_BAUD                        115200
    - ?# O- O9 j$ g0 s' a* D
31.         #define UART4_TX_BUF_SIZE        1*1024
    
32.         #define UART4_RX_BUF_SIZE        1*1024
    ) m' U- P; r" p( Y( w: Q
33. #endif
    
34. 
    
35. #if UART5_FIFO_EN == 1
    
36.         #define UART5_BAUD                        115200
    
37.         #define UART5_TX_BUF_SIZE        1*1024
    
38.         #define UART5_RX_BUF_SIZE        1*1024
    1 u3 N4 @6 x5 I( T! C1 @0 ], V
39. #endif
      g# K( V7 h2 t& i1 I/ _
40. 
    - G: ]  P5 a; n2 r+ m
41. #if UART6_FIFO_EN == 1
    
42.         #define UART6_BAUD                        115200
    0 h  I) l* a5 [; l# Z0 P# q
43.         #define UART6_TX_BUF_SIZE        1*1024
    
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    
46. 
      L' L, W; b9 a- [. E6 r
47. #if UART7_FIFO_EN == 1
    : [1 N. U6 ?& @; H9 ^9 d% E8 {
48.         #define UART7_BAUD                        115200
    ' P9 Z) U0 ^/ r* p1 V2 I0 Q1 v
49.         #define UART7_TX_BUF_SIZE        1*1024
    
50.         #define UART7_RX_BUF_SIZE        1*1024
    
51. #endif
    . x# [! |* n) {% J4 s4 t
52. 
    # ?( e6 l  Q; {* j6 a
53. #if UART8_FIFO_EN == 1
    3 l+ T: [6 Y' B2 Q) J/ j
54.         #define UART8_BAUD                        115200
    7 }2 g+ f# k* d) z
55.         #define UART8_TX_BUF_SIZE        1*1024
    
56.         #define UART8_RX_BUF_SIZE        1*1024
    / y+ t: `! i3 w9 F9 D; o' M& f- L; Q
57. #endif
    : }0 r" ?: A. h% i# X( G

复制代码

$ x; L, z$ C: U$ t
  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。

7 B/ p) H, K; x3 h& m, M1 B30.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

) S. @- m. Z* [0 H! x- W* L8 t) U  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
  第2阶段，进入main函数：
& V: {( d: q* \5 c) k/ `
. s5 ?* ]6 [; H, L2 b  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。

30.7 实验例程说明（MDK）
配套例子：

+ W1 G, z* }; k" X6 yV7-015_串口和PC机通信（驱动支持8串口FIFO）
) b8 q# b; h; b; @! X0 Y
5 f3 C& V' h) A6 V$ G6 S- u实验目的：
' q* c* O4 l* V/ ^2 t, f; J: T0 N学习串口与PC通信。
  r* L5 J# [5 H# Y- u

7 C0 A8 c  C" N# ^实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。

6 B. r6 P# g2 n1 l4 Y- d' B
实验操作：
) T5 B2 ~7 C1 p串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
& `/ m0 W2 [. {- p9 J+ E% i" ]% L串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
/ E  c: A* f0 \+ }5 J串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
8 p5 e) R; @+ i. ~  [  e3 |串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
) `6 N+ f; I: h% L$ v, W- ]K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
8 R4 J' n" x' M! d. h上电后串口打印的信息：

% T; A0 R0 k* C3 V1 O# C( p6 h3 t波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

2 R7 B6 `9 Z' f$ t2 n' G: p  系统栈大小分配：

2 ]* t- `  n! Q" B) ]. `$ }) Q
  RAM空间用的DTCM：

, ?1 `( }5 F, `4 m1 y

- u. L" Z% u! S: ^. d  硬件外设初始化

$ i9 ?4 i! u  o$ t% b硬件外设的初始化是在 bsp.c 文件实现：
! a3 i* l7 S. d! d# r+ {6 [/ _
5 u; f7 q/ F( ?+ ^; ~& c* p! m

1. /*
   % Q6 {$ `5 Z+ F
2. *********************************************************************************************************
   : a1 H9 x( T5 q; E- `9 S4 k
3. *        函 数 名: bsp_Init
   6 w4 H( \" O0 e$ H- [+ O$ }
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   # k9 y% f; O7 U# K! {' R: J
5. *        形    参：无
   . [& W' l+ i/ R0 M8 v7 X7 b, g9 i
6. *        返 回 值: 无
   , P, Y0 a* Y# c6 H
7. *********************************************************************************************************
   1 O% {* b9 Q+ |; R( Y& O
8. */
   ( _8 k3 i; y" t, W& x3 F- u
9. void bsp_Init(void)
   
10. {
    ) W4 `2 h0 S* ^8 t  t1 E+ P
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    % o" Y) S3 R6 _/ V" m+ i- ?
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    % {$ @  o! I; t6 Q2 v5 I5 M
16. 
    ( Y4 G9 b6 D9 D& D+ d
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    * |' D- O( Q$ i2 [) ?8 F: A
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    4 c9 w4 p, ^  E( a/ J" ?4 T
20.            - 设置NVIV优先级分组为4。
    & y1 u" N; ^- Q0 ^' n$ u% \5 w
21.          */
    % w/ M& N# ~. o9 H
22.         HAL_Init();
    0 _* w8 }, j' b/ b* Q
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    " F2 m, Z6 K' i/ `9 f- I
29.         SystemClock_Config();
    
30. 
    
31.         /*
    $ Q- N, G; i- `- t% W) H, t
32.            Event Recorder：
    6 a* v* l1 p# B# n" W( O$ T! A' O  L
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    / q) l" ~. z: J# _0 K' _9 V6 ^' T
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    6 D9 T/ r& [3 U5 r# d1 X
35.         */        
    
36. #if Enable_EventRecorder == 1  
    % F% u6 P$ K3 R+ P5 z
37.         /* 初始化EventRecorder并开启 */
    + |' g2 k# Y8 k+ |( p) F* C, }7 F
38.         EventRecorderInitialize(EventRecordAll, 1U);
      g# e- E" ?0 z/ x& Z2 [1 k
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    $ _8 C. R- O, i/ @, G; z! t4 k
44.         bsp_InitUart();        /* 初始化串口 */
    # X3 j( g3 c5 @
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    7 \  _  I) k: W8 D; h$ P
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

1 F" h- ?1 r9 F! B; q  MPU配置和Cache配置：
1 Q' h! I+ H- \5 E; h7 V
/ g& E; Q0 t7 z4 H数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

( j" R- T: M3 ^

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   # O0 S8 ~# O% b9 b1 Q- j3 v8 r
6. *        返 回 值: 无
   1 h7 s" l' n: f
7. *********************************************************************************************************
   
8. */
   8 K: B# {9 ]8 b; o+ t
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    " ~' ]1 n- D2 l; m0 T- Y4 t5 @
14.         HAL_MPU_Disable();
    : d9 J3 V; W  {4 D3 f3 }
15. 
    / P2 o2 T6 w# a- R0 I+ t
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    / @0 G# B- I' C5 j( `. z
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    & I, p1 k' W; v1 g1 J; H
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    # Q- q: c. X1 m2 {' Y5 r$ R6 y0 H
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 J! V' f8 T5 L% e: E
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    7 E+ b1 e: K6 L. E+ Y
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    # V6 C* a4 _( N$ D* J1 m) f  u; K8 b
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    9 w; _4 k' g7 }5 ~9 X) Y
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    ' [* R# l( N' M0 c% _) o
31.         
    1 _/ ]5 W2 m: u) m# |2 L/ r4 d9 D% F( k
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;        
    
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;
    % ^( A% Q5 j! z7 @; Q! @/ c
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    7 s5 j/ V- ]5 A4 d6 [
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    : }! N) g! ?/ y/ z2 @7 ~" j
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + J; v6 H0 `  l7 d8 Y
44.         
    . i( S7 |# R; `7 d( A  v5 M+ }  V
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ) I2 i: i; C" F: k. q/ k- f; [% I
46. 
    7 L/ q7 g7 d( o
47.         /*使能 MPU */
    6 l5 K" W6 j7 N3 D7 R. e  i" G
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    ! ~  t2 V: {" }4 @, c& @
49. }
      |, N- _+ m( i! b, n
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    1 l; W! m! u! z
55. *        形    参: 无
    
56. *        返 回 值: 无
    5 V, A4 d! }6 ]4 h) `
57. *********************************************************************************************************
    6 \$ H0 m6 }6 Q% b4 @% q" s7 @& ]
58. */
    
59. static void CPU_CACHE_Enable(void)
    9 b/ {2 t, g) ?" r. W" |
60. {
    
61.         /* 使能 I-Cache */
    $ x; v6 Q8 @. J/ {$ H. S: f
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    / Y6 c* w; {2 y) u
66. }

复制代码

( `6 }7 _8 c+ `4 {2 p7 {  每10ms调用一次蜂鸣器处理：
$ o# S5 x5 F% V2 |8 ~6 [$ j4 m
蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
' d1 M' h7 A, S% b3 A
! L' M! j" d, h" b

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   9 S' e* p2 P2 c+ g$ v
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   0 U( O3 b; |  P/ ~" l6 u
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   / ^) {1 r, k& Z/ J" ?7 J2 }1 U# W
6. *        形    参: 无
   2 }3 [/ E0 z# s6 k
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
     S% j: `& T6 T+ w/ n2 j- \* y
10. void bsp_RunPer10ms(void)
    : F  N6 ?% K3 {5 C2 H  P
11. {
    
12.         bsp_KeyScan10ms();
    1 f; |8 {( y4 O+ F: z, a
13. }

复制代码

  主功能：
0 ^: P- F" `* h' h. E# T
主程序实现如下操作：

  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
7 G4 n5 [, P9 d7 V- M  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
2 P+ w- q7 l3 u5 j% u% k# k& _: n  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
7 ~2 Y* N$ o, C5 S7 E0 Z+ I8 S+ t- k  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。

1. /*
   8 {# z' M3 o; V3 N
2. *********************************************************************************************************
   
3. *        函 数 名: main
   ( j: S  N7 {( s! y6 M
4. *        功能说明: c程序入口
   0 Y+ c& g& L$ d8 c) k3 @" ?
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   9 ?" B: Z4 t' c" V
9. int main(void)
   
10. {
    , S9 Z( T6 [+ u5 {9 `
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    
13.         const char buf1[] = "接收到串口命令1\r\n";
    1 s8 g0 o- b  }0 |4 z
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    0 D% i; u) R+ j# S$ T7 @
16.         const char buf4[] = "接收到串口命令4\r\n";
    4 ^: `' K: b" C& j6 `8 ?
17.         
    . A, Z% V  H2 x6 m- r; Z& H9 Y! y
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    + k8 i# n5 Q! l, l) o. w& ], \
20.         
    0 w2 {6 [, a8 R( r' w
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    % G& y/ ?. d8 O9 T) m3 {
22.         PrintfHelp();        /* 打印操作提示 */
    # y9 j* k* h  \2 T
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    5 _; z+ D$ u5 ~8 K( Y
25.         
    % a9 q4 |. c6 l5 w: e
26.         /* 主程序大循环 */
    
27.         while (1)
    ( k6 ]' H* G1 w$ q- Y/ K2 `0 @" @9 N- r
28.         {
    $ P6 N8 r# \4 v9 y" T0 b% Q8 A5 [
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    7 J7 v% p" a4 M- z0 S7 v
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    / h, N" L. E3 y1 V
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    3 r, ~. I  d& c+ o2 }+ ?3 g
42.                 {
    
43.                         switch (read)
    1 B7 g# @9 d( \
44.                         {
    
45.                                 case '1':
    ; \9 h  K$ ^0 o3 B0 Z! j2 r; v
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    * g3 N' l2 e9 ~# Z& Y$ S
47.                                         break;
    
48. 
    9 {. H! n$ w+ l6 {" N
49.                                 case '2':
    , L: h! D- I; a- `! l7 E$ V. j
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    0 F+ N7 k  u" l. c  U
51.                                         break;
    7 `* z& Q# A: Q* P
52. 
    , y: v. v% B; C$ r
53.                                 case '3':
    / f+ E$ @1 Z/ N9 x9 P! H' _
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    + a" N+ ]% u3 B
56. 
      i/ c  ]4 c2 k; Z5 a
57.                                 case '4':
    1 {3 D& _; A: }+ s, p% w
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    , @" L& ?/ \4 R' m" ?
60.                                 
    # V. C3 N( y: V
61.                                 default:
    
62.                                         break;
    
63.                         }
    , K& f: B( [. A8 m
64.                 }
    ) c# @1 j0 z) N/ E( ^; h7 {9 {
65.                
    
66.                 /* 处理按键事件 */
    & k* j1 s/ s" _: ?
67.                 ucKeyCode = bsp_GetKey();
    
68.                 if (ucKeyCode > 0)
    
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    
72.                         {
    * f- p8 ]8 _2 A, T+ _
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    $ t5 _1 w; I/ s: x8 k& `
76.                                         break;               
    
77.                                 
    
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    % H- _1 X) ~( h! J8 b0 w2 N, U
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    ! @! D, \8 c7 b0 A
82. 
    : A3 w; e1 {, Y! f
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    ( u! K( L( |  |) Z
84.                                         printf("按键K3按下\r\n");        
    & O: p4 H" ?! A) }
85.                                         bsp_LedToggle(4);        
    / L/ C% K. |$ z6 P0 _8 L/ a
86.                                         break;                                
    + A2 R$ y. _$ Z7 b& j; D% q+ |
87.                                 
    
88.                                 default:
    ; B9 W6 U+ [. p
89.                                         break;
    ! v1 d9 g: W! Y8 [  f- p4 H
90.                         }
    
91.                 }
    
92.         }
    5 ^, H" O8 G- D
93. }

复制代码

; _* o  p5 e6 Z30.8 实验例程说明（IAR）
8 M; [! P' C/ O+ u配套例子：

V7-015_串口和PC机通信（驱动支持8串口FIFO）
4 \+ B( F$ E& s- [  z! R
5 t7 M0 O6 c7 [0 \. C实验目的：
学习串口与PC通信。
' t2 |  M+ `' I) z
/ C( P7 ~9 w7 o5 H+ W; q
实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。


实验操作：
/ V7 |5 R6 M+ B1 R. C6 \串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
6 h- R+ X8 |$ j% Q5 y9 Z; c串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
& I" @, J7 T( C7 g3 F串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
K2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
. s- ]2 O0 g. e. {; F( u8 Z" E上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
+ X. x% B: s/ n( V4 o# r

' L$ d- b' {  l% x
! f1 g/ d6 @  s& ]4 m程序设计：

   系统栈大小分配：

" b: }, D+ c- Z6 i% C

+ g9 y6 e( M' ^" t, k: e; V   RAM空间用的DTCM：

- ^! v* `: n7 n: A) Z7 G# l' G" [1 B

) J; x. }, M' L
  硬件外设初始化
& K  w* B+ T8 Z5 Q
硬件外设的初始化是在 bsp.c 文件实现：
: f+ o) ]+ W0 s  S+ B
% {! L% E+ @3 Y0 E& s

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

复制代码

: O, |, X( n; s/ h. J9 h3 b  MPU配置和Cache配置：
  _4 _# w8 ?& N. r
5 R% [8 V8 _& D! T) A. D% L7 a数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
" k, ~; J: Z. h$ G( e

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   . j0 U! f) k5 c+ s) K; ^
5. *        形    参: 无
   & O$ @- E0 w3 m; V, d9 E
6. *        返 回 值: 无
   " u/ j8 g" c; N
7. *********************************************************************************************************
   : n" N# P" _2 W% h
8. */
   
9. static void MPU_Config( void )
   # `' N5 f) S8 O, q% r
10. {
    8 M6 N1 C; C% H% M' j" W
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    4 g7 ?9 u8 S0 B. @+ G# s/ Y3 b
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    / b1 Z$ V' z5 n& K2 ?9 _/ C+ C
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;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + W. w% k# f7 e- L! t
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    8 M4 |6 Z6 U2 f3 `2 Q
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    " M6 g! T4 a* O6 x$ Q) a
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    * u, |6 p0 }6 p8 W* O( M
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    + o& \! r& p: ^" x2 r1 G/ D9 Q
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ; ?. b, n: w% v8 i- X, w
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    ) ]; \" D/ o& ]: @% w$ n- p9 r
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    " e* M+ V+ k# D0 h
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ; J( A  E3 B& V9 D
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    5 t$ O1 e- N* I0 I
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 D) H5 ]5 V/ J( d% b
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    $ P* B* W8 Y- a9 Z+ n9 [1 }  n/ c
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + \3 {8 [6 G* ~
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    0 c0 F: S, u3 \$ |
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    8 [' \9 f) W2 R: S
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! S: ?+ c% S+ H
44.         
    & t+ C; u- g! J$ \
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( b5 S% k$ E( S. c: S/ Q
46. 
    
47.         /*使能 MPU */
    8 c8 [) C' |$ i
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    $ [! P+ v$ _4 P9 T) C
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    " c- v, q" U3 d5 Q$ |% G+ {
56. *        返 回 值: 无
    # O3 ~" j1 q. R$ g5 ^  ]4 K
57. *********************************************************************************************************
    * U4 x$ e  T3 W% Y8 L- }6 X
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    - v) _" V2 [9 x) L* A9 P: c! a: g
61.         /* 使能 I-Cache */
    ; v+ z! b, z- Y' m2 N
62.         SCB_EnableICache();
    ! }. C5 Y+ N" i1 {9 L, P7 m, R5 P
63. 
    
64.         /* 使能 D-Cache */
    8 @! W& P  l: u& \# c- K
65.         SCB_EnableDCache();
      H, H" E7 C; s/ F8 F; d' ^$ H% [
66. }
    " f( o  B1 {) z% N1 a
67.   每10ms调用一次蜂鸣器处理：
    , t7 l* L: E% k9 }& @; P
68. 
    
69. 蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
    ' E# A2 Z- ^, h
70. 
    ! m3 u' S  m, \6 x7 ^
71. /*
    5 S* G( V+ d( R9 w
72. *********************************************************************************************************
    ) y" B7 A- I6 p1 c' b& p  _  F9 B# }5 o
73. *        函 数 名: bsp_RunPer10ms
    / y2 K+ w/ }3 s% b6 `% }. h
74. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
    / y4 q2 r$ X- E1 v: ^% J; ]9 |, e
75. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
    
76. *        形    参: 无
    , ]6 d* W2 [% C! J3 B: J3 W  ]
77. *        返 回 值: 无
    
78. *********************************************************************************************************
    
79. */
    
80. void bsp_RunPer10ms(void)
    / t. e1 s3 I( V% x8 W
81. {
    1 g' `- U' G5 Y! ^
82.         bsp_KeyScan10ms();
    
83. }

复制代码

' ?) q% J6 j( B& D  主功能：

主程序实现如下操作：

  p8 l  u8 `: n5 Y  z( _$ P/ D  启动一个自动重装软件定时器，每100ms翻转一次LED2。
  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
0 J% M: I. [5 v  U- |  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
$ q5 m, W$ h, u# V4 x( `  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
8 y+ J- I5 e8 L3 r0 \3 Q  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
9 X; O( }% X+ O/ A  G  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
% z- V8 P  Z$ d1 g, x

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   / y6 L$ V/ m% F! Z3 X( J
9. int main(void)
   
10. {
    4 B: @8 j; [8 o. N! O
11.         uint8_t ucKeyCode;        
    , {7 f. |/ p# i' T% @2 L
12.         uint8_t read;
    ' O; B% ~3 w8 H6 Y# i5 S5 ^$ h6 ^
13.         const char buf1[] = "接收到串口命令1\r\n";
    
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    
16.         const char buf4[] = "接收到串口命令4\r\n";
    , o) m3 M' E4 n& V
17.         
    4 l: @0 k3 P" H* m
18.         
    : \: d. u/ g+ [4 H/ w
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    8 \3 k( ^7 i3 T3 i' ~! j) z8 L, P
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    
27.         while (1)
    
28.         {
    , k$ x5 m* u" B6 ?4 M
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    
30.                 bsp_Idle();               
    
31.                
    
32.                 /* 判断定时器超时时间 */
    
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    . ]) Y0 E4 i# O8 H+ x8 T) s
39.                
    , L$ F5 a7 e1 M8 C3 e8 A2 a0 c
40.                 /* 接收到的串口命令处理 */
    
41.                 if (comGetChar(COM1, &read))
    ; x" V- ?% K# G! T& M
42.                 {
    
43.                         switch (read)
    
44.                         {
    0 q  \8 t) t* \/ V; N# r9 i
45.                                 case '1':
    5 ~0 b5 c, g$ `1 U
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    # |4 j) n2 v/ f* p4 `9 @- W
47.                                         break;
    * p. P9 i4 ~" G' O8 Q# _3 G
48. 
    
49.                                 case '2':
    : Q! d8 Q* y5 P8 w
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    
51.                                         break;
    
52. 
    
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    % n9 g9 M; z' z! _
55.                                         break;
    
56. 
    
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    . j$ k/ _9 L& `6 Y
59.                                         break;        
    
60.                                 
    
61.                                 default:
    7 k5 c% x4 m& _) f- ~, {( ~0 A
62.                                         break;
    , w# H4 Z# b$ l% {! k/ h
63.                         }
    
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
    6 u7 n5 W# S; y# q* I
68.                 if (ucKeyCode > 0)
    
69.                 {
    2 m4 b/ u' w6 x& U: I  c
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    , v7 W. c2 W# Z8 m; i& ?& e
72.                         {
    " B+ n% `  K1 S/ d7 b
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    9 }5 G. c5 y1 r8 v4 ~6 [
75.                                         bsp_LedToggle(1);        
    + B$ y3 F+ [. t% i' K( L( C' p
76.                                         break;               
    
77.                                 
    + g; O: |( K2 \( @
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    . |4 w* f7 E" C! |
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    
84.                                         printf("按键K3按下\r\n");        
    5 w+ u) \3 ]2 {1 V3 t! t3 q
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    , P3 B% w9 N& e: g& Y
87.                                 
    
88.                                 default:
    * a) w3 j* B+ e% j
89.                                         break;
    
90.                         }
    4 j! b0 v+ y: Y0 n* b: Y0 F
91.                 }
    % |% I& f" l& o+ \% c
92.         }
    
93. }

复制代码

6 H  n" A( L" k+ q5 s0 u% y/ W5 n) j30.9 总结
本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
0 g5 ^$ ]: F6 A) f


6 q* p6 z) ]+ {) L/ l