30.1 初学者重要提示
  学习本章节前，务必优先学习第29章。
  串口FIFO的实现跟前面章节按键FIFO的机制是一样的。
  本章节比较重要，因为后面的ESP8266，GPS，RS485，GPRS等试验都是建立在这个驱动的基础上实现。
  大家自己做的板子，测试串口收发是乱码的话，重点看stm32h7xx_hal_conf.h文件中的HSE_VALUE的大小跟板子上实际晶振大小是否一致，然后再看PLL配置。
  CH340/CH341的USB转串口Windows驱动程序的安装包，支持32/64位 Windows 10/8.1/8/7。
, F- V8 R9 @% @) ^, Z; [( H30.2 硬件设计
STM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的引脚分配如下：
2 x( c6 v: `  L& v4 [; V( G! H
串口USART1  TX = PA9，   RX = PA10

" F& j1 o0 F0 [6 O. p! j) W串口USART2  TX = PA2，   RX = PA3

/ _/ j5 s6 T' s' A; L9 [( b串口USART3  TX = PB10，  RX = PB11

串口UART4   TX = PC10，  RX = PC11 （和SDIO共用）
* C7 B/ y  `2 d& l, ^
6 F: Z6 K- W1 N' `# K串口UART5   TX = PC12，  RX = PD2  （和SDIO共用）

- b& q" F2 n* J串口USART6  TX = PG14，  RX = PC7  
$ u# q, S; Y- x6 l6 S3 O
) D; e/ o& P  f, t( h串口UART7   TX = PB4，   RX = PB3  （和SPI1/3共用）
0 u" y6 Y" @3 k; t& O
串口UART8   TX = PJ8，   RX =PJ9   （和RGB硬件接口共用）
$ [. w( a# O+ C7 e1 l. X
6 q% P) d8 ^+ I) l/ H0 [STM32-V7开发板使用了4个串口设备。
# N: b# n+ u. S6 s" U, y: R
  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
( y8 z/ P; H" a2 T0 Q  串口3用于RS485接口
8 f# @. h5 p6 C; k  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是RS232的原理图：

" n, v! y( `  R% x% F8 |

关于232的PHY芯片SP3232E要注意以下几个问题：

  SP3232E的作用是TTL电平转RS232电平。
* e  x* K% s; @' L  电阻R130的作用是避免CPU复位期间，TX为高阻时串口线上出现异常数据。
! c. D3 _  x9 L% w+ S4 P: n  检测SP3232E的好坏可以采用回环的方式，即短接T1OUT和R1IN，对应到DB9插座上就是短接引脚2和引脚3。

* \  U% e% W; M! y4 Q实际效果如下：
, b7 X' u) T" {% P8 I/ T

' Y, c$ J! ]+ Q7 P4 m5 N
通过这种方式，可以在应用程序中通过串口发送几个字符，查看是否可以正确接收来判断232 PHY芯片是否有问题。

  由于这里是TTL转RS232，如果电脑端自带DB9串口，可以找根交叉线直接接上。如果电脑端没有，就需要用RS232转USB的串口线。这里要注意是RS232转USB，不是TTL转USB。像我们用的CH340就是RS232转USB芯片。
  检测串口线的好坏跟板子上的232 PHY一样，将电脑端的串口助手打开，串口线接到电脑端并短接串口线的2脚和3脚，然后使用串口助手进行自收发测试即可。
30.3 串口FIFO驱动设计
30.3.1 串口FIFO框架
1 n# i5 Z  ^: W" v) _% |! r为了方便大家理解，先来看下串口FIFO的实现框图：
2 Y0 G/ K# q. Y8 K; c
& @- I, T; p" \, W0 n

) v8 F; G' r0 U# S7 h  第1阶段，初始化：
6 M5 y* Y6 a5 g" q! k
通过函数bsp_InitUart初始化串口结构体，串口硬件参数。
  第2阶段，串口中断服务程序：
% i3 D8 H( I! p2 B+ [) d2 R+ J
  接收中断是一直开启的。
  做了发送空中断和发送完成中断的消息处理。
, [2 q+ R/ J3 S3 c: r  第3阶段，串口数据的收发：
, R# }) y/ t- u' Z' F
( Y3 Z' G' p* C% X  串口发送函数会开启发送空中断。
  串口接收中断接收到函数后，可以使用函数comGetChar获取数据。
0 Q, Y; g( z2 C  L2 @30.3.2 串口FIFO之相关的变量定义
. W: q; E4 N" }9 q+ x3 @6 J串口驱动的核心文件为：bsp_uart_fifo.c, bsp_uart_fifo.h。
! l4 n) N, i" d2 d+ D: r- \
4 \' k$ r, Y/ e, O1 z这里面包括有串口硬件的配置函数、中断处理函数，以及串口的读写接口函数。还有ptinft函数的实现。

每个串口都有2个FIFO缓冲区，一个是用于发送数据的TX_FIFO，一个用于保存接收数据的RX_FIFO。
) \9 Y3 P5 J- j5 ]8 ~. i& o
+ k+ O3 ]- F7 m7 `% R2 O我们来看下这个FIFO的定义，在bsp_uart_fifo.h文件。

1. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
   8 h; ^5 r0 Z/ `3 X/ b7 y7 U
2. #if UART1_FIFO_EN == 1
   
3.         #define UART1_BAUD                        115200
   * l2 |; {  u0 Q0 b/ ?# U
4.         #define UART1_TX_BUF_SIZE        1*1024
   
5.         #define UART1_RX_BUF_SIZE        1*1024
   
6. #endif
   
7. 
   
8. /* 串口设备结构体 */
     K- ?+ [, d  D, X8 b/ n
9. typedef struct
   
10. {
    ( y9 w0 C( F/ m# u. g
11.         USART_TypeDef *uart;                /* STM32内部串口设备指针 */
    ; j! C. y$ U" F- b5 t# x6 I; ?/ j* K
12.         uint8_t *pTxBuf;                        /* 发送缓冲区 */
    + p6 M0 Y2 F3 |4 A# d
13.         uint8_t *pRxBuf;                        /* 接收缓冲区 */
    # Z) J5 F: u3 A8 M% l0 t! D' s0 V
14.         uint16_t usTxBufSize;                /* 发送缓冲区大小 */
    
15.         uint16_t usRxBufSize;                /* 接收缓冲区大小 */
    , E$ U5 W, L( ~  C
16.         __IO uint16_t usTxWrite;        /* 发送缓冲区写指针 */
    
17.         __IO uint16_t usTxRead;                /* 发送缓冲区读指针 */
    
18.         __IO uint16_t usTxCount;        /* 等待发送的数据个数 */
    
19. 
    : z5 g' r% K4 c# J
20.         __IO uint16_t usRxWrite;        /* 接收缓冲区写指针 */
    
21.         __IO uint16_t usRxRead;                /* 接收缓冲区读指针 */
    + V" V* ~8 c0 B
22.         __IO uint16_t usRxCount;        /* 还未读取的新数据个数 */
    
23. 
    7 Y; S' v3 w. |. M+ N
24.         void (*SendBefor)(void);         /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
    
25.         void (*SendOver)(void);         /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
    & O* C2 e4 ~: c1 M& O
26.         void (*ReciveNew)(uint8_t _byte);        /* 串口收到数据的回调函数指针 */
    
27.         uint8_t Sending;                        /* 正在发送中 */
    " H) q1 U4 G. n5 s
28. }UART_T;

复制代码

0 n( [- K; K& D& Q2 j7 L" @' u1 Pbsp_uart_fifo.c文件定义变量。我们以串口1为例，其他的串口都是一样的代码。
* W6 T( x9 L- p% O; A  A

1. /* 定义每个串口结构体变量 */
   9 W$ |3 E# n& q/ i4 J0 a7 U3 F1 F
2. #if UART1_FIFO_EN == 1
   
3.         static UART_T g_tUart1;
   ; G2 o8 a1 o& {0 I# Q
4.         static uint8_t g_TxBuf1[UART1_TX_BUF_SIZE];                /* 发送缓冲区 */
   
5.         static uint8_t g_RxBuf1[UART1_RX_BUF_SIZE];                /* 接收缓冲区 */
   3 `" W# F0 o# B2 m/ ]
6. #endif

复制代码

7 g5 R2 a1 ~" V. a1 H1 t4 e0 J关于FIFO的机制，我们在按键FIFO驱动已经做过详细的介绍，这个地方就不赘述了。每个串口有两个FIFO缓冲区，每个FIFO对应一个写指针和一个读指针。这个结构中还有三个回调函数。回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。
8 Z, P+ ^' z" s3 L$ A
30.3.3 串口FIFO初始化
串口的初始化代码如下；

1. /*
   ' L0 s. M  z2 i( ^
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitUart
   " `$ n& U3 F0 b5 M! J& }5 P" _
4. *        功能说明: 初始化串口硬件，并对全局变量赋初值.
   ( {* b" p9 B. v
5. *        形    参: 无
     z' j: I1 ^/ @9 o* b
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitUart(void)
   
10. {
    
11.         
    
12.         UartVarInit();        /* 必须先初始化全局变量,再配置硬件 */
    * D" E5 Q, m4 P" ^' d
13. 
    1 c8 c* [$ m; J6 d( \- B( ]
14.         InitHardUart();    /* 配置串口的硬件参数(波特率等) */
    
15. 
    
16.         RS485_InitTXE();        /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */
    
17. }
    

复制代码

' Y1 z: C% n& q
下面将初始化代码实现的功能依次为大家做个说明。
: w# Q' h" B- q. b6 M
& J+ [2 [+ A9 ?2 ^" W3 C% N  函数UartVarInit
4 E# y, L8 B  Q9 z- Q. n这个函数实现的功能比较好理解，主要是串口设备结构体变量的初始化，代码如下：
$ N3 x( ^% A: K6 p: R+ H5 o+ V  s0 G
1 ], ?% g6 G: ^" X3 I- F, `

1. /*
   + J' d( _' ^3 I- y: {
2. *********************************************************************************************************
   
3. *        函 数 名: UartVarInit
   
4. *        功能说明: 初始化串口相关的变量
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   " w( c  Z$ i. Y8 f
7. *********************************************************************************************************
   
8. */
   * q# e' c6 G, o2 J( l6 T3 m
9. static void UartVarInit(void)
   - m3 R+ I5 H; M0 F+ K; ^( J
10. {
    
11. #if UART1_FIFO_EN == 1
    
12.         g_tUart1.uart = USART1;                                                /* STM32 串口设备 */
    
13.         g_tUart1.pTxBuf = g_TxBuf1;                                        /* 发送缓冲区指针 */
    / H, W: V$ Y, v- ^0 m/ O
14.         g_tUart1.pRxBuf = g_RxBuf1;                                        /* 接收缓冲区指针 */
    
15.         g_tUart1.usTxBufSize = UART1_TX_BUF_SIZE;             /* 发送缓冲区大小 */
    
16.         g_tUart1.usRxBufSize = UART1_RX_BUF_SIZE;             /* 接收缓冲区大小 */
    ' E1 {* M& N( e% Z4 O
17.         g_tUart1.usTxWrite = 0;                                                /* 发送FIFO写索引 */
    
18.         g_tUart1.usTxRead = 0;                                                /* 发送FIFO读索引 */
    1 i) A0 o% H, `. F; B
19.         g_tUart1.usRxWrite = 0;                                                /* 接收FIFO写索引 */
    
20.         g_tUart1.usRxRead = 0;                                                /* 接收FIFO读索引 */
    
21.         g_tUart1.usRxCount = 0;                                                /* 接收到的新数据个数 */
    # O# ?% U5 M: k8 d! q
22.         g_tUart1.usTxCount = 0;                                                /* 待发送的数据个数 */
    
23.         g_tUart1.SendBefor = 0;                                                /* 发送数据前的回调函数 */
      M& q4 n* {$ G7 C4 _2 Z
24.         g_tUart1.SendOver = 0;                                                /* 发送完毕后的回调函数 */
    4 s, L" W# O7 k8 z0 R
25.         g_tUart1.ReciveNew = 0;                                                /* 接收到新数据后的回调函数 */
    
26.         g_tUart1.Sending = 0;                                                /* 正在发送中标志 */
    
27. #endif
    9 j: i6 c6 x8 d1 F" Y
28.     /* 串口2-8的初始化省略未写 */
    
29. }

复制代码

6 @% ~! p$ x, w7 }9 T: D  函数InitHardUart
此函数主要用于串口的GPIO，中断和相关参数的配置。

' V. b. y1 H" }

1. 1.        /* 串口1的GPIO  PA9, PA10   RS323 DB9接口 */
   8 p9 G& d2 I2 @9 N* Y- r" ~
2. 2.        #define USART1_CLK_ENABLE()              __HAL_RCC_USART1_CLK_ENABLE()
   
3. 3.        
   
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
   
7. 7.        #define USART1_TX_AF                     GPIO_AF7_USART1
   2 H: d" Z! A$ ~- O
8. 8.        
   8 J; a% a8 ?. ]- ^+ `- p
9. 9.        #define USART1_RX_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
   & H( t+ ^: L5 a4 r8 y! z) c
10. 10.        #define USART1_RX_GPIO_PORT              GPIOA
    
11. 11.        #define USART1_RX_PIN                    GPIO_PIN_10
    
12. 12.        #define USART1_RX_AF                     GPIO_AF7_USART1
    + B5 v9 |, ?! V9 k) I9 z2 P7 T" `
13. 13.        
    * K5 e& q1 C) }! p
14. 14.        /* 串口2-8的引脚和时钟宏定义未写 */
    
15. 15.        
    
16. 16.        /*
    
17. 17.        ******************************************************************************************************
    
18. 18.        *        函 数 名: InitHardUart
    
19. 19.        *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32-H7开
    ) O+ w% Z5 k& i5 W8 n3 K' D
20. 20.        *              发板
    , L0 f1 H, h: f+ @" A4 R3 y
21. 21.        *        形    参: 无
    & D5 X. T: Y! q& V0 Y8 j" p5 W( c
22. 22.        *        返 回 值: 无
    . n  D+ H0 V% Y7 t: p0 W, v
23. 23.        ******************************************************************************************************
    % g0 Z* @) _" G
24. 24.        */
    ) _. v, W: G. a* Z# `0 _
25. 25.        static void InitHardUart(void)
    ; X/ D5 _2 e3 E. A9 B; [
26. 26.        {
    
27. 27.                GPIO_InitTypeDef  GPIO_InitStruct;
    
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。
    - D3 W, R6 |$ k: T1 j
34. 34.            */
    . s) r- Y! v2 G1 X9 W# g
35. 35.                RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
    0 }) v# H, }2 m. C8 o" s
36. 36.                RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
    
37. 37.                HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);        
    % R& Z, A# r9 K2 D
38. 38.        
    - D! h2 E2 U) p
39. 39.        #if UART1_FIFO_EN == 1                /* 串口1 */
    " e2 K- t" }& L9 P! Z3 Q
40. 40.                /* 使能 GPIO TX/RX 时钟 */
    
41. 41.                USART1_TX_GPIO_CLK_ENABLE();
    
42. 42.                USART1_RX_GPIO_CLK_ENABLE();
    
43. 43.               
    
44. 44.                /* 使能 USARTx 时钟 */
    
45. 45.                USART1_CLK_ENABLE();        
    
46. 46.        
    3 T4 k+ G* D  l9 |/ F, f
47. 47.                /* 配置TX引脚 */
    6 h8 F' \% ?) k
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;
    
52. 52.                GPIO_InitStruct.Alternate = USART1_TX_AF;
    
53. 53.                HAL_GPIO_Init(USART1_TX_GPIO_PORT, &GPIO_InitStruct);        
    
54. 54.               
    ) d6 `; D2 F& `9 t, A4 @0 A+ z
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);
    
59. 59.        
    
60. 60.                /* 配置NVIC the NVIC for UART */   
    
61. 61.                HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
    " W8 f" i; d0 g& Y5 [1 w
62. 62.                HAL_NVIC_EnableIRQ(USART1_IRQn);
    
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发送完成标志 */
    
68. 68.                SET_BIT(USART1->RQR, USART_RQR_RXFRQ);  /* 清除RXNE接收标志 */
    : K* x- c6 |: l8 J! d. b) z: x
69. 69.                // USART_CR1_PEIE | USART_CR1_RXNEIE
    
70. 70.                SET_BIT(USART1->CR1, USART_CR1_RXNEIE); /* 使能PE. RX接受中断 */
      N9 x# ]1 q( a: _
71. 71.        #endif
    * c. y& T  H+ a: O9 o9 W
72. 72.        /* 串口2-8的初始化省略未写 */
    
73. 73.        }

复制代码

6 O% X% ]/ J$ O4 S! G. J  第2-12行，以宏定义的方式设置串口1-8的GPIO时钟、引脚和串口时钟，方便修改。
  第35-37行，这里的配置可以注释掉，预留下来仅仅是为了方便以后选择其它时钟使用。默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
. l# H# T6 C% \6 m8 e$ D3 `; ]  第61-62行，配置串口中断优先级并使能串口中断，用户可以根据实际工程修改优先级大小。
  第65行，配置串口的基本参数，具体配置在函数里面有注释。
5 G+ }- U& k6 k

1. /*
   
2. *********************************************************************************************************
   0 I- S' C8 q* c% y) z$ Z! h7 v1 j% q4 n
3. *        函 数 名: bsp_SetUartParam
   
4. *        功能说明: 配置串口的硬件参数（波特率，数据位，停止位，起始位，校验位，中断使能）适合于STM32- H7开发板
   : _1 M. o" T* }+ g" W5 `# n
5. *        形    参: Instance   USART_TypeDef类型结构体
   & [4 m" E5 Q7 w! b7 v& e# [+ ~2 b
6. *             BaudRate   波特率
   
7. *             Parity     校验类型，奇校验或者偶校验
   
8. *             Mode       发送和接收模式使能
   
9. *        返 回 值: 无
   
10. *********************************************************************************************************
    
11. */
    ' Y  H9 d( m3 z; B
12. void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode)
    
13. {
    ! ~2 X; K' X! G) j
14.         UART_HandleTypeDef UartHandle;        
    ! o! r# N' p* S; w5 Z# g9 u1 x
15.         
    
16.         /*##-1- 配置串口硬件参数 ######################################*/
    
17.         /* 异步串口模式 (UART Mode) */
    + z; Z/ E. z) c% A  r  x1 N
18.         /* 配置如下:
    
19.           - 字长    = 8 位
    % G+ q; W7 C) U* c; v+ Q
20.           - 停止位  = 1 个停止位
    & t. U" k. a) O- e
21.           - 校验    = 参数Parity
    
22.           - 波特率  = 参数BaudRate
    7 ^& u8 ]- ]$ q0 }- P7 l8 r
23.           - 硬件流控制关闭 (RTS and CTS signals) */
    / _, q- w' d9 H! K7 w. u
24. 
    
25.         UartHandle.Instance        = Instance;
    & N7 a/ v. ^$ s+ O1 b+ p) ?
26. 
    / s6 v& x; }3 [' Z
27.         UartHandle.Init.BaudRate   = BaudRate;
    - s* A5 Z. r) o: |7 `" T
28.         UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    
29.         UartHandle.Init.StopBits   = UART_STOPBITS_1;
    
30.         UartHandle.Init.Parity     = Parity;
    5 E* D0 I+ z5 i
31.         UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    2 i' Z; K4 R% Q/ [' l7 I% G
32.         UartHandle.Init.Mode       = Mode;
    
33.         UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    
34.         UartHandle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    . H$ Z+ \% t% `8 [+ B' }
35.         UartHandle.Init.Prescaler = UART_PRESCALER_DIV1;
    / c- f' h2 v4 h% ]
36.         UartHandle.Init.FIFOMode = UART_FIFOMODE_DISABLE;
    
37.         UartHandle.Init.TXFIFOThreshold = UART_TXFIFO_THRESHOLD_1_8;
    % v! @1 C8 ~  D# y
38.         UartHandle.Init.RXFIFOThreshold = UART_RXFIFO_THRESHOLD_1_8;
    , x8 U% O0 \- y* j
39.         UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
40. 
    5 V! N6 ]9 j6 ?+ N
41.         if (HAL_UART_Init(&UartHandle) != HAL_OK)
    4 J: ]+ L( j( U0 ]4 m% A# f
42.         {
      ?' s. s2 s- c' a* q- ?: u
43.                 Error_Handler(__FILE__, __LINE__);
    
44.         }
    # b$ T$ R+ Z0 N7 z
45. }

复制代码

5 z1 Q/ \: I- C* X  函数RS485_InitTXE
5 l4 R: H! T- V/ B) d8 N5 `% {此函数主要用于485 PHY芯片的发送使能，直接配置引脚为推挽输出模式即可使用。具体代码如下：

4 e. I. w, H: ]& I+ _4 M. n2 D2 s% `1 D

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: RS485_InitTXE
   . i8 o0 ?  `) v' p0 q
4. *        功能说明: 配置RS485发送使能口线 TXE
   
5. *        形    参: 无
   ) M" C& _: |( Y4 m
6. *        返 回 值: 无
   5 _8 q$ _- V5 @" j
7. *********************************************************************************************************
   2 S3 P, U2 {+ X/ ^
8. */
   
9. void RS485_InitTXE(void)
   
10. {
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         
    
13.         /* 打开GPIO时钟 */
    3 H# V% C7 d0 r/ C* i- @" Q0 p
14.         RS485_TXEN_GPIO_CLK_ENABLE();
    + @1 U3 Z1 z0 ~: ?% f; b' ?8 h, Z
15.         
      z) q  V, f# p2 P5 ]5 N  X7 a/ u6 v3 i
16.         /* 配置引脚为推挽输出 */
    + d7 ^+ }6 R8 B9 i: c+ s( L
17.         gpio_init.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
18.         gpio_init.Pull = GPIO_NOPULL;                             /* 上下拉电阻不使能 */
    
19.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;        /* GPIO速度等级 */
    0 J7 K$ H9 t3 y" {8 F  S0 B6 m
20.         gpio_init.Pin = RS485_TXEN_PIN;
    
21.         HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);        
    
22. }

复制代码

" g8 j# Q7 G5 \% _# d$ y30.3.4 串口中断服务程序工作流程
8 ]5 ?+ Y, z. u, M串口中断服务程序是最核心的部分，主要实现如下三个功能
0 R# c  J: M4 l/ D
  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  如果是RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。
: |. h2 R/ B- K4 U8 _

" v+ G6 l( T. r$ J: P+ W下面我们分析一下串口中断处理的完整过程。

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

  S3 g9 H0 t6 J6 e# h我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序：
2 I! H- Z7 N/ p4 j" D& i/ l
* u+ C0 U5 k$ r/ {% P& [% b- ]

1. #if UART1_FIFO_EN == 1
   % Y9 F% _( ~: Y% F+ m% Z
2. void USART1_IRQHandler(void)
   
3. {
   # z& M, K. T2 u) D$ f
4.         UartIRQ(&g_tUart1);
   * P# I/ n& E" X4 w
5. }
   
6. #endif
   5 z: [" v" ]% i( l( q, V
7. 
   . r; p+ M( x% M# N7 X
8. #if UART2_FIFO_EN == 1
   / l7 @$ c1 J2 @8 h
9. void USART2_IRQHandler(void)
   : z/ c4 |' `7 ^2 j. D# ?" l4 Q1 R
10. {
    - q% ]) u: T. X, a
11.         UartIRQ(&g_tUart2);
    2 |$ a  ~; {+ \/ X3 D2 y: ^
12. }
    
13. #endif
    
14. 
    * W3 i: c& x/ |" ]/ u
15. #if UART3_FIFO_EN == 1
    2 F; {: C) M- f/ @: o' A( s' H
16. void USART3_IRQHandler(void)
    1 ~( c0 {1 L$ {9 m$ T# I
17. {
    
18.         UartIRQ(&g_tUart3);
    
19. }
    + h, c, q, L1 @
20. #endif
    
21. 
      `, b" y( J8 l7 i- O
22. #if UART4_FIFO_EN == 1
    
23. void UART4_IRQHandler(void)
    
24. {
    
25.         UartIRQ(&g_tUart4);
    
26. }
    
27. #endif
    
28. 
      h" _, }( s2 N+ O0 J- U, g
29. #if UART5_FIFO_EN == 1
    
30. void UART5_IRQHandler(void)
    # U! h- M4 [+ d' O
31. {
    . O* b4 Z1 A( {+ J8 S- K, q
32.         UartIRQ(&g_tUart5);
    % n4 \# K: ^5 n. `% @
33. }
    
34. #endif
    
35. 
    
36. #if UART6_FIFO_EN == 1
    
37. void USART6_IRQHandler(void)
    
38. {
    
39.         UartIRQ(&g_tUart6);
    
40. }
    
41. #endif
    ' V- j7 Z& L8 }8 }' {0 w; R4 `) b
42. 
    ( g, O$ K) |1 o$ G6 @% Z. ~8 e* t
43. #if UART7_FIFO_EN == 1
    
44. void UART7_IRQHandler(void)
    , q7 f0 X& G: ?1 Q% A. w8 Q. T
45. {
    * U! N' @! S' T; r
46.         UartIRQ(&g_tUart7);
    
47. }
    
48. #endif
    - ?& h& E7 J0 x0 s3 T$ U; w
49. 
    
50. #if UART8_FIFO_EN == 1
    ! c1 G& M, `# N) F/ y! e
51. void UART8_IRQHandler(void)
    
52. {
    
53.         UartIRQ(&g_tUart8);
    ' ]& {4 I4 _) g
54. }
    
55. #endif

复制代码

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

下面，我们来看看UartIRQ函数的实现代码。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: UartIRQ
   
4. *        功能说明: 供中断服务程序调用，通用串口中断处理函数
   6 R0 o1 p- _# h& M" O+ x
5. *        形    参: _pUart : 串口设备
   5 R- r. ^, Q! {& o
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   . `$ M4 K$ n$ k2 [
8. */
   7 r0 T$ C6 `; x* Q) h& m
9. static void UartIRQ(UART_T *_pUart)
   " V$ i; e0 D% P# N  ?+ s* @
10. {
    
11.         uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
    
12.         uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
      p8 C1 C- h# F/ X
13.         uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
    9 U6 I4 S  B; R% y" u, a
14.         
    / r& D9 d) K! p# P) p
15.         /* 处理接收中断  */
    : O: }+ e- v3 u* F: F6 _' J: M
16.         if ((isrflags & USART_ISR_RXNE) != RESET)
    
17.         {
    8 _( b" X2 ]4 v- U
18.                 /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    . V! @& x3 J' E4 g
19.                 uint8_t ch;
    
20. 
    
21.                 ch = READ_REG(_pUart->uart->RDR);               /* 读串口接收数据寄存器 */
    
22.                 _pUart->pRxBuf[_pUart->usRxWrite] = ch;         /* 填入串口接收FIFO */
    / B, r/ B1 b5 H  m# P
23.                 if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
    
24.                 {
    
25.                         _pUart->usRxWrite = 0;
    ) A  U' N9 c/ M" W% M$ h7 T* j
26.                 }
    # H- P+ \/ n; E. K; d+ o) l: [
27.                 if (_pUart->usRxCount < _pUart->usRxBufSize)    /* 统计未处理的字节个数 */
    
28.                 {
    
29.                         _pUart->usRxCount++;
    
30.                 }
    . e& a8 E  z+ Q; ]
31. 
    
32.                 /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    3 E- \/ w& _1 d, B6 I8 m1 U+ r
33.                 //if (_pUart->usRxWrite == _pUart->usRxRead)
    - `. P4 Z* U3 N& X5 Y7 s# c
34.                 //if (_pUart->usRxCount == 1)
    6 I/ G; e* v+ l( ~; d3 g& ]
35.                 {
      o' [* J' ^( g
36.                         if (_pUart->ReciveNew)
      p' {% Y3 v1 P( ^7 s2 N+ ]  }
37.                         {
    / k  Z, w/ w+ B, Y7 T$ L
38.                                 _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
    8 P/ H# J- c. m8 }! [
39.                         }
    8 K6 W9 v! l" b, J+ m8 ?
40.                 }
    : B( X$ G3 ^1 ]8 b
41.         }
    
42. 
    
43.         /* 处理发送缓冲区空中断 */
    
44.         if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
    
45.         {
    ! C2 ^& C( a+ d
46.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    3 @3 ~/ _6 K2 R
47.                 if (_pUart->usTxCount == 0)  /* 发送缓冲区已无数据可取 */
    
48.                 {
    ; j) x/ u$ z* c/ j- z
49.                 /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
    
50.                         //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
    & ]8 s6 k3 J  I8 E- l2 D0 q
51.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    ; G5 I- _- P- L4 S# T( N5 i2 A8 Q
52. 
    
53.                         /* 使能数据发送完毕中断 */
    $ o# R% ?5 k/ T9 D5 S
54.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
    
55.                         SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
56.                 }
    
57.                 Else  /*　还有数据等待发送 */
    
58.                 {
    , k$ Y5 c- r6 G
59.                         _pUart->Sending = 1;
    % }4 n7 H* a3 Z+ C$ ?
60.                         
    
61.                         /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
    
62.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
63.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
64.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    
65.                         {
    
66.                                 _pUart->usTxRead = 0;
    
67.                         }
    
68.                         _pUart->usTxCount--;
    
69.                 }
    
70. 
    9 L% v1 E! R5 R# J
71.         }
    ( V9 m( j& Q4 e& p
72.         /* 数据bit位全部发送完毕的中断 */
    
73.         if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
    
74.         {
    
75.                 //if (_pUart->usTxRead == _pUart->usTxWrite)
    $ @3 a4 H. g0 G1 K4 [0 F
76.                 if (_pUart->usTxCount == 0)
    + x0 e+ P: C0 s% z3 Q9 u
77.                 {
    4 e, s5 F' k+ I
78.                         /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
    2 E- H1 q2 P3 G* p/ [. T  p
79.                         //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
    0 T) U9 T$ x9 G: J
80.                         CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    
81. 
    
82.                         /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
    , t$ ^; P) t( ~( g4 w& U
83.                         if (_pUart->SendOver)
    
84.                         {
    ( M1 W" G; ?' V7 Q6 U; ^3 y; T
85.                                 _pUart->SendOver();
    1 \0 S- p# g& |8 x0 R+ ~/ d) o9 q
86.                         }
    
87.                         
    3 u9 c3 c0 `% I; ~
88.                         _pUart->Sending = 0;
    * f! w: u/ E% Z$ }
89.                 }
    
90.                 else
    
91.                 {
    
92.                         /* 正常情况下，不会进入此分支 */
    , E" A( P! H& l
93. 
    . R6 ~1 i; d* |
94.                         /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
    # N, z% }( J1 E" L
95.                         //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
    
96.                         _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
    
97.                         if (++_pUart->usTxRead >= _pUart->usTxBufSize)
    ; u2 D9 o# H' V8 E" t
98.                         {
    
99.                                 _pUart->usTxRead = 0;
    
100.                         }
     - W8 l- _- v9 |' D( t$ q
101.                         _pUart->usTxCount--;
     
102.                 }
     
103.         }
     2 d; |' f$ r5 z% X( v* e1 e) g9 M# p/ N7 j
104.         
     
105.         /* 清除中断标志 */
     2 L* L. z1 I. X( S7 E
106.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
     ! z  x6 M& q3 F% E0 O
107.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
     
108.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
     
109.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
     ( o2 a5 c( ^9 I5 q. n
110.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
     + {! G; J; o7 g4 i7 R% a" d, @7 W4 N
111.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
     6 }6 Y7 C4 o5 Z
112.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
     . t4 ?  j- E! X7 |4 U/ _% W" C! l
113.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
     2 F! i$ ~1 ?! ^/ W  ]1 q8 W
114.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
     7 w: N& q0 c$ a9 ~9 k7 Q3 \
115.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
     
116.         SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);        
     1 a9 v. ^) e; I$ o9 d- v, n* b
117. }

复制代码

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

" s- B& w( q' h3 N  接收数据处理
( |  \1 _- A! z, l) ]接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。

特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。
1 x8 K' }5 V; h1 H. V
  发送数据处理
: ?: m" K; K) p6 p( y发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

+ p7 Z; U- A& F2 v% ^& i8 m  J9 B30.3.5 串口数据发送
串口数据的发送主要涉及到下面三个函数：

1. /*
   " a$ C+ A; r* l* T* J% g" y$ s" L( j
2. *********************************************************************************************************
   
3. *        函 数 名: comSendBuf
   
4. *        功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
   ) n7 n4 @" O3 p9 {
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   6 o9 J7 d" |: U3 A1 F
6. *                          _ucaBuf: 待发送的数据缓冲区
   + O7 O  ~5 N* r# s
7. *                          _usLen : 数据长度
   $ N4 K/ G: o( S3 I9 u& H$ p7 A$ S
8. *        返 回 值: 无
   & b$ a9 W3 Y( [0 O' [
9. *********************************************************************************************************
   9 x  {1 s: J, S$ e( j
10. */
    
11. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
      p; W) |1 o5 Z; {
12. {
    $ @% v& s' r4 A+ [9 `, s" J
13.         UART_T *pUart;
    
14. 
    5 v5 x* G$ L2 @: L8 S# q
15.         pUart = ComToUart(_ucPort);
    $ |* E6 h" @4 Y9 e& N" h
16.         if (pUart == 0)
    
17.         {
    
18.                 return;
    
19.         }
    ( w2 Z2 k. V* G. l: ^) q
20. 
    
21.         if (pUart->SendBefor != 0)
    $ }' M) ^& H' T3 E% H
22.         {
    # a6 H% j/ r) L$ A5 v+ N
23.                 pUart->SendBefor();                /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
    
24.         }
    
25. 
    $ h$ }$ ~6 j" _1 [$ r
26.         UartSend(pUart, _ucaBuf, _usLen);
    ( P) a; A2 B% s* H
27. }
    
28. 
    
29. /*
    $ W9 y. y2 u. D
30. *********************************************************************************************************
    
31. *        函 数 名: comSendChar
    
32. *        功能说明: 向串口发送1个字节。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
    % O; |, m  D- q: i) ?8 d
33. *        形    参: _ucPort: 端口号(COM1 - COM8)
    1 A9 Q2 I5 `, }0 N# l
34. *                          _ucByte: 待发送的数据
    
35. *        返 回 值: 无
    + P' O; z3 T: g4 F- L0 g) u: i) s
36. *********************************************************************************************************
    
37. */
    
38. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
    : ]' a' P0 S, \. F6 I
39. {
    : Z" @( s6 T- J8 ?
40.         comSendBuf(_ucPort, &_ucByte, 1);
    ! [' H* y  M3 f' U
41. }
    ; j; {7 I( S  O& E" r2 f
42. /*
    
43. *********************************************************************************************************
    
44. *        函 数 名: UartSend
    * H  {1 ]- F# ?
45. *        功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断
    
46. *        形    参: 无
    
47. *        返 回 值: 无
      a$ `  [; _4 E. b3 U
48. *********************************************************************************************************
    
49. */
    4 i3 Z, L' u+ ~) @
50. static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
    4 {' y9 q0 i8 J# P4 I/ H! L5 a
51. {
    
52.         uint16_t i;
    + L' f- {! y8 c( A
53. 
    
54.         for (i = 0; i < _usLen; i++)
    
55.         {
    
56.                 /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    ( K& v# g: A% _* g5 u  f6 A3 W
57.                 while (1)
    
58.                 {
    7 H9 K/ L+ }% Q& T
59.                         __IO uint16_t usCount;
      x' m* E* m5 l: `
60. 
    % u/ q* j' N7 G* V
61.                         DISABLE_INT();
    
62.                         usCount = _pUart->usTxCount;
    ' U# W0 O, b: h1 z& V* H1 ~
63.                         ENABLE_INT();
    ( O* H6 k* O9 s2 x# ]! ?
64. 
    * [) g. X4 N* ^3 o2 g
65.                         if (usCount < _pUart->usTxBufSize)
    6 e' B& S0 Z; G
66.                         {
    
67.                                 break;
    ' y& t8 d$ H+ N& P2 F
68.                         }
    
69.                         else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
    0 ]; v! D, x9 s' V' {* a% V, i
70.                         {
    
71.                                 if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
    
72.                                 {
    4 k2 y) b8 O1 l8 G. R, w; n
73.                                         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
    - Y! q' q0 O1 M9 R2 F
74.                                 }  
    * L% R4 x+ k. y! |, {! i6 N" v
75.                         }
    
76.                 }
    
77. 
    ; f4 d5 d+ R' k9 Q1 d, s
78.                 /* 将新数据填入发送缓冲区 */
    
79.                 _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;
    
80. 
    
81.                 </i>DISABLE_INT();
    / B- c3 L$ m2 k$ a6 r& l/ }0 w1 i+ u
82.                 if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    
83.                 {
    7 Q; N$ }4 ]. p1 f+ \. J$ z
84.                         _pUart->usTxWrite = 0;
    9 X: D  R+ z" X+ f: f7 }) W& e
85.                 }
    3 _. W+ A) r1 Y
86.                 _pUart->usTxCount++;
    
87.                 ENABLE_INT();
    ' Z/ p2 z7 W, @
88.         }
    
89. 
    
90.         SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);        /* 使能发送中断（缓冲区空） */
    
91. }

复制代码

函数comSendChar是发送一个字节，通过调用函数comSendBuf实现，而函数comSendBuf又是通过调用函数UartSend实现，这个函数是重点。

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

5 u2 Z$ S) B" ]9 C5 ^  如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
8 j) @/ U3 Z# ?. M( \7 I  如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

+ N9 G$ R/ L& z# k2 e
注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数comSendChar和comSendBuf是供用户调用的。


0 l9 o9 }8 P/ ?# o) u
3 i: v8 z) }. e1 n函数comSendBuf中调用了一个函数pUart = ComToUart(_ucPort)，这个函数是将整数的COM端口号转换为UART结构体指针。
0 L, V5 x$ C9 E

1. /*
   + x0 |; A- o1 B* _% Z7 Q- U% N
2. *********************************************************************************************************
   
3. *        函 数 名: ComToUart
   ' c. B5 G9 _/ ?3 C2 S0 E% ]
4. *        功能说明: 将COM端口号转换为UART指针
   : V) L* v1 R2 ^0 J
5. *        形    参: _ucPort: 端口号(COM1 - COM8)
   
6. *        返 回 值: uart指针
   4 H/ T5 X* a3 j  o& |. d+ Q
7. *********************************************************************************************************
   
8. */
   $ r4 {/ ^3 l$ [6 O
9. UART_T *ComToUart(COM_PORT_E _ucPort)
     i/ O' @! X/ t: J* H2 |! D6 n
10. {
    ( A3 v( ^4 S1 O. d% c8 O, f& U
11.         if (_ucPort == COM1)
    
12.         {
    + [: u( Y' u9 J% N" m
13.                 #if UART1_FIFO_EN == 1
    ! P% k) w7 P# n& i) e+ @' e
14.                         return &g_tUart1;
    2 j# Q: |6 k- f' c/ c4 f8 L' D. J
15.                 #else
    
16.                         return 0;
    
17.                 #endif
    7 N/ I7 h; l4 S
18.         }
    
19.         else if (_ucPort == COM2)
    
20.         {
    % o3 |; I- A# h; n* {
21.                 #if UART2_FIFO_EN == 1
    9 P, s; q( h: y9 P& T
22.                         return &g_tUart2;
    
23.                 #else
    
24.                         return 0;
    
25.                 #endif
    
26.         }
    
27.         else if (_ucPort == COM3)
    
28.         {
    5 S4 D3 d+ c5 ?
29.                 #if UART3_FIFO_EN == 1
    " K+ f9 Z/ K2 u  H; E
30.                         return &g_tUart3;
    
31.                 #else
    # {* ~% N# Z% f) h) W4 z) n* q
32.                         return 0;
    
33.                 #endif
    2 K  ]* X6 ?9 `5 }
34.         }
    
35.         else if (_ucPort == COM4)
    
36.         {
    
37.                 #if UART4_FIFO_EN == 1
    % d3 v% r4 F, j) {
38.                         return &g_tUart4;
    
39.                 #else
    
40.                         return 0;
      U4 F  @+ T7 C. t: M' y0 b- F) L! b6 B
41.                 #endif
    : ~4 X: I5 ^: T0 l, J' p6 ~* U
42.         }
    
43.         else if (_ucPort == COM5)
    
44.         {
    % d  S+ u( ?# W# @
45.                 #if UART5_FIFO_EN == 1
    1 ?- Z8 E& u" \: X: B6 W) u
46.                         return &g_tUart5;
    8 ^4 i; ~' R$ r  n+ e& I6 I2 y, g; E% e
47.                 #else
    
48.                         return 0;
    : V2 j3 x- w% F+ F" O1 ?; n% [: a
49.                 #endif
    2 D+ o* ~2 x8 C! P: Z
50.         }
    
51.         else if (_ucPort == COM6)
    ) h# C; @' O' |0 e& y) B6 b
52.         {
    
53.                 #if UART6_FIFO_EN == 1
    
54.                         return &g_tUart6;
    0 A2 O1 R& M6 l
55.                 #else
    - h5 V; F. M" H( J
56.                         return 0;
    # I) V  E9 ]+ M5 h7 ?; I: Z
57.                 #endif
    1 H5 G" @: G4 f% T! h  y% P
58.         }
    
59.         else if (_ucPort == COM7)
    ( k. P/ P# _" W* [# I$ Q! y: k. q
60.         {
    ; [' J) ^! E* y2 \
61.                 #if UART7_FIFO_EN == 1
    ) y( f  p1 O( m1 v8 H7 N
62.                         return &g_tUart7;
    
63.                 #else
    3 ?' e$ [' W& v# H* q) |. L
64.                         return 0;
    
65.                 #endif
    ; ]7 h) t2 Z: b: O/ n. u; d
66.         }
    * o. A2 `; U- }; C5 a2 h
67.         else if (_ucPort == COM8)
    
68.         {
    & Y( Q' M. N: I6 v, M$ Q
69.                 #if UART8_FIFO_EN == 1
    7 T1 F2 X  q: i
70.                         return &g_tUart8;
    ( A  [; V  j" `
71.                 #else
      |* e2 q/ K5 S% m# W
72.                         return 0;
    
73.                 #endif
    
74.         }        
    
75.         else
    
76.         {
    
77.                 Error_Handler(__FILE__, __LINE__);
    
78.                 return 0;
    % Y0 l5 X4 s' z& n$ S
79.         }
    - p: @. r! M9 Q
80. }
    
81. 30.3.6 串口数据接收
    7 d/ V7 U+ w. T  T* L% {6 ?) Q1 @# u
82. 下面我们再来看看接收的函数：
    
83. 
    
84. /*
    
85. *********************************************************************************************************
    
86. *        函 数 名: comGetChar
    
87. *        功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
    
88. *        形    参: _ucPort: 端口号(COM1 - COM8)
    / Q/ j8 M+ ?# Y! u
89. *                          _pByte: 接收到的数据存放在这个地址
    
90. *        返 回 值: 0 表示无数据, 1 表示读取到有效字节
    / A( R9 @2 x' t5 g9 t
91. *********************************************************************************************************
    * p) m8 M4 }" y: d; `1 i
92. */
    9 g7 l7 b" X! T: e) [
93. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
    
94. {
    6 K! c) o/ U4 T% T% `, w% C
95.         UART_T *pUart;
    / k& G1 Y# R( O9 i" o
96. 
    6 V/ D2 Q/ Z. z, r, w# Y5 w. J. R
97.         pUart = ComToUart(_ucPort);
    ' q. y5 V  S" d9 K
98.         if (pUart == 0)
    3 L3 k8 `6 b. c3 g  A  Z0 y' T3 P
99.         {
    
100.                 return 0;
     6 C* e: I# d" A; q
101.         }
     
102. 
     3 x/ M: q6 v, _! v  z
103.         return UartGetChar(pUart, _pByte);
     
104. }
     8 v6 B. D; {* _/ ^, _
105. 
     
106. /*
     
107. *********************************************************************************************************
     
108. *        函 数 名: UartGetChar
     ! a! q/ m* U) J3 x9 \. D
109. *        功能说明: 从串口接收缓冲区读取1字节数据 （用于主程序调用）
     
110. *        形    参: _pUart : 串口设备
     
111. *                          _pByte : 存放读取数据的指针
     
112. *        返 回 值: 0 表示无数据  1表示读取到数据
     2 K% |5 k0 X4 L2 F& }
113. *********************************************************************************************************
     3 l6 Z2 ]: K9 g3 W! e( T. o
114. */
     4 T& S3 Z' U# F+ S, k" j4 P/ s* ^
115. static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
     9 R: W- C) Q# R# R' h
116. {
     . L2 w' G$ ?, B7 \7 J- U
117.         uint16_t usCount;
     
118. 
     
119.         /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
     , R. N. h5 j# R1 N9 C) v( ^2 F$ }3 Z3 l
120.         DISABLE_INT();
     
121.         usCount = _pUart->usRxCount;
     
122.         ENABLE_INT();
     3 y9 ?4 c3 r' o+ }
123. 
     
124.         /* 如果读和写索引相同，则返回0 */
     
125.         //if (_pUart->usRxRead == usRxWrite)
     
126.         if (usCount == 0)        /* 已经没有数据 */
     1 E9 |( d! o! p6 L
127.         {
     
128.                 return 0;
     
129.         }
     
130.         else
     # p; b* R$ ]9 k. _" S2 s
131.         {
     
132.                 *_pByte = _pUart->pRxBuf[_pUart->usRxRead];                /* 从串口接收FIFO取1个数据 */
     
133. 
     
134.                 /* 改写FIFO读索引 */
     
135.                 DISABLE_INT();
     
136.                 if (++_pUart->usRxRead >= _pUart->usRxBufSize)
     
137.                 {
     , G: f; A3 }1 y
138.                         _pUart->usRxRead = 0;
     # @4 k. d7 a$ I( z( r1 t
139.                 }
     
140.                 _pUart->usRxCount--;
     
141.                 ENABLE_INT();
     
142.                 return 1;
     , A3 Q4 W) V) X1 K  j6 s
143.         }
     
144. }

复制代码

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

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

  D$ R4 A* u1 {30.3.7 串口printf实现
printf函数是标准c库函数。最原来的意思是打印输出到显示器。在单片机，我们常用它来打印调试信息到串口，通过计算机上运行的串口软件来监视程序的运行状态。

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

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

实现printf输出到串口，只需要在工程中添加两个函数：
* b8 N0 W! O+ {; c1 l" [' h$ K

1. /*
   ( q8 B1 `+ n5 q& b
2. *********************************************************************************************************
   
3. *        函 数 名: fputc
   
4. *        功能说明: 重定义putc函数，这样可以使用printf函数从串口1打印输出
   + x$ U$ g" _& A, V$ D
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   / m/ J( ]% Q2 t9 E7 K, T. ?# F
9. int fputc(int ch, FILE *f)
   
10. {
    + w2 b) ]" w+ U" d
11. #if 1        /* 将需要printf的字符通过串口中断FIFO发送出去，printf函数会立即返回 */
    
12.         comSendChar(COM1, ch);
    % N5 j3 a& u9 i0 m( G5 g% }4 g
13.         
    * Y* ]) `0 d* n( X% K1 O8 a$ J( B! }
14.         return ch;
    
15. #else        /* 采用阻塞方式发送每个字符,等待数据发送完毕 */
    3 g* o/ M; H; n! D0 b) @" U
16.         /* 写一个字节到USART1 */
    
17.         USART1->TDR = ch;
    
18.         
    
19.         /* 等待发送结束 */
    
20.         while((USART1->ISR & USART_ISR_TC) == 0)
    
21.         {}
    
22.         
    8 f9 o% `8 A$ ?* |
23.         return ch;
    ; u+ {* Y3 B' ~, m: c% ~
24. #endif
    
25. }
    
26. 
    + h- M: d7 f$ W
27. /*
    
28. *********************************************************************************************************
    3 ^8 \/ g# ~& ]' c% c
29. *        函 数 名: fgetc
    
30. *        功能说明: 重定义getc函数，这样可以使用getchar函数从串口1输入数据
    % z( f( x( L1 h+ B9 b
31. *        形    参: 无
    6 Y# R3 ~9 ^, J1 s3 ]3 U  p
32. *        返 回 值: 无
    3 z; g: y9 z% j
33. *********************************************************************************************************
    
34. */
    
35. int fgetc(FILE *f)
    
36. {
    
37. 
    6 J6 E" J* f( T) X. }, V4 U
38. #if 1        /* 从串口接收FIFO中取1个数据, 只有取到数据才返回 */
    3 \+ S9 t! k4 T3 l
39.         uint8_t ucData;
    
40. 
    $ J- _8 ?! x+ m8 \4 b1 e. W$ {; p
41.         while(comGetChar(COM1, &ucData) == 0);
    6 H' N( c; }5 q3 }1 {+ Y3 t
42. 
    1 J( j" [$ {, X1 k. e* p
43.         return ucData;
    
44. #else
    
45.         /* 等待接收到数据 */
    ' Z; w2 c; ^' F1 N
46.         while((USART1->ISR & USART_ISR_RXNE) == 0)
    
47.         {}
    4 U1 W3 j9 Q5 P! j  T# h) i) O
48. 
    8 c% {7 H. f( h
49.         return (int)USART1->RDR;
    
50. #endif
      j0 s- _9 l, M/ z: a/ K
51. }

复制代码

) s6 x; n/ ~8 Rprintf函数是非阻塞的，执行后会立即返回，串口中断服务程序会陆续将数据发送出去。
0 b" t2 m' c$ D! s
30.4 串口FIFO板级支持包（bsp_uart_fifo.c）
串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

8 Q& b% I! a0 d3 a  bsp_InitUart
, H5 n0 J( P5 T* }! p8 T  comSendBuf
  comSendChar
  comGetChar
& K: ]) e& A( W; c9 \8 g% j1 U; W30.4.1 函数bsp_InitUart
函数原型：
4 q2 s( W$ x. q) b1 E. [

1. void bsp_InitUart(void)

复制代码

  I* d' J6 ?+ ]! u5 w( f  H: e函数描述：

; Q! q) R* l2 X* _* u此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。
1 a+ K, ]. S. t8 u6 e8 n; {  n
. d3 F# G0 Y; H( T) V- F+ g使用举例：

) h/ R$ z. A6 L1 l串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。
5 V, m& o" j* r* J8 V+ S
; t5 d- T: d- A, `  y6 u5 E7 _30.4.2 函数comSendBuf
函数原型：
* y- }* g! T. a1 S6 X/ u* ~

1. void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

复制代码

% R! w1 {' v6 D( s4 s8 T' S函数描述：

此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：

1 G- P) r5 @1 l  第1个参数_ucPort是端口号，范围COM1 - COM8。
) K5 e8 B* h* M) Y. N  第2个参数_ucaBuf是待发送的数据缓冲区地址。
8 b" }5 `, a2 L2 J  第3个参数_usLen是要发送数据的字节数。
3 O7 W' m$ m; v9 b) a注意事项：

. \0 h2 b/ a% r+ K  此函数的解读在本章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：
; N, B1 ]/ Y7 n) a5 s
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

( `; @4 n! l4 D

1. const char buf1[] = "接收到串口命令1\r\n";
   
2. comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));

复制代码

30.4.3 函数comSendChar
1 h2 n- p4 F; O4 n6 d  @; ^& }; u函数原型：

* `' b# ~; X- C* c( O

1. void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);

复制代码

+ Q( g9 w$ u; @3 A函数描述：
: X7 t7 D3 D* _: {0 C
9 H0 a4 ~8 M+ W* d2 @6 X此函数用于向串口发送1个字节，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。
+ [* N$ B( S6 U
函数参数：
% B5 v9 M5 ^1 a8 Z
  Y  a  G$ g6 {! G  b  第1个参数_ucPort是端口号，范围COM1 - COM8。
4 u  j) M3 j" c5 c4 k* z* _2 P  第2个参数_ucByte是待发送的数据。
( p. i. t( A* [: i' _! s6 q& M注意事项：

  此函数的解读在本章30.3.2小节。
* O3 y1 D# D- Q% W2 l1 K1 \使用举例：
# a  M! H+ C' K* R3 v& a
9 F% s. p+ m3 _4 g5 _  Y& p9 w+ k调用此函数前，务必优先调用函数bsp_InitUart进行初始化。比如通过串口1发送一个字符c：
$ f* l* n. b# G/ E
comSendChar(COM1, 'c')。
# @* C$ R; ?1 E
( [! E2 a/ T: |* s# J  O" ^9 O9 {4 P- P30.4.4 函数comGetChar
0 @) m# Q4 ]* N& m7 c2 ~. ~函数原型：

1. uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)

复制代码

) {" G$ \$ |# g; D& u函数描述：

此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
; [2 k8 U8 T+ R: [0 ]
函数参数：

, V* E. P+ w8 l' k  v  第1个参数_ucPort是端口号，范围COM1 - COM8。
+ _, C  W0 [( j9 s$ X  第2个参数_pByte用于存放接收到的数据。
" j" J% H# o5 b) N2 n( i' ]  返回值，返回0表示无数据, 1 表示读取到有效字节。
注意事项：

& s3 n# [! C/ ?  此函数的解读在本章30.3.6小节。
使用举例：
, |' Z( ~* M; U: o
调用此函数前，务必优先调用函数bsp_InitUart进行初始化。
$ p  N7 P* v7 N2 r7 k
比如从串口1读取一个字符就是：comGetChar(COM1, &read)。

0 r+ O+ k. q& `4 Y30.5 串口FIFO驱动移植和使用
7 p# J# ^  T" w" e3 n4 e; m串口FIFO移植步骤如下：

  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
4 V$ G$ R  j9 d  第2步：根据自己要使用的串口和收发缓冲大小，修改下面的宏定义即可。

1. #define        UART1_FIFO_EN        1
   $ B" {8 e. g  N' ^! Y8 q9 D. m
2. #define        UART2_FIFO_EN        0
   
3. #define        UART3_FIFO_EN        0
   
4. #define        UART4_FIFO_EN        0
   " a/ d0 \+ M6 Q6 v" f* U0 n
5. #define        UART5_FIFO_EN        0
   
6. #define        UART6_FIFO_EN        0
   
7. #define        UART7_FIFO_EN        0
   + B5 I8 k0 `3 p3 J9 q: w0 p
8. #define        UART8_FIFO_EN        0
   % _  f- S$ q3 i2 F; `8 r. Z
9. 
   ) h+ x, O2 P0 f( e- B
10. /* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */
    + o8 B3 V$ t- T! J/ M) Q
11. #if UART1_FIFO_EN == 1
    
12.         #define UART1_BAUD                        115200
    
13.         #define UART1_TX_BUF_SIZE        1*1024
    + l8 p, x  ~5 n6 U
14.         #define UART1_RX_BUF_SIZE        1*1024
    
15. #endif
    
16. 
    ; q' h! P6 g7 n# Q- V! v8 s
17. #if UART2_FIFO_EN == 1
    . g0 s* {( N1 A8 w3 R3 h) j& C
18.         #define UART2_BAUD                        9600
    
19.         #define UART2_TX_BUF_SIZE        10
    
20.         #define UART2_RX_BUF_SIZE        2*1024
    % A: T- Z. t3 ^8 j7 d( i( }: J
21. #endif
    
22. 
    # E$ A) x( u/ W+ V8 t& d. K
23. #if UART3_FIFO_EN == 1
    ) Y" W+ S3 u; m) R
24.         #define UART3_BAUD                        9600
    
25.         #define UART3_TX_BUF_SIZE        1*1024
    
26.         #define UART3_RX_BUF_SIZE        1*1024
    : U$ b, k: ]% O0 d0 n
27. #endif
    
28. 
    ) n" g! O; }" n, ], ~0 k
29. #if UART4_FIFO_EN == 1
    
30.         #define UART4_BAUD                        115200
    5 q2 ^5 E( O( T3 w1 K3 u
31.         #define UART4_TX_BUF_SIZE        1*1024
    ) j/ ~8 u6 T! I" s1 G, h
32.         #define UART4_RX_BUF_SIZE        1*1024
    
33. #endif
    
34. 
    3 k* \: Y; N! U5 y* x5 n
35. #if UART5_FIFO_EN == 1
    % H; S- m% R- c! b
36.         #define UART5_BAUD                        115200
    / w& j8 \- ]+ D1 F& B5 z+ \
37.         #define UART5_TX_BUF_SIZE        1*1024
    
38.         #define UART5_RX_BUF_SIZE        1*1024
    . m8 O, \- k) f; |/ B+ U
39. #endif
    
40. 
    
41. #if UART6_FIFO_EN == 1
    
42.         #define UART6_BAUD                        115200
    9 Z4 b5 C9 F' \* s6 R# U
43.         #define UART6_TX_BUF_SIZE        1*1024
    ( Y* ]! J3 K& V3 A' z0 N/ x- y
44.         #define UART6_RX_BUF_SIZE        1*1024
    
45. #endif
    
46. 
    
47. #if UART7_FIFO_EN == 1
    
48.         #define UART7_BAUD                        115200
    
49.         #define UART7_TX_BUF_SIZE        1*1024
    , _2 _$ [6 o0 C! Y/ U& x4 J! P+ A
50.         #define UART7_RX_BUF_SIZE        1*1024
    
51. #endif
    
52. 
    & ^& E2 B. f7 M( I1 n! s5 i
53. #if UART8_FIFO_EN == 1
    , Z9 O' L9 w% Y
54.         #define UART8_BAUD                        115200
    7 V& n/ W9 d9 ], G
55.         #define UART8_TX_BUF_SIZE        1*1024
    $ S! U, E% W* k# ~& J
56.         #define UART8_RX_BUF_SIZE        1*1024
    
57. #endif

复制代码

1 W: _1 t" i0 P( w/ l4 n  第3步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第4步，应用方法看本章节配套例子即可。
30.6 实验例程设计框架
6 O( E, i0 b8 ?2 `; m8 L通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
" f1 u& t: l. G) X2 Y/ i! j
3 }& G1 e% c" E

& o' j. q$ P. O+ O  M
  第1阶段，上电启动阶段：
5 Y3 d* f1 {1 q# p' P; K# b+ r
1 @$ ^6 S2 N2 s% _) p这部分在第14章进行了详细说明。
( Z0 W" I. Q- n1 K& B' z4 @8 j  第2阶段，进入main函数：
$ E( a/ I. K3 d% f, a
  w* \, Q9 f. Q  i  第1部分，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器和LED。
) b% ~8 J$ U4 ~3 u& j  第2部分，应用程序设计部分，实现了一个串口接收命令，返回消息的简单功能。
& K- f4 I9 X5 a5 w+ {. ?30.7 实验例程说明（MDK）
3 [' q0 e) I& p, I配套例子：

+ \& _$ V; ^# T  O5 uV7-015_串口和PC机通信（驱动支持8串口FIFO）

实验目的：

* k; C4 Y+ U+ `( B4 T% L学习串口与PC通信。
9 t$ J; q0 j8 W( G$ g, ^+ m实验内容：

2 e, S% @- l( k& E$ m启动一个自动重装软件定时器，每100ms翻转一次LED2。
实验操作：
6 ^4 ]4 {4 k& y" S, D; {
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
* o8 [4 F: m5 ~& ?K1按键按下，串口打印"按键K1按下"。
1 b: m! s  p5 N+ f, WK2按键按下，串口打印"按键K2按下"。
K3按键按下，串口打印"按键K3按下"。
: s" K5 Z5 a' @2 R上电后串口打印的信息：

! h$ C# G% l' L, e' q# F$ y波特率 115200，数据位 8，奇偶校验位无，停止位 1
4 `; q  @7 I* L3 G( I

7 @% o1 ~  {$ Q7 }程序设计：

6 m  q: B: j+ t" w- B  |. W, j  B  系统栈大小分配：

  RAM空间用的DTCM：
& h0 a; d: s8 x" L8 d1 i! N

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
8 i# Y% v) Y1 o$ m7 m
0 M& b2 R8 G& L: Z/ A1 r

1. /*
   4 ?/ m( l! W& z- R
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   7 t5 O3 Q1 T; }
5. *        形    参：无
   2 r* X% n- G! R0 ~
6. *        返 回 值: 无
   % X9 \& v& E% o1 D* J
7. *********************************************************************************************************
   2 V5 y! I3 V+ z& T0 C
8. */
   : r* K$ N1 R% k3 S/ c& l4 Y
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    , o7 }% o! w: V% x- {1 i& I
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    ! B. j3 ^8 I1 b! Y. N/ M
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    : R  s/ L& e5 l5 k% n* Y
20.            - 设置NVIV优先级分组为4。
    : X+ n% K  Z2 E% W3 S; i+ _2 M
21.          */
    8 y+ @# r% U! R! Q; Z- L+ N
22.         HAL_Init();
    
23. 
    9 a) w; N+ Z: i9 o6 ^8 @
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
      K) p, X0 F1 n' Z7 _
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    : F: \1 t! C" l4 S6 e7 Y: {. N
31.         /*
    1 e* k9 K* _1 M
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    . y! V0 u. B4 h8 k
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    8 l5 r. j! C6 H
36. #if Enable_EventRecorder == 1  
    8 C* O$ {4 s+ m8 J
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    2 _7 y2 k  l' O, r# {, U3 z
41.         
      Z+ y1 l, K, X
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    6 o: h; z: F& \! K8 m
46.         bsp_InitLed();            /* 初始化LED */        
    " T6 E5 R& [+ ~- \# D9 r  Y
47. }

复制代码

, U+ E  N) Q7 q  B! B) i  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
8 b8 h) N! ]( i
9 n9 l! P4 a; x( b/ X; W7 l, g; r

1. /*
   
2. *********************************************************************************************************
   # Z* g' y6 j% L$ D" @
3. *        函 数 名: MPU_Config
   ) N9 a. Q  ]/ U0 k; g& N
4. *        功能说明: 配置MPU
   " x3 c4 n) Y; E( K
5. *        形    参: 无
   
6. *        返 回 值: 无
   $ d2 `( O7 |4 w5 i3 |
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    + ?$ n4 B' H1 y4 ]; h4 O' C, X
13.         /* 禁止 MPU */
    8 q% t2 {" l7 ?- M
14.         HAL_MPU_Disable();
    ' y( p& ]1 G* ~8 _/ s
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;
    1 R/ Y/ J- K' b- p( I8 I; M
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - N% B# d: v6 G. L( o! }
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    5 v* G" M6 U" t( g6 Y. g- l" c
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    * S2 C! X5 _9 H3 k$ }. S
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    # G. X$ X2 {3 P! r" @
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    * W& ^# k/ i. e5 }
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    1 |1 A' `' g. ?" v( G
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % X4 _: z- R) N
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ' V. h2 e) \+ u1 C
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    3 Q# u3 H/ m: a+ }- v% _
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    & c8 c6 W- g  X6 A% G' i0 a
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    8 M! T6 |- @9 Y9 h
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    : q5 X8 Q( E# C7 Z8 x  ?
47.         /*使能 MPU */
    6 N" y  J: D0 @3 n) V
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    6 G1 d# T% c3 f
50. 
    
51. /*
    % y* F. i  t  f
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    # L  Z& ]  H# E2 C- [$ f8 i0 d0 J
58. */
    $ T+ |! F/ T, g- J
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    , M7 E# K0 A; _" T% f
62.         SCB_EnableICache();
    * Z- D1 ]7 n' Y5 E( S; K) [
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

% ~7 O9 F/ x( o2 R3 S" g3 t: L; a  每10ms调用一次蜂鸣器处理：

* X* J7 s/ k8 b: c/ k; G& q  u蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   ! f4 j# D4 I* V$ m8 i9 B
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   7 N/ w# ]* L/ ?; Z5 Z
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   6 _9 K2 N( p) d2 W7 t* x5 y% P
10. void bsp_RunPer10ms(void)
    " g4 k) @9 n, P4 Q
11. {
    4 y% k" b0 ?( \8 B7 f) q3 S
12.         bsp_KeyScan10ms();
    
13. }

复制代码

: y- {0 P& E: z! v& b7 {  主功能：

9 h, E4 A2 X5 D/ j! I4 J主程序实现如下操作：
% ?. w; a% \  ~: z  f, r5 J
! C& @! O% h4 d: g2 ?- g1 y  启动一个自动重装软件定时器，每100ms翻转一次LED2。
; p/ M; [; q& z% ]: o  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
% n# w+ j, K2 z' ]4 G" R0 X$ ]  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
8 Y' P$ v3 ^+ R

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   7 l0 d# [" a9 y3 i7 i
5. *        形    参: 无
   : P8 A% ?2 X4 F# O  m% W
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   6 [! r) L7 A2 l/ c& l* }. I4 ]
9. int main(void)
   3 p# Z6 S0 ~7 o9 B+ d. q
10. {
    
11.         uint8_t ucKeyCode;        
    
12.         uint8_t read;
    & x4 O* o! \! d; E1 ^
13.         const char buf1[] = "接收到串口命令1\r\n";
    
14.         const char buf2[] = "接收到串口命令2\r\n";
    + F" u% e, X" P
15.         const char buf3[] = "接收到串口命令3\r\n";
    0 y) I  m0 o6 D- X+ f
16.         const char buf4[] = "接收到串口命令4\r\n";
    7 q, c) c/ Q. d2 E- k3 d
17.         
    ( G; D+ K, n- z0 M  _
18.         
    " t' B7 d% }! q5 ^2 }* i( k% j
19.         bsp_Init();                /* 硬件初始化 */
    1 n+ N9 g$ u* W. X8 t
20.         
    ( ]' o4 B5 \& x  g; Q4 A8 n
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    1 x6 L+ `2 A7 Y& Z( l8 ?" x
25.         
    & B" q) ?& U0 \
26.         /* 主程序大循环 */
    
27.         while (1)
    - f5 I6 E' V- I- f& ~3 T; H
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    + p" g; F; \# O- G0 K% K* N$ g
30.                 bsp_Idle();               
    7 B" D8 Z! t3 B! c
31.                
    
32.                 /* 判断定时器超时时间 */
    6 J8 T- p! V2 O6 R9 L5 r
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    
36.                         /* 翻转LED2的状态 */
    
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    * D% l0 W. k& Z# w: O& Z0 z
40.                 /* 接收到的串口命令处理 */
    ' I6 A5 T1 A/ Y+ o. e
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    7 ]) K( @: |% q- ~* c/ r
43.                         switch (read)
    2 Y- G7 |; [  T% |7 u
44.                         {
    & d- u4 G' _( I4 l5 H
45.                                 case '1':
    : P8 R+ s8 d+ _- |6 Q; U' J$ n" B% H
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    ( }0 {: H' e- x7 u; ]2 Z' z
47.                                         break;
    % b! P  }: o& L' }/ Y
48. 
    
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    : |: a% U, N) L2 \8 j
51.                                         break;
    
52. 
    
53.                                 case '3':
    ; M) W2 x7 j0 l" v+ x  [( I/ M
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    
55.                                         break;
    . P* c8 W1 @# m
56. 
    " p5 Z7 I8 S8 p' j0 v* c# J
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    2 I5 z; E2 r$ [& R( c/ e
59.                                         break;        
    
60.                                 
    
61.                                 default:
    - V1 I+ u& h& A* o
62.                                         break;
    
63.                         }
    
64.                 }
    
65.                
    
66.                 /* 处理按键事件 */
    2 V+ q( [( h: a* `
67.                 ucKeyCode = bsp_GetKey();
    0 L6 r& M. Y8 h) w/ I: N4 v
68.                 if (ucKeyCode > 0)
    4 H# f$ c' E8 |' x
69.                 {
    
70.                         /* 有键按下 */
    
71.                         switch (ucKeyCode)
    
72.                         {
    % W# K5 g  o- V
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    
75.                                         bsp_LedToggle(1);        
    " {9 `+ k% a: G* x1 f1 @4 A: v
76.                                         break;               
    ; o1 }5 V4 Z! D  \: P
77.                                 
      ]7 [  r# |" c, m
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    ( h9 d1 f8 n: t8 y8 C6 p
84.                                         printf("按键K3按下\r\n");        
    $ R, z: x2 I2 I$ N
85.                                         bsp_LedToggle(4);        
    
86.                                         break;                                
    
87.                                 
    % w/ U/ ~0 q0 @) A8 Y
88.                                 default:
    
89.                                         break;
    
90.                         }
    , z& }7 L  `! i7 w
91.                 }
    ; d2 m- y2 W( o5 ~0 T
92.         }
    
93. }

复制代码

1 j) h) C! A( x/ V" l+ t; r( p30.8 实验例程说明（IAR）
; ?6 P8 ]6 T2 C配套例子：

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

实验目的：

; S( Q% u: ^- }学习串口与PC通信。
/ C# H) s- K! y: n2 ?) w实验内容：
5 o& _2 o6 @# _8 E$ d7 z- j
! |$ @+ w$ f/ |+ x: i; C' K启动一个自动重装软件定时器，每100ms翻转一次LED2。
! I0 E5 f2 V( D1 U! x  t. q实验操作：
  h+ U9 c/ C/ l& ~5 `& o2 I
串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
. ?' T/ p6 ?0 T3 k5 B) {* h, I; p串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
- B/ a' s0 {% N0 S串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
' }. M- _" O8 n4 L( ?- I串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
K1按键按下，串口打印"按键K1按下"。
% q3 H( Q3 h" V% I  EK2按键按下，串口打印"按键K2按下"。
* ^+ @5 c) j2 O. o7 ]$ tK3按键按下，串口打印"按键K3按下"。
" d' V: V" u7 D4 S  l) d( \上电后串口打印的信息：
7 ?7 u5 V0 v9 ~# @+ m! G3 _6 i$ f
波特率 115200，数据位 8，奇偶校验位无，停止位 1
! ~+ z: H8 }4 j% }
6 S7 B! o. b  y- \8 H% u

; B) Z1 ^! X  t& V4 w& X程序设计：

   系统栈大小分配：
# V) [$ D* b% X  e8 A4 [, L; j

$ {. r$ a  T; ]- o
* ]! Z& u6 R7 S: [" U+ I   RAM空间用的DTCM：
1 ]0 k' i4 ]0 r8 L( e1 Q
) A  W7 e6 v  Z% _+ H

) G" e4 t/ o, `5 ]  O
  硬件外设初始化
8 J: t3 O) E# ^, ~: _
硬件外设的初始化是在 bsp.c 文件实现：
: N! I+ }  e+ }& g

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

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
% T# m" e% Z  g8 D
8 G' @) A' n7 P- u3 a

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   ( [1 u( P+ V7 ^+ K& h' l3 I
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   2 ]) H2 @. b- K& x1 }* S
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   5 e, x% U1 E5 {! F9 o
10. {
    $ Z8 Q, `9 }, C, ?( e( m# P6 _) A
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    . F5 R* x0 d+ i7 d$ Y# ^- F$ r
13.         /* 禁止 MPU */
    9 E! _6 V) C/ x! s$ m, z
14.         HAL_MPU_Disable();
    
15. 
    # @* x8 Q# N& c& l9 ]1 a
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    9 N( q% P2 E( s
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + h1 K! B1 X% t4 u/ s+ `4 @& I( E7 o
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    5 j2 R9 T$ g7 Z
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    % G  g) e* W0 T: P
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 l* O, b4 j9 Q: Q4 _. U
30.         
    0 G- c* W) Y, M( _3 N- x% m
31.         
    ) k4 A) ?; m: \" F! C& B
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    - q' a% N3 p/ m8 v, @$ X' o
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    - x, s" A2 T4 |4 Q
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    $ ]; X2 m$ ?, U7 T& \( P
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ! U& L0 ^5 Y' |% @3 K0 v: W7 R1 x$ u
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 o1 h. d3 k: g- x7 T' c
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! D" E% n6 t7 Q' [. \
46. 
    # S- G3 h8 t+ I9 m" o
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    9 l: K# V' m4 s8 k
49. }
    ! d0 @$ }+ H$ |
50. 
    
51. /*
    , ]7 w, q' i, f* ?, r
52. *********************************************************************************************************
    ! G9 v8 p) }2 H( [% D- R' U5 H" O
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    : C/ S: u, l# h( ]. z5 m8 l! B" q# e
55. *        形    参: 无
    
56. *        返 回 值: 无
    # Z2 w2 A- Q; q" z: I5 [
57. *********************************************************************************************************
    
58. */
    ) G  i, P2 G$ Q3 l  [# C/ F
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    ; Z+ h$ }( `% n) U6 p4 ^7 W2 N& I
63. 
    
64.         /* 使能 D-Cache */
    4 S6 ~8 e; S8 |8 ^9 c5 E
65.         SCB_EnableDCache();
    : q& O  o" g8 W+ P& q
66. }

复制代码

  每10ms调用一次蜂鸣器处理：
5 e( K6 ^3 e( ?2 T1 x" {* Q
* h  E: i+ p& ~7 \" R/ w! q蜂鸣器处理是在滴答定时器中断里面实现，每10ms执行一次检测。
' {4 r" [1 K6 a& S; [" J% d
) M# N3 R* `* F6 Z) I4 r/ V7 n

1. /*
   4 {& `1 \* j- f/ K% D
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   # T: ^# F6 i* ^( H* m; t
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   . d5 l+ |1 u' [7 b  H3 U
7. *        返 回 值: 无
   * D, b. H& O3 e  N# ~$ z6 i6 }' {
8. *********************************************************************************************************
   9 E$ k% `2 T2 ~7 U
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    4 v% g9 I4 R8 g
12.         bsp_KeyScan10ms();
    
13. }

复制代码

4 ]& d# u" U+ O/ X4 s9 r/ t  主功能：
5 V2 J4 u) d) l! ]
主程序实现如下操作：
6 M8 @' l8 u2 M, J3 D+ Y
$ N& b% i: r% C( W  启动一个自动重装软件定时器，每100ms翻转一次LED2。
7 T" p; Y" ]0 U( e8 E  串口接收到字符命令'1'，返回串口消息"接收到串口命令1"。
  串口接收到字符命令'2'，返回串口消息"接收到串口命令2"。
  串口接收到字符命令'3'，返回串口消息"接收到串口命令3"。
: K. |8 k. g& e0 T  串口接收到字符命令'4'，返回串口消息"接收到串口命令4"。
: o5 f. a" V& v& i$ C3 i  K1按键按下，串口打印"按键K1按下"。
  K2按键按下，串口打印"按键K2按下"。
  K3按键按下，串口打印"按键K3按下"。
4 `+ _3 V* L$ A/ o# L: [4 f# \  ^

1. /*
   
2. *********************************************************************************************************
   # ^( L* a" s& _" N; f# \) ~4 ~1 d
3. *        函 数 名: main
   8 v7 T5 O2 \' I3 ?
4. *        功能说明: c程序入口
   ( L' K! n$ W, Q  h3 }: I% h$ W
5. *        形    参: 无
   , T& L1 q, f5 d" |" F, x% `3 r# V
6. *        返 回 值: 错误代码(无需处理)
   9 B# Y9 @1 {* \8 A  z" _
7. *********************************************************************************************************
   % r. D3 k. `& u& B- U' f
8. */
   - ]. i2 D$ T2 n. F* v& \! P  K
9. int main(void)
   # C. U& {/ [: G) t; ]* T
10. {
    / t) t/ q% h/ y' P
11.         uint8_t ucKeyCode;        
    2 Z0 L& a, U+ L$ _; C  ?! v/ z
12.         uint8_t read;
    ) A) j& C# v$ Y* O
13.         const char buf1[] = "接收到串口命令1\r\n";
    ) p  ~; p) ^  P* g1 D
14.         const char buf2[] = "接收到串口命令2\r\n";
    
15.         const char buf3[] = "接收到串口命令3\r\n";
    $ u$ c  K* X6 H$ @" Q  e& V  L* g
16.         const char buf4[] = "接收到串口命令4\r\n";
    
17.         
    
18.         
    
19.         bsp_Init();                /* 硬件初始化 */
    
20.         
    5 d/ a+ {8 u& ]5 Q  t
21.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    ; h+ P4 e  C! ]+ k4 W) c6 M# ], Y& i9 c
22.         PrintfHelp();        /* 打印操作提示 */
    
23. 
    
24.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
25.         
    
26.         /* 主程序大循环 */
    3 v# s+ E2 @3 s. ^% T8 X( k
27.         while (1)
    
28.         {
    
29.                 /* CPU空闲时执行的函数，在 bsp.c */
    ' D8 o) A7 E8 c- u+ p/ M. K
30.                 bsp_Idle();               
    0 T7 Y( u) Y7 L  O! W+ o3 k7 H
31.                
    $ K" L$ ?0 a4 |6 P4 B% w
32.                 /* 判断定时器超时时间 */
    8 h9 F. b* @* W
33.                 if (bsp_CheckTimer(0))        
    
34.                 {
    
35.                         /* 每隔100ms 进来一次 */
    $ s1 `$ z" m0 F: M6 O
36.                         /* 翻转LED2的状态 */
    6 L* V6 t0 Y6 W1 X9 ~6 x* [
37.                         bsp_LedToggle(2);        
    
38.                 }
    
39.                
    % X$ n- P  t- Z5 i+ a, v5 s
40.                 /* 接收到的串口命令处理 */
    ) D% T$ I+ h3 z% d/ Q( B4 R5 v
41.                 if (comGetChar(COM1, &read))
    
42.                 {
    
43.                         switch (read)
    5 d; H% G/ \0 B0 d, P
44.                         {
    
45.                                 case '1':
    ( D) l( @8 H! ^; n
46.                                         comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));
    
47.                                         break;
    9 L9 s9 o' h- ~, C8 J2 R
48. 
    
49.                                 case '2':
    
50.                                         comSendBuf(COM1, (uint8_t *)buf2, strlen(buf2));
    8 e; W3 l; w  G0 o
51.                                         break;
    
52. 
    / Z: ^- m' W% G( U  E
53.                                 case '3':
    
54.                                         comSendBuf(COM1, (uint8_t *)buf3, strlen(buf3));
    8 v/ ~# q/ M5 a
55.                                         break;
    8 R4 {5 ^# J$ Y9 H, v, i9 u
56. 
    : q& a; T7 J' P* W+ c
57.                                 case '4':
    
58.                                         comSendBuf(COM1, (uint8_t *)buf4, strlen(buf4));
    
59.                                         break;        
    : E( n6 H% a$ x' q
60.                                 
    - |& L/ c/ U$ O2 x
61.                                 default:
    
62.                                         break;
    
63.                         }
    6 k; ]% _! I% a* `' P* a0 c
64.                 }
    8 j( H) T9 A& p! @
65.                
    
66.                 /* 处理按键事件 */
    
67.                 ucKeyCode = bsp_GetKey();
      Y, E4 ]. X, t2 I8 g
68.                 if (ucKeyCode > 0)
    " A6 {: `  r6 n. i- b
69.                 {
    
70.                         /* 有键按下 */
    # p0 t' q4 x0 X
71.                         switch (ucKeyCode)
    
72.                         {
    , V* n6 _/ i1 F: w0 a7 e, M
73.                                 case KEY_DOWN_K1:                /* 按键K1键按下 */
    
74.                                         printf("按键K1按下\r\n");
    ; ]$ W) U* r3 J; k: j$ i2 U& _
75.                                         bsp_LedToggle(1);        
    * \/ ~" n3 P! Y
76.                                         break;               
    + m8 a1 R! H* E2 S- |$ f
77.                                 
    # F  w, r& R# b$ B1 u6 {
78.                                 case KEY_DOWN_K2:                /* 按键K2键按下 */
    , d7 S$ f1 ?8 Y5 _' d; T5 m( d
79.                                         printf("按键K2按下\r\n");
    
80.                                         bsp_LedToggle(3);                                       
    
81.                                         break;
    ' c: i4 y8 W3 ~
82. 
    
83.                                 case KEY_DOWN_K3:                /* 按键K3键按下 */
    9 }) o3 V' S$ i
84.                                         printf("按键K3按下\r\n");        
    
85.                                         bsp_LedToggle(4);        
    2 ?5 P7 \3 x4 ?* [& }; F( z; V1 [
86.                                         break;                                
    & |) v) e1 G; E# g6 _9 b
87.                                 
    
88.                                 default:
    ' H6 Q# N& n0 s% A4 n) b
89.                                         break;
    2 S  A9 ]% N$ `( v+ ~
90.                         }
    
91.                 }
    ' R2 E* T* p8 d
92.         }
    
93. }

复制代码

30.9 总结
本章节就为大家讲解这么多， 重点是8串口FIFO的实现，而且移植也比较简单，可放心用于项目实战。
- X' ^2 I. \4 D, t6 d

1 g8 [9 P; c9 I8 Y$ E& v( C" {