STM32的串口介绍
  j7 C# r5 a* _$ U7 _* I. qSTM32 芯片具有多个 USART 外设用于串口通讯，它是 Universal Synchronous Asynchronous Receiver and Transmitter 的缩写，即通用同步异步收发器可以灵活地与外部设备进行全双工数据交换。有别于 USART，它还有具有 UART 外设(Universal Asynchronous Receiver and Transmitter)，它是在 USART 基础上裁剪掉了同步通信功能，只有异步通信。简单区分同步和异步就是看通信时需不需要对外提供时钟输出，我们平时用的串口通信基本都是 UART。

USART 满足外部设备对工业标准 NRZ 异步串行数据格式的要求，并且使用了小数波特率发生器，可以提供多种波特率，使得它的应用更加广泛。USART 支持同步单向通信和半双工单线通信；还支持局域互连网络 LIN、智能卡(SmartCard)协议与IrDA(红外线数据协会) SIR ENDEC 规范。USART 支持使用 DMA，可实现高速数据通信。

STM32F103与STM32F407的串口使用方法基本相同。
F103有3个USART（USART1~3）与2个UART（UART4~5）
6 `$ o2 o) q. v0 g# H, DF407有4个USART（USART1~3, USART6）与2个UART（UART4~5）。
以下两表分别是这两种单片机串口的管脚（部分）映射与时钟说明。
" \: C, y9 ]1 x! T

: Y$ T8 a1 {+ }3 g3 B5 Y
2 V# |( ?" G- p- c3 A, m


串口配置的模板函数
以STM32F103平台为例，开发了三个核心的串口配置函数，在串口初始化和需要修改参数时可直接调用。这些串口配置函数可以满足大多数应用场景的需求，但需要注意的是为了减少函数的参数个数、提高函数的易用性，部分串口参数直接采用了默认配置（例如收发使能、中断使能、流控禁用等），在一些特殊场景下需要重写部分函数的实现才能修改默认配置。
  ^6 t! ~4 q6 h. d4 ?2 s
配置GPIO
' n) x4 l4 O1 `9 V3 Y# c

1. /**
   * h. U7 f+ \2 v
2. * @brief 配置串口的引脚端口
   
3. * @param TXD_Port: 'A'~'G'
   
4. * @param TXD_Pin: 0~15
   7 C/ [, a, ^$ a5 o8 i' d7 I
5. * @param RXD_Port: 'A'~'G'
   7 y9 ?% i/ J1 K( z
6. * @param RXD_Pin: 0~15
   
7. */
   
8. void USART_ConfigGPIO(char TXD_Port, uint8_t TXD_Pin, char RXD_Port, uint8_t RXD_Pin)
   / D$ z4 ]; O" W/ n
9. {
   
10.         uint16_t txdPin;
    % T+ b% C; D* D; S9 N
11.         uint16_t rxdPin;
    
12.         GPIO_TypeDef *txdPort;
    
13.         GPIO_TypeDef *rxdPort;
    
14. 
    ; t7 M: w  c7 v
15.         GPIO_InitTypeDef GPIO_InitStructure;
    9 n% A" }* S& n9 x
16. 
    
17.         switch (TXD_Port)
    
18.         {
    - t1 F* E4 T. W0 n8 h8 P
19.         case 'A':
    4 N  y3 B7 y8 @% ^% z
20.                 txdPort = GPIOA;
    / @( j2 y- s6 H! N- x0 |+ \
21.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
22.                 break;
    
23.         case 'B':
    
24.                 txdPort = GPIOB;
    
25.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    
26.                 break;
    ( o% O# ^$ M2 \& g
27.         case 'C':
    
28.                 txdPort = GPIOC;
    
29.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    
30.                 break;
    + o; F9 l% n9 J. S1 o8 ^
31.         case 'D':
    
32.                 txdPort = GPIOD;
    
33.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    
34.                 break;
    
35.         case 'E':
    ) O9 [: |1 T) I: V
36.                 txdPort = GPIOE;
    0 D" D6 y/ p8 C4 a- n6 l& w6 v* \- M
37.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    # t7 Z. v8 m: j; B3 L8 Z5 g2 l
38.                 break;
    & Q# m# w1 n  \% T/ g7 W
39.         case 'F':
    
40.                 txdPort = GPIOF;
    
41.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
    
42.                 break;
    
43.         case 'G':
    
44.                 txdPort = GPIOG;
    2 R2 k& I, q- h. U' K& q1 X
45.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
    2 I# B, @  t: O6 t
46.                 break;
      e. j) m/ D3 P$ Q& b
47.         default:
    ) u4 ^& l+ }+ L- |1 x; E+ K
48.                 break;
    
49.         }
    
50. 
    , P7 X# j* l  A  y2 j6 X' y5 Y1 S/ J
51.         txdPin = (uint16_t) (0x0001 << TXD_Pin);
    
52. 
    ) N4 r4 q1 Z/ W$ m; w7 f; q) z
53.         switch (RXD_Port)
    
54.         {
    7 `( r" S, ^" N: ~! d9 H: u# z- O
55.         case 'A':
    
56.                 rxdPort = GPIOA;
    
57.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    ) g0 o8 A; B6 H" L
58.                 break;
    8 `8 O  R6 B- N8 J5 Q
59.         case 'B':
    ' }- j& r" n  W( o4 z
60.                 rxdPort = GPIOB;
      e* v8 b% S3 G% N8 t( M; C: H
61.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    
62.                 break;
    
63.         case 'C':
    
64.                 rxdPort = GPIOC;
    : c; |1 A+ D! L; I$ X& u% q
65.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    
66.                 break;
    ! s# X7 i1 O& L) N' t/ w! h
67.         case 'D':
    5 K8 N% i, f9 c' ]+ b8 @
68.                 rxdPort = GPIOD;
    
69.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    
70.                 break;
    
71.         case 'E':
    
72.                 rxdPort = GPIOE;
    
73.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
74.                 break;
    + \. D! x( ?+ y. s- o# {% ], v
75.         case 'F':
    
76.                 rxdPort = GPIOF;
    
77.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
    3 n) j( X0 K* n5 s$ W
78.                 break;
    6 T+ J' z# K7 V( k- @$ Q! c
79.         case 'G':
    ( F+ M/ T1 {# i/ G) @
80.                 rxdPort = GPIOG;
    0 f1 W6 [* q& N
81.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
    
82.                 break;
    9 z' l; V7 ~# w; l1 [9 ^
83.         default:
    
84.                 break;
    - N8 R9 Q6 J! \' P
85.         }
    & Y6 g" \! A4 w1 Y/ ?
86. 
    
87.         rxdPin = (uint16_t) (0x0001 << RXD_Pin);
    
88. 
    
89.         GPIO_InitStructure.GPIO_Pin = txdPin;
    
90.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    - ^0 b' z) Q4 W5 m9 L$ I
91.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
92.         GPIO_Init(txdPort, &GPIO_InitStructure);
    " K+ j. e$ }' Q& Q
93. 
    
94.         GPIO_InitStructure.GPIO_Pin = rxdPin;
    
95.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    1 U$ K# l0 r  |0 @1 e; i, D
96.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    3 v5 @6 J3 Q) [4 ?1 w7 A8 H0 B. }
97.         GPIO_Init(rxdPort, &GPIO_InitStructure);
    0 z+ }- k7 V$ M8 V/ l
98. }
    

复制代码

配置NVIC

1. /**
   " I5 Q  D4 {) b* _6 ~9 i2 ]9 D
2. * @brief 配置串口的中断向量控制器
   
3. *                 注意，此函数中未设置中断向量控制器的优先级分组。
   
4. *                 中断向量控制器的优先级分组应当先在程序其他地方被设置后，再调用此函数。
   
5. *                 在运行FreeRTOS的系统中，一般情况下采用分组4，即四位都被配置为设置抢占优先级。
   
6. * @param portNum: 串口序号1~5
   : {% ]1 z) O: l, k
7. * @param preePriority: 主优先级（抢占优先级）
   
8. * @param subPriority: 从优先级
   # D; }8 C0 A) K/ j0 h) o) g/ w8 o
9. */
   
10. void USART_ConfigNVIC(uint8_t portNum, uint8_t preePriority, uint8_t subPriority)
    
11. {
    
12.         NVIC_InitTypeDef NVIC_InitStructure;
    
13. 
    
14.         switch(portNum)
    
15.         {
    
16.         case 1:
    - _; G$ t9 u* m- T, ?
17.                 NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    1 U! T8 G3 X, \, P; X
18.                 break;
    
19.         case 2:
    
20.                 NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    : @0 G- m( e9 }
21.                 break;
    2 W8 D' M2 Q  o+ f- N
22.         case 3:
      J) v% i8 I/ I: J. h2 a
23.                 NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    * K: D; P5 c7 ^
24.                 break;
    : O( v8 R& b7 C0 T% e8 S- h0 G
25. #if defined(STM32F10X_HD) || defined(STM32F10X_HD_VL) || defined(STM32F10X_XL) || defined(STM32F10X_CL)
    
26.         case 4:
    / r! n2 M6 m$ e: N3 ?
27.                 NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    
28.                 break;
    6 o. X$ ]6 q- d, d
29.         case 5:
    ; c* _5 S9 _  {. q# W
30.                 NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
    
31.                 break;
    9 k: w6 p7 k0 h7 ?% s/ M
32. #endif
    
33.         default:
    $ h4 j5 L; g! D& @" n+ [
34.                 break;
    
35.         }
    
36. 
    1 U9 ?. q2 D) s# d. o7 q! X, \
37.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = preePriority;
    
38.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = subPriority;
    ( i; W- n1 S3 z4 W
39.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    2 |) h1 w6 B/ L
40.         NVIC_Init(&NVIC_InitStructure);
    
41. }

复制代码

配置USART

1. /**
   : p! H$ Z! N2 i4 y* l
2. * @brief 配置串口外设
   
3. *                 注意，函数参数列表中没有列出的配置参数采用默认的配置：
   
4. *                 1. 无硬件流控 2. 双向收发 3. 使能接收中断 4. 开启串口
   $ t# X8 g$ d7 C( A9 c! l
5. *                 如果需要修改默认的配置参数，则不能直接调用此函数完成串口外设的配置。
   
6. * @param portNum: 串口序号1~5
   
7. * @param baudRate: 波特率
   
8. *
   * T& ^5 L' G2 E, h4 t
9. * @param wordLength: 数据位长度（枚举变量）
   ; L# i% p  G$ V
10. *                 @arg WordLength_8b: 数据位8
    , F7 G/ H8 H6 [' F
11. *                 @arg WordLength_9b: 数据位9
    
12. *
    / I7 D; N5 O8 ~- b( ?/ h: e0 [
13. * @param stopBits:  停止位（枚举变量）
    
14. *                 @arg StopBits_1: 停止位1
    
15. *                 @arg StopBits_0_5: 停止位0.5
    0 D+ t; y! Q& Y. x% m
16. *                 @arg StopBits_2: 停止位2
    - Y7 H2 K* E8 {0 v4 L6 P# p) J/ [
17. *                 @arg StopBits_1_5: 停止位1.5
    
18. *
    9 Y1 q5 s+ `  ~2 X
19. * @param parity: 校验类型（枚举变量）
    , a- o! z* s4 b# U5 W. b
20. *                 @arg Parity_No: 无校验
    2 i0 x1 J! x4 k3 e( J. m" M
21. *                 @arg Parity_Even: 偶校验
    
22. *                 @arg Parity_Odd: 奇校验
    + B! D/ Z5 |- Y8 y$ h5 [# q+ N
23. */
    
24. void USART_ConfigPort(uint8_t portNum, uint32_t baudRate,  USART_WordLength_Enum wordLength, USART_StopBits_Enum stopBits, USART_Parity_Enum parity)
    
25. {
    
26.         USART_InitTypeDef USART_InitStructure;
    
27.         USART_TypeDef* USARTx;
    4 Z7 o7 y' c- V( ]2 R' A
28. 
    
29.         //开启外设时钟
    9 N6 R5 \% `2 Z. v) S+ w; q1 _
30.         switch (portNum)
    ( ?! A. M' R7 |1 B
31.         {
    
32.         case 1:
    1 c2 d- P( G. f7 @3 U" G
33.                 USARTx = USART1;
    
34.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    
35.                 break;
    9 N4 R9 V4 l# V# C# g8 t9 N$ ?  M
36.         case 2:
    7 H/ V/ w( H& F) ^  E- B
37.                 USARTx = USART2;
    4 s/ t: U& E! n7 S& P: N, K- {5 ~) q. h
38.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    
39.                 break;
    + [" Q6 ?( S+ t  Q8 H4 _: z0 f
40.         case 3:
    2 O1 l- V3 Z* q. s) k
41.                 USARTx = USART3;
    1 \& g8 v/ y+ ]' i" L0 }9 j( I
42.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    
43.                 break;
    7 ^: D* F9 i1 ]! y1 [  V1 y9 J
44.         case 4:
    ' k' X' A' K( J( y" f
45.                 USARTx = UART4;
    1 o1 M4 H- C& _
46.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
    
47.                 break;
    0 Q4 r" c/ q: c8 f/ M/ L
48.         case 5:
    ; V: O5 _  E2 N' i& {: K
49.                 USARTx = UART5;
    / J/ Z  t5 f0 ]( b! t3 e
50.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
      v1 H- W  ]) x) F  Q4 g
51.                 break;
    * d: _" c. }& L- B% R. U/ O
52. 
    
53.         default:
    
54.                 return;
    ! N' H3 S4 x5 U5 b3 J7 T
55.         }
    
56. 
    5 t6 ~) u0 Z! b- ^& @& O2 m
57.         //设置波特率
    . t9 O+ L) S" U' l5 N
58.         USART_InitStructure.USART_BaudRate = baudRate;
    
59. 
    
60.         //设置数据位长度（一般情况下无校验时，为8位数据；有奇偶校验时，为9位数据）
    
61.         USART_InitStructure.USART_WordLength = wordLength;
    ! N3 u5 C# I) K. b# t2 q% l7 e7 T
62. 
    
63.         //设置停止位
    
64.         USART_InitStructure.USART_StopBits = stopBits;
    
65. 
    
66.         //设置校验位
    
67.         if (parity == USART_Parity_No)
    7 G$ L# K7 H. i- \6 x
68.         {
    
69.                 USART_InitStructure.USART_Parity = USART_Parity_No;
      E, z- b) \& T1 e, P
70. //                USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
71.         }
    9 r! s' G- Q' i% n  M6 o# p
72.         else if (parity == USART_Parity_Even)
    0 e4 r/ T/ C+ |: G
73.         {
    
74.                 USART_InitStructure.USART_Parity = USART_Parity_Even;
    6 Q/ G, ?* d; ~
75. //                USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
76.         }
    1 e4 ~+ |2 ]9 @2 `1 m$ S6 N' B. P9 s
77.         else if (parity == USART_Parity_Odd)
    & Y. w  G$ q* V2 R
78.         {
    
79.                 USART_InitStructure.USART_Parity = USART_Parity_Odd;
    
80. //                USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
81.         }
    ) ^$ h4 n5 f- [
82.         else
    ! V9 T7 D7 f7 v! l  k' t4 c! ]' V
83.         {
    ' @) l; f; U2 s& J, T- |
84.                 return;
    0 ]0 b0 v' Y$ h
85.         }
    & n: x/ F8 T8 t! {
86. 
    
87.         //设置硬件流控
    2 _  j8 [+ O+ h, s
88.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    6 ?0 Y7 L9 T5 B0 y) r( N. R
89. 
    
90.         //设置收发模式
    
91.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    ! P) _! R  |: o5 \; H
92. 
    
93.         USART_Init(USARTx, &USART_InitStructure);
    9 N$ i% G3 K0 O$ r" c: c3 z- l
94. 
    
95.         //设置中断模式
    $ `& {8 R. ~2 L" G& h( n
96.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    ( i  E0 f+ S6 D* g+ x) i
97. 
    
98.         //使能外设
    
99.         USART_Cmd(USARTx, ENABLE);
    # j! c8 _2 n: g% K/ x4 [" \6 F2 y
100. }
     . W9 O/ ]/ _, n) _8 K% e$ Q" k

复制代码

扩展库的特性
. q: G9 C/ S. O: i  T! |% }" H本串口扩展库的核心是构造了多个循环FIFO队列作为接收数据的缓存。通过向接收数据处理函数传递一个具体的处理函数，可以实现本扩展库较好的封装。开发者设置了合适大小的接收缓冲区之后，仅需要在合适的位置调用接收数据处理函数void USARTx_RevBuffer_Handler(void (*USART1_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count))即可获取缓冲区中保存的串口接收数据，而不必考虑这些数据是如何入队、如何出队的。
# e) R3 O  p; G4 y. i
0 S. i; v! y4 j1 K2 i* B: b本串口扩展库函数采用中断的方式接收串口数据，利用系统空闲处理串口接收数据，采用查询等待的方式发送串口数据。如果需要发送的数据较多，可以考虑利用中断或者DMA传输发送数据，否则系统将会等待较长的时间。同时库函数可以与FREEModbus库配合使用，通过FREEMODBUS_ENABLE宏定义的值可条件编译不同的串口中断服务函数。
( W5 b" X3 x* b" u
+ i$ D9 @" j5 q" T% a6 A( E需要特别注意的是为了使函数名称与功能更加准确的对应起来，本扩展库中的连续数据发送函数名USART_SendData与标准串口外设库函数中的单字节发送函数名重复了。因为需要将标准库函数中的函数名USART_SendData改为USART_SendByte。当然，也可以修改本扩展库的*连续数据发送函数名，使之区别于标准库的函数名即可。
! r5 R0 r4 I  S3 W7 Q
在"stm32f10x_usart.h"与"stm32f10x_usart.c"需要修改的标准库函数如下：
, A* {0 t9 d$ q

1. /**
   . x' G$ R. l8 w% b3 j% E! d! ~: H
2.   * @brief  Transmits single data through the USARTx peripheral.
   
3.   * @param  USARTx: Select the USART or the UART peripheral.
   
4.   *   This parameter can be one of the following values:
   
5.   *   USART1, USART2, USART3, UART4 or UART5.
   8 S' C% B& s$ B- F
6.   * @param  Data: the data to transmit.
   
7.   * @retval None
   
8.   */
   
9. void USART_SendByte(USART_TypeDef* USARTx, uint16_t Data)
   
10. {
    
11.   /* Check the parameters */
    
12.   assert_param(IS_USART_ALL_PERIPH(USARTx));
    8 e: K* b1 P2 X8 u
13.   assert_param(IS_USART_DATA(Data));
    ' [6 b1 A  m" g* y
14. 
    
15.   /* Transmit Data */
    # \4 Y( W4 N' x# J+ O
16.   USARTx->DR = (Data & (uint16_t)0x01FF);
    : ]! s, ~5 S5 _% t4 h8 q( D
17. }

复制代码

; a- H5 t1 [+ t5 R4 k  U" a; T6 a源码
8 ?) ?6 B5 E2 z- Z头文件
6 A0 p& W* O8 a9 w6 W

1. #ifndef __USART_EXT_H__
   5 p1 D9 h0 a% x2 ^8 A/ B6 s0 f7 _
2. #define __USART_EXT_H__
   : C  ]% q/ x8 ~7 M- ?+ t9 Z5 X
3. 
   
4. #include "stm32f10x_conf.h"
   9 J3 B# {1 P) {* X! d1 k4 w7 E
5. #include "stm32f10x.h"
   
6. 
   
7. #define USART_Count                                5
   
8. 
   5 w7 b2 r; a( Q7 f6 n" S: p
9. #define USART1_BufferSize                50
   
10. #define USART2_BufferSize                50
    & y; p$ |- o, A9 E, D( R
11. #define USART3_BufferSize                50
    4 g8 f7 [* N9 ]/ q- C. r2 Z
12. #define UART4_BufferSize                50
    
13. #define UART5_BufferSize                50
    
14. 
    
15. typedef enum{
    
16.         WordLength_8b = USART_WordLength_8b,
    5 J  e* M8 f3 Z8 G3 z" A
17.         WordLength_9b = USART_WordLength_9b,
    % r" g- {  I/ k1 D) ?5 {$ e
18. } USART_WordLength_Enum;
    7 V5 }6 m" f& ^2 I) w: I
19. 
    + G  [+ ]" d& c" R
20. typedef enum{
    
21.         StopBits_1 = USART_StopBits_1,
    
22.         StopBits_0_5 = USART_StopBits_0_5,
    # ]4 f" W, N% D* s* a  q
23.         StopBits_2 = USART_StopBits_2,
    
24.         StopBits_1_5 = USART_StopBits_1_5,
    
25. } USART_StopBits_Enum;
    
26. 
    0 _/ f2 M6 E0 V! q$ V% R
27. typedef enum{
    5 P2 ~- m" y9 O7 s! H
28.         Parity_No = USART_Parity_No,
    
29.         Parity_Even = USART_Parity_Even,
    4 Y# {' i( V  l( y, {
30.         Parity_Odd = USART_Parity_Odd,
    
31. } USART_Parity_Enum;
    
32. 
    
33. void USART_ConfigGPIO(char TXD_Port, uint8_t TXD_Pin, char RXD_Port, uint8_t RXD_Pin);
    
34. void USART_ConfigNVIC(uint8_t portNum, uint8_t preePriority, uint8_t subPriority);
    & v/ {; i1 v' F! {4 L. h+ u
35. void USART_ConfigPort(uint8_t portNum, uint32_t baudRate,  USART_WordLength_Enum wordLength, USART_StopBits_Enum stopBits, USART_Parity_Enum parity);
    
36. 
    
37. void USART_RevInitAll(void);
    
38. void USART_RevInit(USART_TypeDef* USARTx);
    
39. 
    ) ]7 J; F& M! V9 P1 p* T$ ?
40. void USART_SendByteData(USART_TypeDef* USARTx,const uint8_t byteData);
    
41. void USART_SendData_Bit16(USART_TypeDef* USARTx,const uint16_t *Data, uint16_t Count);
    
42. void USART_SendData(USART_TypeDef* USARTx, const uint8_t *Data, uint16_t Count);
    
43. uint16_t USART_SendString(USART_TypeDef* USARTx, const char *String);
    
44. 
    + M+ ]6 L+ H  [1 V3 a+ @/ ]
45. void USART1_RevBuffer_Handler(void (*USART1_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count));
    1 H( m$ i/ C0 M; F+ X6 s
46. void USART2_RevBuffer_Handler(void (*USART2_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count));
    
47. void USART3_RevBuffer_Handler(void (*USART3_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count));
    * W- c6 B# K& t+ R9 R" l
48. void UART4_RevBuffer_Handler(void (*USART4_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count));
    
49. void UART5_RevBuffer_Handler(void (*USART5_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count));
    $ G: b4 q% v7 M. a. ~! D) b
50. 
    
51. #endif
    

复制代码

源文件
: @+ K0 ?7 m& d6 s

1. #include "usart_ext.h"
   6 M$ Z: g" f. o! V& m: z, n
2. #include "mb_user.h"
   $ `( a8 J  Y/ a! Q
3. 
   
4. /**
   
5. * 本串口扩展库函数采用中断的方式接收串口数据，利用系统空闲处理串口接收数据，采用查询等待的方式发送串口数据。
   
6. * 如果需要发送的数据较多，可以考虑利用中断或者DMA传输发送数据，否则系统将会等待较长的时间。
   
7. * 同时库函数可以与FREEModbus库配合使用，通过FREEMODBUS_ENABLE宏定义的值可条件编译不同的串口中断服务函数。
   
8. */
   
9. 
   
10. /**
    
11. * 定义串口接收的缓冲区大小，根据串口的应用需求，可以为每个串口设置不同大小的缓冲区
    
12. */
    
13. const static uint16_t USART_BufferSize[USART_Count] =
    0 j0 l$ U, S2 }8 e
14. {
    
15.                 USART1_BufferSize,
    
16.                 USART2_BufferSize,
    * N9 C3 ?0 J  ?( C
17.                 USART3_BufferSize,
    
18.                 UART4_BufferSize,
    
19.                 UART5_BufferSize,
    
20. };
    ; Z1 y# N. ?% v1 z. S
21. 
    
22. /**
    
23. * 将各串口接收的缓冲区声明为静态数组变量，防止外部修改
    8 A- |" n. s+ Q) q3 \& G% ?2 H
24. */
    ! s3 t  Q4 ?( A" O2 n: L5 Y
25. static uint8_t USART1_RevBuffer[USART1_BufferSize];
    : q# H# t. f; W* w
26. static uint8_t USART2_RevBuffer[USART2_BufferSize];
    
27. static uint8_t USART3_RevBuffer[USART3_BufferSize];
    
28. static uint8_t USART4_RevBuffer[UART4_BufferSize];
    
29. static uint8_t USART5_RevBuffer[UART5_BufferSize];
    
30. 
    
31. /**
    8 j* a; ], Z3 ^3 U3 J
32. * 指针数组，将各串口接收缓冲区的首地址作为数组的成员，以方便程序操作
    
33. */
    * r5 |- e! B4 P% u/ B
34. static uint8_t* USART_RevBuffer[USART_Count];
    $ r3 I9 X# u7 z' e- x& ^& V
35. 
    
36. /**
    1 p8 r9 k* V4 w9 W
37. * 指针二维数组，用于管理缓冲区的读写指针
    . n1 w8 S! l$ v  S- K) Q
38. */
    $ j2 U" g0 P& C0 g8 b
39. static uint8_t* USART_RevPointer[USART_Count][2];
    
40. 
    
41. /**
    
42. * 缓冲区接收数据计数
    / x4 Y4 R5 D+ @% M& c; G6 B/ P
43. */
    3 w  l$ W4 a/ l! Z
44. static uint16_t USART_RevCount[USART_Count];
    % ?- }4 d3 G: V. \1 D* [- [
45. 
    
46. /**
    ; c, @# B) U) |. P
47. * @brief 配置串口的引脚端口
    0 i# x  `, O# W0 w9 _& a, h/ M
48. * @param TXD_Port: 'A'~'G'
    
49. * @param TXD_Pin: 0~15
    . O' V9 }+ Q. S7 H0 t
50. * @param RXD_Port: 'A'~'G'
    & P4 n" U  Z8 L1 G5 e- n
51. * @param RXD_Pin: 0~15
    
52. */
    
53. void USART_ConfigGPIO(char TXD_Port, uint8_t TXD_Pin, char RXD_Port, uint8_t RXD_Pin)
    5 R; D, B' `# U% W# ?
54. {
    
55.         uint16_t txdPin;
    
56.         uint16_t rxdPin;
    5 r) D4 u$ [9 h. Z
57.         GPIO_TypeDef *txdPort;
    
58.         GPIO_TypeDef *rxdPort;
    * H9 `- _8 Z( o* q8 v- v# ?4 w; K
59. 
    9 I) r3 a3 \  i, m( v
60.         GPIO_InitTypeDef GPIO_InitStructure;
    
61. 
    
62.         switch (TXD_Port)
    + g4 w" [% d! {. i3 ~
63.         {
    
64.         case 'A':
    8 B8 L/ N8 u9 s& ?
65.                 txdPort = GPIOA;
    ) ~2 f  [2 W6 k( |/ ~  |' m6 b
66.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
67.                 break;
    8 q4 Z3 X) k6 D! v7 i1 t4 k
68.         case 'B':
    
69.                 txdPort = GPIOB;
    
70.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    * Y4 v4 Y& H' t. P6 e' I
71.                 break;
    
72.         case 'C':
    
73.                 txdPort = GPIOC;
    & `1 x+ D! {: V- p5 }' }+ W
74.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    
75.                 break;
    5 l9 R6 y6 h9 f; [$ G
76.         case 'D':
    0 _" D* R* H: {, u/ Z( x" M/ W) o
77.                 txdPort = GPIOD;
    
78.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    
79.                 break;
    
80.         case 'E':
    3 S3 m" Q( W. g3 e6 x6 E5 X
81.                 txdPort = GPIOE;
      D  W$ r( F1 W# ?: J
82.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
83.                 break;
    - y8 A! R- A4 _+ b6 g
84.         case 'F':
    
85.                 txdPort = GPIOF;
    + M: [% n3 L! q* s
86.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
    - v; T# B+ m9 h* |5 s/ x
87.                 break;
    
88.         case 'G':
    
89.                 txdPort = GPIOG;
    
90.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
    5 X" g6 i' L' `! O- |7 O
91.                 break;
    & J/ }* C3 K4 e) p1 {
92.         default:
    
93.                 break;
    
94.         }
    
95. 
    ( j+ n% h  f2 D/ z
96.         txdPin = (uint16_t) (0x0001 << TXD_Pin);
    " U; r# \; O) s
97. 
    - A- p' K2 R$ d2 G3 ?( }8 E
98.         switch (RXD_Port)
    " i; e' Q" @- ~) ?0 V0 E2 a
99.         {
      U6 X: z) C: P' L/ C, e0 e1 I
100.         case 'A':
     
101.                 rxdPort = GPIOA;
     
102.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
     
103.                 break;
     
104.         case 'B':
     ; B. J1 I9 @9 o' }  K! u  a
105.                 rxdPort = GPIOB;
     + o  \$ u3 w/ t3 D* M. v* c
106.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
     ! \. n2 d" h  _# x* D. J) {1 K  u' f
107.                 break;
     / x  G5 k& C- m8 h: p1 d7 g
108.         case 'C':
     , u9 k) M* e- k' o( D& l
109.                 rxdPort = GPIOC;
     / x+ L  X( j  k" N6 j; ^' c) O4 t  S
110.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
     
111.                 break;
     
112.         case 'D':
     
113.                 rxdPort = GPIOD;
     ( x3 R2 i/ f1 X# q% j5 ]
114.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
     - a8 v( h' J" [; c
115.                 break;
     $ n3 r0 Q, Q3 B* h# f% }
116.         case 'E':
     " k+ k# w6 h: G2 H! K: n5 @
117.                 rxdPort = GPIOE;
     9 S. h' x7 w9 _
118.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
       |8 D. F1 F3 Y
119.                 break;
     - U- Q( c) ?+ k# z$ e1 K
120.         case 'F':
     
121.                 rxdPort = GPIOF;
     
122.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
     
123.                 break;
     9 C/ e( ~4 y2 e: \$ H/ Q: J
124.         case 'G':
     
125.                 rxdPort = GPIOG;
     9 a5 h; D# a, s8 ~1 z$ C1 I  `
126.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
     
127.                 break;
     1 e" |# O. V5 ?  ~  |( Y' `- ^
128.         default:
     : k& X9 p4 o" j0 X9 Q
129.                 break;
     
130.         }
     2 m# R( A* K. z! U* i# \
131. 
     1 R2 E( i" S- ?2 s
132.         rxdPin = (uint16_t) (0x0001 << RXD_Pin);
     
133. 
     ) X. P1 o/ r: @* G
134.         GPIO_InitStructure.GPIO_Pin = txdPin;
     5 b3 {9 e0 L' T$ i. ?  [6 g
135.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
     % m5 F( E3 \( x0 ?! ^  _* b# W
136.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     , _$ Q1 e# i3 L
137.         GPIO_Init(txdPort, &GPIO_InitStructure);
     
138. 
     + \. ~8 ^4 G, u; F2 u
139.         GPIO_InitStructure.GPIO_Pin = rxdPin;
     7 D4 Y' q% K3 W/ x9 Z) I7 A$ @
140.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
       I" [+ `0 J6 W4 @
141.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
142.         GPIO_Init(rxdPort, &GPIO_InitStructure);
     
143. }
     
144. 
     
145. 
     . p3 ]: A3 L4 @
146. /**
     
147. * @brief 配置串口的中断向量控制器
     $ N# x; U' I; a9 |
148. *                 注意，此函数中未设置中断向量控制器的优先级分组。
     
149. *                 中断向量控制器的优先级分组应当先在程序其他地方被设置后，再调用此函数。
     3 C; E( I- M$ a7 L
150. *                 在运行FreeRTOS的系统中，一般情况下采用分组4，即四位都被配置为设置抢占优先级。
       P+ \* e2 d1 V4 A) W8 w, T2 d& V
151. * @param portNum: 串口序号1~5
     
152. * @param preePriority: 主优先级（抢占优先级）
     
153. * @param subPriority: 从优先级
     6 [, L& t8 N1 |
154. */
     " ^; Z/ o. w9 `& E4 Q" C% r* o" Y
155. void USART_ConfigNVIC(uint8_t portNum, uint8_t preePriority, uint8_t subPriority)
     
156. {
     8 p9 l' r8 m+ h; B1 }4 r* Z
157.         NVIC_InitTypeDef NVIC_InitStructure;
     
158. 
     . l% F0 w0 j& r/ I* {; ?
159.         switch(portNum)
     
160.         {
     ( s, B: v$ p/ K1 C
161.         case 1:
     1 O# `4 M1 S/ h9 R0 |. A2 Z( h
162.                 NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
     9 w8 c& v6 p' R/ ?
163.                 break;
     # L3 s- U% }5 \4 c
164.         case 2:
     ( a6 C  S- }3 Q2 z" i; M% i
165.                 NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
     ' r3 x8 M. y4 M/ c( R
166.                 break;
     
167.         case 3:
     
168.                 NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
     
169.                 break;
     
170. #if defined(STM32F10X_HD) || defined(STM32F10X_HD_VL) || defined(STM32F10X_XL) || defined(STM32F10X_CL)
     0 M1 [! h9 t' e" L& S0 }4 N( ^
171.         case 4:
     
172.                 NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
     , l6 t) w* s# d! I; w7 }
173.                 break;
     
174.         case 5:
     
175.                 NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
     $ t" Z" g2 c5 h8 U2 t* O0 X* n3 s. [
176.                 break;
     7 C5 @% G  l. p6 f
177. #endif
     
178.         default:
     
179.                 break;
     0 c/ a6 d+ p  H
180.         }
     ; D" v, x+ M' d8 O- }
181. 
     
182.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = preePriority;
     % Q. F, q; P2 D$ v2 j
183.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = subPriority;
     
184.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
185.         NVIC_Init(&NVIC_InitStructure);
     
186. }
     1 {' s" |- ?6 v3 @
187. 
     
188. 
     
189. /**
     ) y$ G( q( r9 B; \5 @
190. * @brief 配置串口外设
     3 {! w' @8 \( \* I/ U
191. *                 注意，函数参数列表中没有列出的配置参数采用默认的配置：
     ' _# @- b) C3 E+ V" M  e0 b
192. *                 1. 无硬件流控 2. 双向收发 3. 使能接收中断 4. 开启串口
     # o& q9 y6 R* o  g6 F! k
193. *                 如果需要修改默认的配置参数，则不能直接调用此函数完成串口外设的配置。
     
194. * @param portNum: 串口序号1~5
     ) z7 L7 p6 @" s, w
195. * @param baudRate: 波特率
     
196. *
     + j  L8 C0 |7 a% e6 t2 w2 b2 @, }% C' r7 l
197. * @param wordLength: 数据位长度（枚举变量）
     7 \* Y8 i+ b6 l! L9 Z0 [
198. *                 @arg WordLength_8b: 数据位8
     
199. *                 @arg WordLength_9b: 数据位9
     , ~4 a( [; h5 ~( T$ U6 p" ^
200. *
     
201. * @param stopBits:  停止位（枚举变量）
     
202. *                 @arg StopBits_1: 停止位1
     
203. *                 @arg StopBits_0_5: 停止位0.5
     5 o8 g3 W5 ~: P. j; f
204. *                 @arg StopBits_2: 停止位2
     5 V* H1 Q3 R& e6 e/ e
205. *                 @arg StopBits_1_5: 停止位1.5
     5 \& g2 `! Q& g. L& N; E
206. *
     . q& }  X$ `. o+ r8 H! g
207. * @param parity: 校验类型（枚举变量）
     & _& b5 }9 h+ I# X" |
208. *                 @arg Parity_No: 无校验
     : m9 M& r0 X- v3 F. U! J
209. *                 @arg Parity_Even: 偶校验
     ( k" I. f/ D) U$ k/ R
210. *                 @arg Parity_Odd: 奇校验
     
211. */
     / X: d3 W+ T/ s+ f0 a0 y- v
212. void USART_ConfigPort(uint8_t portNum, uint32_t baudRate,  USART_WordLength_Enum wordLength, USART_StopBits_Enum stopBits, USART_Parity_Enum parity)
     
213. {
     . {* I) M( `* h; r  q; h
214.         USART_InitTypeDef USART_InitStructure;
     ' m  S' `  ~6 w2 I! k
215.         USART_TypeDef* USARTx;
     ( {. T9 }4 J( R- \" R( ~
216. 
     0 I: @% ?3 k2 a+ d
217.         //开启外设时钟
     
218.         switch (portNum)
     9 b' a7 z) J2 Q, h
219.         {
     
220.         case 1:
     
221.                 USARTx = USART1;
     % ~/ e/ T' w2 S& n9 ?% K* w
222.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
     
223.                 break;
     
224.         case 2:
     " [: E4 A: V* K' J& A- X
225.                 USARTx = USART2;
     % i1 `1 j$ \8 X, H
226.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
     " G/ D2 q) d1 R2 F% ], a3 Q
227.                 break;
     # ^) L+ ~+ a! r# z% E
228.         case 3:
     
229.                 USARTx = USART3;
     2 {- L% ^9 C$ L3 O  X
230.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
     - ?/ h& P* S& X9 a0 Y
231.                 break;
     
232.         case 4:
     
233.                 USARTx = UART4;
     ; I0 I. j* [7 f7 i9 p
234.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
     
235.                 break;
     4 a6 k+ g* d) X: K6 t; S& z% q
236.         case 5:
     / r9 Z+ M$ B, L' a# |/ Y
237.                 USARTx = UART5;
     
238.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
     ( ]' J) a' I+ o
239.                 break;
     & z3 y; |5 n! \' J' C
240. 
     / t( \! P' _, W8 J  u" b
241.         default:
     & L  g% m9 O/ ?/ u% h9 C1 w
242.                 return;
     7 e5 k# j% r9 `" K
243.         }
     3 m% l0 J* s. `: V1 _) @
244. 
     
245.         //设置波特率
     
246.         USART_InitStructure.USART_BaudRate = baudRate;
     ) L  X* e5 Q' e% `( U! z- c
247. 
     1 a3 j. P. f$ q2 ^/ @; P
248.         //设置数据位长度（一般情况下无校验时，为8位数据；有奇偶校验时，为9位数据）
     
249.         USART_InitStructure.USART_WordLength = wordLength;
       D5 k( ^4 [. f. i! n7 N
250. 
     
251.         //设置停止位
     
252.         USART_InitStructure.USART_StopBits = stopBits;
     
253. 
     & Z: c8 j8 B% V; U6 K  W) l1 a
254.         //设置校验位
     
255.         if (parity == USART_Parity_No)
     , N5 e! V( u+ Y' p" |" B; I
256.         {
     
257.                 USART_InitStructure.USART_Parity = USART_Parity_No;
     
258. //                USART_InitStructure.USART_WordLength = USART_WordLength_8b;
     " E8 c- t( o/ H$ j7 A) e& {5 I( K
259.         }
     
260.         else if (parity == USART_Parity_Even)
     
261.         {
     
262.                 USART_InitStructure.USART_Parity = USART_Parity_Even;
     * R5 {/ ]8 k: `% O0 T4 p" e3 i
263. //                USART_InitStructure.USART_WordLength = USART_WordLength_9b;
     8 s6 ?. Z" g4 V5 _7 s
264.         }
     % O" ?  \' ^! `5 U# x& @" a* q
265.         else if (parity == USART_Parity_Odd)
     * g' B- z( b$ ]3 F/ Y
266.         {
     
267.                 USART_InitStructure.USART_Parity = USART_Parity_Odd;
     
268. //                USART_InitStructure.USART_WordLength = USART_WordLength_9b;
     
269.         }
     1 j* R0 ?1 M6 z7 E! E# |
270.         else
     
271.         {
     & b9 ?8 P7 e. S5 m
272.                 return;
     ; ?! c& L8 A" \1 @' c. d- t
273.         }
     $ x0 m6 p8 \3 `) o. {* W8 ?1 m
274. 
     9 e# p( K2 s; b0 b9 Z& @
275.         //设置硬件流控
     
276.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
     : n5 g+ a; [( P% ~+ h
277. 
     8 n* f& A  Y+ n! }
278.         //设置收发模式
     
279.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
     * g) M" r" }+ H, Z; Z. w( C$ o
280. 
     
281.         USART_Init(USARTx, &USART_InitStructure);
     & f! O3 a' Y+ U- Z2 g) D
282. 
     3 ?8 h, f+ \" K, v8 n
283.         //设置中断模式
     $ d& u* k# k! t: t3 r$ P
284.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
     $ R- a0 U% `1 g6 \8 V
285. 
     
286.         //使能外设
     , r8 Y7 P2 m+ {0 F0 P$ B
287.         USART_Cmd(USARTx, ENABLE);
     * E0 K8 L7 Q+ j; x- G
288. }
     
289. 
     
290. 
     
291. /**
     : T1 C( q- l8 b8 m1 V
292. * @brief 初始化全部串口缓冲区及其管理变量
     0 |! f/ A, u, o* Y
293. */
     
294. void USART_RevInitAll(void)
     
295. {
     
296.         uint8_t i;
     
297.         ///
     
298.         USART_RevBuffer[0] = USART1_RevBuffer;
     
299.         USART_RevBuffer[1] = USART2_RevBuffer;
     
300.         USART_RevBuffer[2] = USART3_RevBuffer;
     ( `+ K" V) u/ Z- S& Z
301. 
     
302.         USART_RevBuffer[3] = USART4_RevBuffer;
     / \, c- o- C' F# _
303.         USART_RevBuffer[4] = USART5_RevBuffer;
     " Q* B6 b! h3 c/ y$ i
304.         ///
     / Q- Q; H+ k* X  d: B
305.         for (i = 0; i < USART_Count; ++i)
     ) h2 ]% ~' [3 |# |+ G
306.         {
     
307.                 USART_RevCount<i> = 0;
     
308.                 USART_RevPointer<i>[0] = USART_RevBuffer<i>;
     ( `( Z$ Y6 ^/ v. p% k9 @1 Q0 V
309.                 USART_RevPointer<i>[1] = USART_RevBuffer<i>;
     
310.         }
     
311. 
     
312.         for (i = 0; i < USART_BufferSize[0]; ++i)
     6 `3 k; f9 B1 H5 U" D2 q
313.         {
     . c+ a1 Q# r, D, N) O
314.                 USART1_RevBuffer<i> = 0;
     
315.         }
     
316. 
     
317.         for (i = 0; i < USART_BufferSize[1]; ++i)
     0 b8 B0 a* [; a* w
318.         {
     8 E( i& J% h0 i
319.                 USART2_RevBuffer<i> = 0;
     7 p3 i& t4 G( a/ {
320.         }
     % u% N( L8 v0 @7 W3 M
321. 
     
322.         for (i = 0; i < USART_BufferSize[2]; ++i)
     
323.         {
     4 Y% {6 |1 ~% ~: d1 \# Y
324.                 USART3_RevBuffer<i> = 0;
     
325.         }
     ) e( i1 f* v: ?8 _  `
326. }
     # s8 N/ @$ ~$ \, c( f  C" s* ]0 Q
327. 
     
328. 
     * u4 P, k# H/ T7 @( S
329. /**
     
330. * @brief 初始化指定串口缓冲区及其管理变量
     / g2 a% h! u9 g4 Y
331. * @param USARTx: 需要初始化的串口
     
332. */
     
333. void USART_RevInit(USART_TypeDef* USARTx)
     
334. {
     
335.         uint8_t i;
     
336. 
     6 F2 ~/ l) U( s
337.         if (USARTx == USART1)
     & e$ D0 `' n$ x1 q
338.         {
     & a3 ]1 s& a' c$ H3 W
339.                 USART_RevBuffer[0] = USART1_RevBuffer;
     
340.                 USART_RevCount[0] = 0;
     
341.                 USART_RevPointer[0][0] = USART_RevBuffer[0];
     2 \4 \1 _' K" m" K
342.                 USART_RevPointer[0][1] = USART_RevBuffer[0];
     5 f; }) j5 v7 J( q/ C9 Q
343. 
     
344.                 for (i = 0; i < USART_BufferSize[0]; ++i)
     / k' [' l. M, }1 j: j
345.                         USART1_RevBuffer<i> = 0;
     
346.         }
     
347.         else if (USARTx == USART2)
     
348.         {
     
349.                 USART_RevBuffer[1] = USART2_RevBuffer;
     
350.                 USART_RevCount[1] = 0;
     
351.                 USART_RevPointer[1][0] = USART_RevBuffer[1];
     
352.                 USART_RevPointer[1][1] = USART_RevBuffer[1];
     9 d7 z# _7 s! ]  T, T+ p
353. 
     ) w$ k2 @5 w( r$ X& \& A
354.                 for (i = 0; i < USART_BufferSize[1]; ++i)
     - X# `7 @1 y; S" H6 ~
355.                         USART2_RevBuffer<i> = 0;
     
356.         }
     3 c9 s+ d( t. ]2 E3 O
357.         else if (USARTx == USART3)
     : r0 ]3 J7 i4 K/ J7 j6 n+ ?4 P
358.         {
     9 R9 n  M% g) X6 j. f6 p2 X
359.                 USART_RevBuffer[2] = USART3_RevBuffer;
       |9 `" j+ |+ `# _( w6 R% Y+ O
360.                 USART_RevCount[2] = 0;
     9 G" ^, N" [  G7 [2 k; a( ?
361.                 USART_RevPointer[2][0] = USART_RevBuffer[2];
     % w5 B2 r2 T& }0 T
362.                 USART_RevPointer[2][1] = USART_RevBuffer[2];
     
363. 
     
364.                 for (i = 0; i < USART_BufferSize[2]; ++i)
     
365.                         USART3_RevBuffer<i> = 0;
     " u- }6 m2 Z$ S* r. _' g/ x7 V; G
366.         }
     
367.         else if (USARTx == UART4)
     7 w& |- \6 Z) z' ^+ b. L! D
368.         {
     5 d( l" E! o. W& e8 D4 I2 e
369.                 USART_RevBuffer[3] = USART4_RevBuffer;
     
370.                 USART_RevCount[3] = 0;
     6 Y. U7 c; o0 k
371.                 USART_RevPointer[3][0] = USART_RevBuffer[3];
     2 D; b7 }; \* _# X; ]) p: v4 {
372.                 USART_RevPointer[3][1] = USART_RevBuffer[3];
     
373. 
     : ?1 S' h6 ~( V5 P; X) \
374.                 for (i = 0; i < USART_BufferSize[3]; ++i)
     
375.                         USART4_RevBuffer<i> = 0;
     % c) r+ I' W  f, |
376.         }
     6 ~$ k5 ^" i$ }& y2 U! [9 y  V9 M
377.         else if (USARTx == UART5)
     4 m9 W: U; x  I
378.         {
     
379.                 USART_RevBuffer[4] = USART5_RevBuffer;
     
380.                 USART_RevCount[4] = 0;
     
381.                 USART_RevPointer[4][0] = USART_RevBuffer[4];
     
382.                 USART_RevPointer[4][1] = USART_RevBuffer[4];
     
383. 
     # _, E0 n) B$ a/ o# i6 p0 D
384.                 for (i = 0; i < USART_BufferSize[4]; ++i)
     
385.                         USART5_RevBuffer<i> = 0;
     ) o: y$ X* p0 a, \( ~- z
386.         }
     
387.         else
     , |) u; t, Z: p3 V9 J
388.         {
     % X: b$ S: T& |# G! H: W8 j# M
389.                 ;
     
390.         }
     9 }& k& I. D- P" D
391. }
     
392. 
     9 Y" b4 r. _2 h, _( j, w1 }
393. 
     / @  ~2 j( H2 I# Q! y% t4 q
394. /**
     
395. * @brief 通过指定串口发送字节数据
     , v1 n5 c8 p# v( u1 G
396. *                 通过查询的方式确认发送结果，如果发送失败，此函数会阻塞
     
397. * @param USARTx: 发送数据的串口
     4 }4 Q  n! k3 V. }" z
398. * @param byteData: 发送的字节数据
     0 j* z5 a  E+ z% V7 O! {* }
399. */
     
400. void USART_SendByteData(USART_TypeDef* USARTx, const uint8_t byteData)
     
401. {
     
402.         USART_SendByte(USARTx, (uint16_t) byteData);
     ! Z3 b" m6 D- P/ W
403.         while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET)
     
404.                 ;
     ( I0 _* T2 _: H: l) F
405. }
     
406. 
     
407. 
     
408. /**
       G- d4 m( a' Z6 I7 |
409. * @brief 通过指定的串口发送连续16位数据
     
410. *                 单个16位数据的传输通过发送两次8位数据，高位先发送，低位后发送
     
411. *                 通过查询的方式确认发送结果，如果发送失败，此函数会阻塞
     6 h8 G! C3 [4 \; y" p
412. * @param USARTx: 发送数据的串口
     
413. * @param Data: 发送16位数据的起始地址
     
414. * @param Count: 发送数据的数量
     * p9 ]4 X8 M' m. F- R3 l
415. */
     
416. void USART_SendData_Bit16(USART_TypeDef* USARTx, const uint16_t *Data, uint16_t Count)
     
417. {
     
418.         for (uint16_t i = 0; i < Count; i++)
     
419.         {
     
420.                 USART_SendByte(USARTx, (*Data) >> 8);
     ; Q) N& w+ U4 l: i
421.                 while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET)
     $ T  b# c+ P! _2 Q5 o1 D
422.                         ;
     
423.                 USART_SendByte(USARTx, *Data);
     
424.                 while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET)
     5 B  P, n) b5 n3 G
425.                         ;
     ) E; Q2 s# U1 P6 ^
426.                 Data++;
     
427.         }
     
428. }
     
429. 
     
430. 
     
431. /**
     
432. * @brief 通过指定的串口发送连续8位数据
     , [  o2 G  X& |
433. *                 通过查询的方式确认发送结果，如果发送失败，此函数会阻塞
     
434. * @param USARTx: 发送数据的串口
     
435. * @param Data: 发送8位数据的起始地址
     
436. * @param Count: 发送数据的数量
     
437. */
     # r( i$ j( G4 ]# B# K4 K0 P
438. void USART_SendData(USART_TypeDef* USARTx, const uint8_t *Data, uint16_t Count)
     
439. {
     ! `$ E0 Y5 l* {) B4 A4 Z
440.         uint16_t i;
     
441. 
     & x  f' |4 A- e! ?
442.         for (i = 0; i < Count; i++)
     
443.         {
     2 u" g0 @, A6 L1 x1 T! m
444.                 USART_SendByte(USARTx, (uint16_t) *Data);
     
445.                 Data++;
     / ~9 ^) E0 V9 ^/ d
446. 
     $ g5 T1 ~0 z1 W: G% p! i% ~
447.                 while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET)
     - z  z$ G) v/ H3 V1 v8 _
448.                         ;
     
449.         }
     
450. }
     , ^9 w, G, B. w! T4 A
451. 
     + D$ d0 _5 R$ J2 a. m: e, s: T2 e
452. 
     
453. /**
     : x/ U; N& d- p! ]9 b
454. * @brief 通过指定的串口发送字符串
     0 j5 j4 J/ r4 ]5 K& F" L
455. *                 通过查询的方式确认发送结果，如果发送失败，此函数会阻塞
     
456. * @param USARTx: 发送数据的串口
     3 Q6 r' u4 I$ E8 v3 b  H* h+ l
457. * @param String: 需要发送的字符串(检测到'\0', 自动停止发送)
     
458. * @return 发送的字节数
     1 a: k. k+ B8 o8 u
459. */
     
460. uint16_t USART_SendString(USART_TypeDef* USARTx, const char *String)
     
461. {
     ' G$ J; M$ `2 E9 q5 E3 U
462.         uint16_t count = 0;
     
463.         while (*String != '\0')
     
464.         {
     , Z) l. f; X  K6 D  f& J% ?. F. C
465.                 USART_SendByte(USARTx, *String);
     
466.                 String++;
     3 r$ Z! M" _3 P! ^, _
467.                 count++;
     
468.                 while (USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET)
     
469.                         ;
     
470.         }
     
471.         return count;
     
472. }
     
473. 
     + k6 o2 Z" m; m' q6 y
474. 
     4 |! ^' a5 M- H! J' c
475. /**
     ( P4 U. y& d$ U
476. * @brief 串口1数据接收处理函数
     ; R: D1 a+ u- K5 a
477. *                 在系统空闲时轮询或者在需要的时候调用此函数即可处理串口缓冲区中已经接收到的数据
     6 P( w9 E6 [' c  t) s& \1 x+ v& y
478. * @param USART1_RevBuffer_HdlPoint: 需要注册的数据处理回调函数
     
479. */
     # o3 j+ X3 ]4 F5 G6 B7 u
480. void USART1_RevBuffer_Handler(void (*USART1_RevBuffer_HdlPoint)(uint8_t* _Data, uint16_t Count))
     , h% ?: J( ], t
481. {
     
482.         uint16_t count = 0;
     # j! G, q( l4 g- B2 _
483.         uint8_t _data[USART1_BufferSize] =
     
484.         { 0 };
     
485. 
     
486.         while (1)
     7 c: Z; h4 }$ ?. ?
487.         {
     
488.                 if (USART_RevPointer[0][1] == USART_RevPointer[0][0])
     5 b2 l% ]! T7 R) F
489.                         break;
     
490. 
     & W% V0 ~+ x- o" C
491.                 _data[count] = *USART_RevPointer[0][1];
     
492.                 count++;
     
493.                 USART_RevPointer[0][1]++;
     9 b+ E+ U* U  u, J. y2 x
494. 
     
495.                 if (USART_RevPointer[0][1] >= USART_RevBuffer[0] + USART_BufferSize[0])
     - e: q- a- c7 `$ `' h# j3 i" z
496.                         USART_RevPointer[0][1] = USART_RevBuffer[0];
     
497.         }
     
498. 
     ; H2 `* ~% {( G9 r3 x1 f; U& I. `$ y. t
499.         USART1_RevBuffer_HdlPoint(_data, count);
     # n3 `4 G( R* H  R7 j2 Z/ M5 M
500. }
     / I: t* [" T3 Q! P  U: f
501. 
     
502. 
     
503. /**
     ; i5 ~! @, S7 p3 f# h2 q
504. * @brief 串口2数据接收处理函数
     ( o6 ^& r1 u' \$ B. d2 a0 j! Q5 e% s
505. *                 在系统空闲时轮询或者在需要的时候调用此函数即可处理串口缓冲区中已经接收到的数据
       H  N9 p7 O3 ]
506. * @param USART2_RevBuffer_HdlPoint: 需要注册的数据处理回调函数
     
507. */
     
508. void USART2_RevBuffer_Handler(void (*USART2_RevBuffer_HdlPoint)(uint8_t* Data, uint16_t Count))
     4 X1 i1 J; Y3 D9 H: X
509. {
     - T) |$ f" }, \# Y
510.         uint16_t count = 0;
     
511.         uint8_t _data[USART2_BufferSize] =
     ' i" U6 J# `/ O9 h  n) n
512.         { 0 };
     
513. 
     ; i& p+ u: m' G2 }1 }8 l
514.         while (1)
     
515.         {
     6 @  H; P! t3 A' Y& M& s
516.                 if (USART_RevPointer[1][1] == USART_RevPointer[1][0])
     + L" j' a6 `/ x/ Q0 m' S' R
517.                         break;
     ( [3 F1 j2 _1 k- m7 o5 C
518. 
     " U" r! d( N7 |6 p$ F+ M
519.                 _data[count] = *USART_RevPointer[1][1];
     ! U; U  o2 ?- ]7 e+ ~. b
520.                 count++;
     5 t3 o4 z8 P/ \+ e, z: c6 W: L5 u4 \
521.                 USART_RevPointer[1][1]++;
     
522. 
     
523.                 if (USART_RevPointer[1][1] >= USART_RevBuffer[1] + USART_BufferSize[1])
     
524.                         USART_RevPointer[1][1] = USART_RevBuffer[1];
     # @0 \5 r2 F  n& w* j5 P
525.         }
     0 h9 ~$ `1 l+ U: j% z; N
526. 
     
527.         USART2_RevBuffer_HdlPoint(_data, count);
     
528. 
     
529. }
     - k% J1 ?4 Q2 A
530. 
     
531. 
     # u5 ?- E5 |  A9 B, a: k
532. /**
     8 z) r' z6 D9 N/ b+ b
533. * @brief 串口3数据接收处理函数
     
534. *                 在系统空闲时轮询或者在需要的时候调用此函数即可处理串口缓冲区中已经接收到的数据
     
535. * @param USART3_RevBuffer_HdlPoint: 需要注册的数据处理回调函数
     
536. */
     
537. void USART3_RevBuffer_Handler(void (*USART3_RevBuffer_HdlPoint)(uint8_t* Data, uint16_t Count))
     
538. {
     
539.         uint16_t count = 0;
     # n% A! N: ^1 F+ C  }, P
540.         uint8_t _data[USART3_BufferSize] =
     
541.         { 0 };
     ' X+ x& C" D- L
542. 
     7 \. \' b1 Q2 ?; f) h5 o
543.         while (1)
     
544.         {
     6 y  m( z, K! b' x% i) N% N
545.                 if (USART_RevPointer[2][1] == USART_RevPointer[2][0])
     
546.                         break;
     
547. 
     
548.                 _data[count] = *USART_RevPointer[2][1];
     ! G" t0 ?! z$ y1 W
549.                 count++;
       r1 o5 T9 i- _: o1 r, {
550.                 USART_RevPointer[2][1]++;
     1 j$ }5 R& P7 J5 u
551. 
     % h; X; H1 i% j/ v
552.                 if (USART_RevPointer[2][1] >= USART_RevBuffer[2] + USART_BufferSize[2])
     2 y1 y" b$ ?9 ]- Q( G7 _- D( M
553.                         USART_RevPointer[2][1] = USART_RevBuffer[2];
     
554.         }
     
555. 
     
556.         USART3_RevBuffer_HdlPoint(_data, count);
     6 k" l2 Y, i' }2 D. }. I
557. }
       t6 ^6 ]. U! |/ k/ \+ Q
558. 
     
559. 
     6 S5 l  R. E+ M
560. /**
     
561. * @brief 串口4数据接收处理函数
     1 q( S4 m/ L2 p, Z+ Z7 ~0 x
562. *                 在系统空闲时轮询或者在需要的时候调用此函数即可处理串口缓冲区中已经接收到的数据
     ' ~. s8 m8 i, g6 M: B
563. * @param UART4_RevBuffer_HdlPoint: 需要注册的数据处理回调函数
     
564. */
     $ E, v! b4 j- L
565. void UART4_RevBuffer_Handler(void (*UART4_RevBuffer_HdlPoint)(uint8_t* Data, uint16_t Count))
     
566. {
     
567.         uint16_t count = 0;
     $ V9 ]0 O( I7 e6 s( P
568.         uint8_t _data[UART4_BufferSize] =
     8 R" {7 q$ R9 M8 Y& I
569.         { 0 };
     * H/ G. H1 D. W9 G
570. 
     6 |: P# [# v+ k4 k
571.         while (1)
       k9 B$ U3 A& B3 S
572.         {
     
573.                 if (USART_RevPointer[3][1] == USART_RevPointer[3][0])
     3 c9 I# b$ I8 y+ |( Z0 M
574.                         break;
     
575. 
     8 r2 P# O1 V6 e+ p* {
576.                 _data[count] = *USART_RevPointer[3][1];
     
577.                 count++;
     ( M& i1 ^0 m8 y9 j
578.                 USART_RevPointer[3][1]++;
     
579. 
     5 Q1 G, ?0 o: }7 P
580.                 if (USART_RevPointer[3][1] >= USART_RevBuffer[3] + USART_BufferSize[3])
     
581.                         USART_RevPointer[3][1] = USART_RevBuffer[3];
     2 O4 c  o* e5 a9 J( ~) f
582.         }
     . f1 ~4 y9 T9 v: c7 T' _' S$ b& ^
583. 
     , q' T& I2 P) r
584.         UART4_RevBuffer_HdlPoint(_data, count);
     
585. 
     
586. }
     $ d/ u9 k1 U/ }" k+ X* U9 u
587. 
     
588. 
     
589. /**
     $ Y3 G# \% q$ n
590. * @brief 串口5数据接收处理函数
     
591. *                 在系统空闲时轮询或者在需要的时候调用此函数即可处理串口缓冲区中已经接收到的数据
     " t3 ?  s) {  R: x$ U
592. * @param UART5_RevBuffer_HdlPoint: 需要注册的数据处理回调函数
     
593. */
     
594. void UART5_RevBuffer_Handler(void (*UART5_RevBuffer_HdlPoint)(uint8_t* Data, uint16_t Count))
     + a% [! u' C$ J+ g! w
595. {
     
596.         uint16_t count = 0;
     7 Z) T. B  M" h' `/ n9 W# |
597.         uint8_t _data[UART5_BufferSize] =
     
598.         { 0 };
     
599. 
     0 ^0 }& g* _1 F6 O
600.         while (1)
     0 M' a2 ]% P; k; Z. w4 k2 ]
601.         {
     
602.                 if (USART_RevPointer[4][1] == USART_RevPointer[4][0])
     
603.                         break;
     4 J" v% B" w  o- X& q
604. 
     
605.                 _data[count] = *USART_RevPointer[4][1];
     
606.                 count++;
     
607.                 USART_RevPointer[4][1]++;
     
608. 
     ' U2 ~$ p4 |8 X0 D5 f) Q4 W3 M9 A
609.                 if (USART_RevPointer[4][1] >= USART_RevBuffer[4] + USART_BufferSize[4])
     
610.                         USART_RevPointer[4][1] = USART_RevBuffer[4];
     9 h9 P2 G% ?8 {( T# z$ G; W1 z3 ]. n4 r
611.         }
     $ l: n) f+ t- f5 S
612. 
     
613.         UART5_RevBuffer_HdlPoint(_data, count);
     
614. }
       `2 x9 R/ Z! j' G  ^0 q+ G
615. 
     
616. 
     
617. /*************************以下是串口中断服务函数*********************************/
     
618. /****************根据是否启用modbus，会启用不同的服务函数********************/
       F, \5 g# [% W' Z
619. #if FREEMODBUS_ENABLE==0
     
620. void USART1_IRQHandler(void)
     " h, A/ q! W% p. J- f+ T+ k
621. {
     , M& T2 m% G  s! n- d/ }* P
622.         /**
     
623.          * 如果使能串口接收中断，那么ORE为1时也会产生中断。
       {5 f7 I- s2 N) Q- G0 Z  N
624.          * 在应用中对ORE标志进行处理，当判断发生ORE中断的时候，
     - N  n: k+ f! `
625.          * 我们再读一次USART_DR的值，
     
626.          * 这样如果没有新的Overrun 溢出事件发生的时候，ORE会被清除,
     
627.          * 然后程序就不会因为ORE未被清除而一直不断的进入串口中断
     
628.          */
     6 f( X8 d5 f0 E3 E1 }$ H5 O- U- R
629.         if(USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET)
     ' {+ [+ K! M% v4 u/ Z* N) Z2 m
630.         {
     2 Q+ s% V1 H$ h2 o/ q4 x- C
631.                 USART_ReceiveByte(USART1);
     
632.         }
     
633. 
     
634.         if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
     
635.         {
     
636.                 USART_ClearITPendingBit(USART1, USART_IT_RXNE);
     
637.                 *USART_RevPointer[0][0] = (u8) USART_ReceiveByte(USART1);
     
638.                 USART_RevPointer[0][0]++;
     " ~2 h/ q4 `* S" {+ ]+ b# g
639.                 USART_RevCount[0]++;
     
640. 
     
641.                 if (USART_RevPointer[0][0] >= USART_RevBuffer[0] + USART_BufferSize[0])
     
642.                         USART_RevPointer[0][0] = USART_RevBuffer[0];
     0 s+ W. h; u$ E" j0 G  T
643.         }
     4 N( K. w- `8 ]
644. }
     / R" x# G9 t/ `  H3 `9 F
645. 
     2 C3 s* h- l0 e. [
646. 
     
647. void USART2_IRQHandler(void)
     ) G2 a& g1 l3 Q4 o/ g" k
648. {
     
649.         if(USART_GetFlagStatus(USART2, USART_FLAG_ORE) != RESET)
     - L/ L) V( t  A3 v0 w( x, |
650.         {
     ; I* k) F; n% Z: ^& ?: E
651.                 USART_ReceiveByte(USART2);
     
652.         }
     
653. 
     
654.         if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
     7 ?& t- O8 ^5 B* M. O* K6 q. b1 {
655.         {
     7 f/ O+ ~9 o3 O
656.                 USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     
657.                 *USART_RevPointer[1][0] = (u8) USART_ReceiveByte(USART2);
     # g5 U3 a8 |8 t5 D
658.                 USART_RevPointer[1][0]++;
     
659.                 USART_RevCount[1]++;
     9 A% V" T# u2 _/ V% z/ {4 c- d2 i
660. 
     / F) {3 w5 r8 L& n. {( u+ u$ n
661.                 if (USART_RevPointer[1][0] >= USART_RevBuffer[1] + USART_BufferSize[1])
     9 P& M- k0 N' a' o1 k* D* N# T5 f
662.                         USART_RevPointer[1][0] = USART_RevBuffer[1];
     & ^( M# i7 z* B- y5 {
663.         }
     
664. }
     ! r0 Y8 Y, m4 w7 A& A
665. 
     9 o; N* n, q! ?3 m% \
666. 
     
667. void USART3_IRQHandler(void)
     ( ~7 D2 j: F& |
668. {
     
669.         if(USART_GetFlagStatus(USART3, USART_FLAG_ORE) != RESET)
     4 N9 f' Y& i8 L. ~) n; o
670.         {
     
671.                 USART_ReceiveByte(USART3);
     " R% x# p2 l5 r
672.         }
     + _$ K8 W! |3 A. x8 v5 I& n
673. 
     4 k# C- s( f" @. @9 u% M+ N! u
674.         if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
     ) v) x* n) y' n- l( H- s( s. U3 a9 n
675.         {
     4 u. P' C2 _* b8 A2 v+ t; q! N, A
676.                 USART_ClearITPendingBit(USART3, USART_IT_RXNE);
     9 b2 B$ ^* z# r9 x; c" |
677.                 *USART_RevPointer[2][0] = (u8) USART_ReceiveByte(USART3);
     8 |2 P# m! B" M0 u8 Z) I2 M, g/ I% R
678.                 USART_RevPointer[2][0]++;
     
679.                 USART_RevCount[2]++;
     
680. 
     
681.                 if (USART_RevPointer[2][0] >= USART_RevBuffer[2] + USART_BufferSize[2])
     ( K" V9 ~2 e$ H+ P
682.                         USART_RevPointer[2][0] = USART_RevBuffer[2];
     
683.         }
     
684. }
     : I/ E- f% H5 X1 P( C* L+ l6 d
685. 
     # z1 |  }) ^; ?7 I
686. 
     
687. void UART4_IRQHandler(void)
     
688. {
     , w7 L4 i. O+ ~1 U
689.         if(USART_GetFlagStatus(UART4, USART_FLAG_ORE) != RESET)
     $ ?& }8 a( }4 n2 O( D
690.         {
     7 X! C% y2 N3 U& M  c
691.                 USART_ReceiveByte(UART4);
     
692.                 USART_ClearFlag(UART4, USART_FLAG_ORE);
     + B! M: [7 s. u7 n" q' s
693.         }
     6 R" }: j4 }6 Z( o
694. 
     
695. 
     % @3 T; k  J$ @1 u9 \, K$ |: N, n
696.         if (USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)
     6 w+ |! ~3 |# K. O3 o* X
697.         {
     4 [. L6 o+ o0 |% c
698.                 USART_ClearITPendingBit(UART4, USART_IT_RXNE);
     
699.                 *USART_RevPointer[3][0] = (uint8_t) USART_ReceiveByte(UART4);
     
700.                 USART_RevPointer[3][0]++;
     
701.                 USART_RevCount[3]++;
     1 {" k$ d! ]' S& {& R& d3 j$ D
702. 
     
703.                 if (USART_RevPointer[3][0] >= USART_RevBuffer[3] + USART_BufferSize[3])
     
704.                         USART_RevPointer[3][0] = USART_RevBuffer[3];
     , B7 Y) L6 h6 b
705.         }
     / o) c1 C4 U# F+ }9 A& ^
706. }
     2 x7 C$ T. z9 G
707. 
     
708. 
     
709. void UART5_IRQHandler(void)
     * _% Q* n7 j; n, m
710. {
     8 }$ u) R% @" S
711.         if(USART_GetFlagStatus(UART5, USART_FLAG_ORE) != RESET)
     # f3 A  O. U0 [! M  l1 \) y
712.         {
     
713.                 USART_ReceiveByte(UART5);
     1 `9 Q0 F* ~, X
714.                 USART_ClearFlag(UART5, USART_FLAG_ORE);
     & V7 X, o; @) l9 }& ^* F
715.         }
     
716. 
     , a) d( k1 F7 U1 Z, s
717.         if (USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
     # w9 Q4 d$ b) d) G" j9 ~
718.         {
     - O* f+ [: s8 A. }2 ?# E! }
719.                 USART_ClearITPendingBit(UART5, USART_IT_RXNE);
     
720.                 *USART_RevPointer[4][0] = (uint8_t) USART_ReceiveByte(UART5);
     0 b: G- Z4 d' v9 G
721.                 USART_RevPointer[4][0]++;
     
722.                 USART_RevCount[4]++;
     
723. 
     / J3 y2 m9 o  Q2 S/ v* M. y3 I
724.                 if (USART_RevPointer[4][0] >= USART_RevBuffer[4] + USART_BufferSize[4])
     ; U& G+ T0 c* n# `: j9 \2 I
725.                         USART_RevPointer[4][0] = USART_RevBuffer[4];
     
726.         }
     ' z* O( c6 b9 M- `( M: S+ D
727. }
     4 T; D. K; V/ N. l% o
728. #else
     $ u6 O/ Y3 I+ u- k1 n5 o
729. void USART1_IRQHandler(void)
     3 x6 }( O: Y( D  y/ k; p
730. {
     5 B4 ?. P7 Y. T+ A# G! b
731.         /**
     
732.          * 如果使能串口接收中断，那么ORE为1时也会产生中断。
     
733.          * 在应用中对ORE标志进行处理，当判断发生ORE中断的时候，
     
734.          * 我们再读一次USART_DR的值，
     $ h6 L- `  d" M& `$ U) i
735.          * 这样如果没有新的Overrun 溢出事件发生的时候，ORE会被清除,
     ' z0 u4 I. n7 o( _' ^
736.          * 然后程序就不会因为ORE未被清除而一直不断的进入串口中断
     2 N2 o9 [1 m* O! K* {2 S) i1 [
737.          */
     0 E/ g1 S3 J1 S. q
738.         if(USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET)
     
739.         {
     
740.                 USART_ReceiveByte(USART1);
     ' U% p) M6 ]' W% {; [( R9 Z
741.         }
     ' s4 p$ \7 L( @0 w
742. 
     ) t; F. J' \( p, s! x: g  m: U; T1 j0 v
743.         if(FreeModbus_PortNum == 1)
     
744.         {
     
745.                 if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
     
746.                 {
     
747.                         //                prvvUARTRxISR();
     
748.                         pxMBFrameCBByteReceived();
     0 S& ^0 u1 z; a$ R  S; \
749.                         USART_ClearITPendingBit(USART1, USART_IT_RXNE);
     ' _$ b6 d% d) g2 f. B
750.                 }
     , K( Y' i$ u+ q, I4 K5 h
751.                 else if(USART_GetITStatus(USART1, USART_IT_TC) != RESET)
     
752.                 {
     / K) y3 F1 b4 A' v/ ]
753.                         //                prvvUARTTxReadyISR();
     + J. l: E7 N$ Q' ]0 U, m0 C5 x
754.                         pxMBFrameCBTransmitterEmpty();
     
755.                         USART_ClearITPendingBit(USART1, USART_IT_TC);
     
756.                 }
     
757.                 else
     
758.                 {
       {4 `) X7 `7 U: I5 V: ~$ U* J$ s/ {- R
759. 
     1 ~6 P3 w0 C" o5 `( n( ^: Q- [. X+ _
760.                 }
     
761.         }
     
762.         else
     
763.         {
     , F2 p  x0 y: }. ^
764.                 if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
     
765.                 {
       \; F8 v# O/ C2 T3 t9 W( o$ u2 G
766.                         USART_ClearITPendingBit(USART1, USART_IT_RXNE);
     7 k' Z; n- b: f5 z) ~. j
767.                         *USART_RevPointer[0][0] = (u8) USART_ReceiveByte(USART1);
     9 X( U* S! {! O1 y: v& K. N, ]
768.                         USART_RevPointer[0][0]++;
     + L6 `2 C; k7 {
769.                         USART_RevCount[0]++;
     , w2 M5 c, M. j; o( t0 h
770. 
     
771.                         if (USART_RevPointer[0][0] >= USART_RevBuffer[0] + USART_BufferSize[0])
     
772.                                 USART_RevPointer[0][0] = USART_RevBuffer[0];
     1 C- a2 q- v+ {: W
773.                 }
     
774.         }
     
775. }
     0 v+ |8 }8 W6 b; q% D+ i
776. 
     2 K% }. ^1 O% y3 c2 e
777. 
     0 Y1 E" Q% |) m4 [+ d2 Q0 T
778. void USART2_IRQHandler(void)
     
779. {
     
780.         if(USART_GetFlagStatus(USART2, USART_FLAG_ORE) != RESET)
     
781.         {
     # B5 }4 m) [, K
782.                 USART_ReceiveByte(USART2);
       @* ]; K& I: y7 J- q* V
783.         }
     
784. 
     
785.         if(FreeModbus_PortNum == 2)
     
786.         {
     - Q+ ]9 r; h: P( p: K: a. A& v
787.                 if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
     
788.                 {
     
789.                         USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     
790.                         pxMBFrameCBByteReceived(  );
     ' s" O: \- h1 T; h
791.                 }
     
792.                 else if(USART_GetITStatus(USART2, USART_IT_TC) != RESET)
     2 W6 `' c) C2 ^- e
793.                 {
     1 H* T2 w5 Q% K1 W/ |# w
794.                         USART_ClearITPendingBit(USART2, USART_IT_TC);
       x+ M8 c: V0 f: [3 d
795.                         pxMBFrameCBTransmitterEmpty(  );
     
796.                 }
     % ~$ W  W2 f% t1 k% i  ]& Z5 M
797.                 else
     ' v7 I3 R( X7 t! F( x
798.                 {
     
799. 
     ( }0 c, [  u) Q
800.                 }
     
801.         }
     
802.         else
     
803.         {
     + ?; S5 A9 {+ f% n$ `- X
804.                 if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
     ' g7 N& A3 F' {0 o
805.                 {
     
806.                         USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     ; p4 k9 |& B0 c" Z  n$ J$ a, @6 `
807.                         *USART_RevPointer[1][0] = (u8) USART_ReceiveByte(USART2);
     6 D( F1 c  a: ~, b# F6 ]
808.                         USART_RevPointer[1][0]++;
     ) k2 v4 h3 O* I
809.                         USART_RevCount[1]++;
     
810. 
     
811.                         if (USART_RevPointer[1][0] >= USART_RevBuffer[1] + USART_BufferSize[1])
     
812.                                 USART_RevPointer[1][0] = USART_RevBuffer[1];
     
813.                 }
     1 x, P  `7 v5 x
814.         }
     8 D5 }; I* g; x/ N/ v
815. }
     
816. 
     , \, o) R+ c3 n* U
817. 
     
818. void USART3_IRQHandler(void)
     
819. {
     
820.         if(USART_GetFlagStatus(USART3, USART_FLAG_ORE) != RESET)
     
821.         {
     
822.                 USART_ReceiveByte(USART3);
     
823.         }
     
824. 
     
825.         if(FreeModbus_PortNum == 3)
     
826.         {
     
827.                 if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
     
828.                 {
     
829.                         USART_ClearITPendingBit(USART3, USART_IT_RXNE);
     
830.                         pxMBFrameCBByteReceived(  );
     - ^6 _2 K. c3 i. z2 O
831.                 }
     ; a4 I( W: P( X
832.                 else if(USART_GetITStatus(USART3, USART_IT_TC) != RESET)
     
833.                 {
     
834.                         USART_ClearITPendingBit(USART3, USART_IT_TC);
     7 E/ Q0 i$ J& |% J: ]2 p' j& n* v) S
835.                         pxMBFrameCBTransmitterEmpty(  );
     5 k+ @3 }* T& d0 p3 G! d
836.                 }
       T. G( P$ R% C1 i0 }
837.                 else
     
838.                 {
     % p) t. R* `; }' j
839.                
     
840.                 }
     6 d$ l0 A& n  u" `' s8 z
841.         }
     5 h: [  y6 K6 L- e5 |$ P
842.         else
     
843.         {
     9 W" [  H1 J8 Z( o( Y0 o
844.                 if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
     
845.                 {
     
846.                         USART_ClearITPendingBit(USART3, USART_IT_RXNE);
     
847.                         *USART_RevPointer[2][0] = (u8) USART_ReceiveByte(USART3);
     , f) y9 m" R) B4 c5 o7 o+ N8 R6 r
848.                         USART_RevPointer[2][0]++;
     ) l  S0 ?# Y( {; R. v
849.                         USART_RevCount[2]++;
     
850. 
     " y+ e5 m) F( d0 I& D0 S/ ~' I
851.                         if (USART_RevPointer[2][0] >= USART_RevBuffer[2] + USART_BufferSize[2])
     
852.                                 USART_RevPointer[2][0] = USART_RevBuffer[2];
     8 h0 E4 V1 T& Y# @9 Z0 n4 e
853.                 }
     
854.         }
     4 U3 f# c6 w) D& `
855. }
     . S% U2 C+ k1 j# {
856. 
     
857. 
     
858. void UART4_IRQHandler(void)
     $ b. A( d5 Q* U" q
859. {
     - d2 L+ H* F- o5 j7 F& A/ U
860.         if(USART_GetFlagStatus(UART4, USART_FLAG_ORE) != RESET)
     
861.         {
     * L. a* o, U7 b/ c" ?4 Q0 |! @% R
862.                 USART_ReceiveByte(UART4);
     : V- e; i: h- P+ y) U, y
863.                 USART_ClearFlag(UART4, USART_FLAG_ORE);
     9 ~- B8 Y8 N% u% Z
864.         }
     7 c! j* ?7 Y+ }3 p
865. 
     
866.         if(FreeModbus_PortNum == 4)
     
867.         {
     
868.                 if (USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)
     
869.                 {
     
870.                         USART_ClearITPendingBit(UART4, USART_IT_RXNE);
     " K8 B  {6 f2 g7 L
871.                         pxMBFrameCBByteReceived(  );
     
872.                 }
     
873.                 else if(USART_GetITStatus(UART4, USART_IT_TC) != RESET)
     4 z! R8 A- A8 k2 t5 Q! S0 w8 _
874.                 {
     $ x& r( [! r& X
875.                         USART_ClearITPendingBit(UART4, USART_IT_TC);
     
876.                         pxMBFrameCBTransmitterEmpty(  );
     3 Y7 W% s) C$ K  l$ j* |) ]  S
877.                 }
     
878.                 else
     " ^$ p0 y; g4 ]9 J' l, A
879.                 {
     1 f! M! y( L4 N- M2 d
880. 
     " b( Y9 e, s+ ~2 e
881.                 }
     5 D; m) a) t! o- {7 t
882.         }
     % i! @- A" I6 ], ]& r5 E: \) K
883.         else
     
884.         {
     $ m& N' ]0 _8 m: I. R
885.                 if (USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)
     2 L, N% ^. e) R
886.                 {
     / ?# u7 v" m4 P2 y% w
887.                         USART_ClearITPendingBit(UART4, USART_IT_RXNE);
     # w) S# J: j9 g7 b! M
888.                         *USART_RevPointer[3][0] = (uint8_t) USART_ReceiveByte(UART4);
     
889.                         USART_RevPointer[3][0]++;
     
890.                         USART_RevCount[3]++;
     
891. 
     
892.                         if (USART_RevPointer[3][0] >= USART_RevBuffer[3] + USART_BufferSize[3])
     
893.                                 USART_RevPointer[3][0] = USART_RevBuffer[3];
     
894.                 }
     ; _$ t/ |8 G* {! i/ I0 R  k+ v/ B
895.         }
     " E' j: W9 n+ y7 t& x2 R+ S
896. }
     
897. 
     
898. 
     
899. void UART5_IRQHandler(void)
     & U# o, W/ o: ~$ A
900. {
     6 ~# O* u7 k0 {$ @/ x
901.         if(USART_GetFlagStatus(UART5, USART_FLAG_ORE) != RESET)
     
902.         {
     
903.                 USART_ReceiveByte(UART5);
     " f! Q2 e/ ~" @* v) E/ X$ N, ]8 N6 t
904.                 USART_ClearFlag(UART5, USART_FLAG_ORE);
     
905.         }
     
906. 
     
907.         if(FreeModbus_PortNum == 5)
     
908.         {
     
909.                 if (USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
     5 }% W- y5 @+ i( D- Q8 |
910.                 {
     ; n; G6 V% a* g1 J
911.                         USART_ClearITPendingBit(UART5, USART_IT_RXNE);
     
912.                         pxMBFrameCBByteReceived(  );
     " R9 Z& @2 U2 u7 H. H1 g
913.                 }
     
914.                 else if(USART_GetITStatus(UART5, USART_IT_TC) != RESET)
     ! Q6 H6 o3 U$ `* U3 Y
915.                 {
     " |' T/ {0 ?& N/ f1 x, Z8 E
916.                         USART_ClearITPendingBit(UART5, USART_IT_TC);
     . K# Y/ _& N* N: I8 e1 z% I
917.                         pxMBFrameCBTransmitterEmpty(  );
     
918.                 }
     
919.                 else
     
920.                 {
     $ b9 J1 T; `1 v1 \0 W
921.                         
     
922.                 }
     
923.         }
     2 F9 i( E  n" T  v1 F3 N8 q) O" h
924.         else
     ( t0 k9 Q  p+ I  {
925.         {
     
926.                 if (USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
     + v9 ~4 w6 r* x+ C
927.                 {
     3 j. Q* _, O; R' {# x. q+ U
928.                         USART_ClearITPendingBit(UART5, USART_IT_RXNE);
     
929.                         *USART_RevPointer[4][0] = (uint8_t) USART_ReceiveByte(UART5);
     
930.                         USART_RevPointer[4][0]++;
     - S! D$ I2 |1 T* H9 U; t
931.                         USART_RevCount[4]++;
     ; z) f( d4 `6 p9 X! L) W
932. 
     
933.                         if (USART_RevPointer[4][0] >= USART_RevBuffer[4] + USART_BufferSize[4])
     
934.                                 USART_RevPointer[4][0] = USART_RevBuffer[4];
     
935.                 }
     
936.         }
     # P$ I9 H+ H7 ]7 ~
937. }
     
938. #endif
     
939. </i></i></i></i></i></i></i></i></i></i></i></i></i>

复制代码

使用指南
基本使用流程
配置串口外设
配置GPIO
7 A# j4 c0 G& F' y0 \& I. u( O

1. void GPIO_Config()
   
2. {
   7 L$ u* i2 c8 E
3. 
   
4.         GPIO_InitTypeDef GPIO_InitStructure;
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE, ENABLE);
   
6. 
   
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
   
8. 
   9 P: y3 K1 ?' V: s% q, l
9.         GPIO_AFIODeInit();
   3 ^# x8 s+ P: `, |( }
10.         /*JTAG-DP Disabled and SW-DP Enabled, use PB3, PB4 as GPIO*/
    . Z8 f+ v, }6 ]
11.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
    2 D. g% A: {! f; }( z7 S: v8 M& r
12. 
    8 v, z: R2 r: p, q
13.         /**
    ) D& y, u- M$ w! y2 w4 E
14.          * System State LED
    
15.          */
    9 z4 v% u( f! b
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    
17.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    " F: X7 O) T% h; i5 G7 e$ V1 o
18.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
19.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    ! K6 ^- E. u- m4 g8 }0 g
20. 
    0 g+ N& u" s7 o9 r3 a
21.         GPIO_ResetBits(GPIOA, GPIO_Pin_15);
    0 V% ?1 ~0 `# D$ r$ u
22.         
    
23.         /**
    ( r  h+ s- _- S! v+ b" }
24.          * Serial Port Interface
    . V7 v, |: J  k2 X
25.          */
    2 R+ ^. m& l: {6 G
26.         /***************USART1_TX-->GPIOA.9************/
    
27.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
28.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
29.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
30.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    $ v1 O) E+ G+ K
31. 
    
32.         /***************USART1_RX-->GPIOA.10***********/
    1 Z7 A3 [' K8 k' I& o
33.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
34.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
35.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    
36.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    5 C- T1 X6 s8 M" H$ s% ^
37. }
    ! |' ?$ n5 u8 x$ j: X

复制代码

# l7 J& `. b3 q" ~) c配置USART

1. void USART_Config()
   
2. {
   
3.         USART_InitTypeDef USART_InitStructure;
   
4.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
   
5. 
   
6.         USART_InitStructure.USART_BaudRate = USART1_BAUDRATE;
   # f' L6 X+ ]' a* D+ y- O
7.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
   
8.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
   , j5 o( n$ C9 I2 }$ ]/ g
9.         USART_InitStructure.USART_Parity = USART_Parity_No;
   ' R3 b: }% h2 A1 W" {$ m+ z. ?  G
10.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    2 H( e8 q9 v- o0 i
11.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    ! h, V+ h! a# z# b4 ~
12. 
    
13.         USART_Init(USART1, &USART_InitStructure);
    
14.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    ! O1 z, _; e, F" X
15. }

复制代码

5 d1 U/ P$ h4 b+ ^配置NVIC

1. void NVIC_Config()
   
2. {
   * k% V  B6 ?& B3 E% C, s; U4 \
3.         NVIC_InitTypeDef NVIC_InitStructure;
   + m2 X3 S  t9 R% L( N2 E
4.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   3 u; G0 H% f6 F
5.         
   
6.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
   
7.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
   
8.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
   8 Y' m' K' s, w% a0 B' B
9.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   
10.         
    3 ?8 g/ H$ _6 \& I2 ^
11.         NVIC_Init(&NVIC_InitStructure);
    
12. }

复制代码

打开串口
/ z& H9 E! W5 L. _  R

1. void User_Init()
   0 R# n2 B) ^# C- S
2. {
   
3.         /*省略无关内容*/
   0 ~) d' \" R% d! N5 [, B+ t( @) j
4.         USART_RevInitAll( );
   
5.         USART_Cmd(USART1, ENABLE);
   
6.         /*省略无关内容*/
   : _* e  L+ @0 q6 U' O9 }
7. }

复制代码

定义数据处理函数
定义一个数据处理函数，并将其作为参数传递给接收数据处理函数。
' E& u  Q9 G+ N- B& D( S1 t

1. void ReceiveFromPC(uint8_t *_Data, uint16_t Count)
   % C% o2 f1 r1 F3 {* C9 O
2. {
   
3.         //如果没有接收数据就直接返回
   $ k' ~; q* c. o/ Z4 T" s. M9 @' r
4.         if (Count == 0)
   & ~" R" p! d$ a# X
5.                 return;
   " Z) y# ?0 s# N* h
6.         //处理接收的数据
   
7.         for (int i = 0; i < Count; i++)
   
8.         {
   $ L: X4 l  p! I8 a
9.                 shellHandler(*_Data++);
     u+ u+ q/ S( W) o  D2 J3 f3 D# X* h
10.         }
    
11. }

复制代码

# n0 A; T: [# e4 u  U7 }: ]$ [8 F处理接收数据
在系统空闲时（一般在主函数的轮询中）或者其他需要的地方调用数据处理函数处理接收的数据。

1. int main(void)
   , b* R, y1 z+ y/ t( l
2. {
   $ P& x8 t7 {# }' }- R8 ]. I
3.         //略初始化外设
   ( c: _* p* c& a- `
4.         //初始化用户配置
   
5.         /*省略无关内容*/
   6 P" O/ p% W, Z
6.         while (1)
   
7.         {
   0 m3 M. T0 @# x6 E8 p1 |' e* }
8.                 /*省略无关内容*/
   
9.                 //ReceiveFromPC为USART1接收数据的处理函数
   
10.                 USART1_RevBuffer_Handler(ReceiveFromPC);
    2 G; K: S" R  y* R: f; Y& L
11.                 /*省略无关内容*/
      d) l) B# b& K, {1 S" N) _" a
12.         }
    6 f0 v+ }9 n5 U& G* c
13. }
    

复制代码

发送数据
: O. m4 s% ~0 f1 Y: x  E# N* V在需要的地方，根据数据内容选择适合的数据传输函数。
& J- l% c, h9 A2 c" ^
* ~9 {: ~( d, {: e/ k) Y通过指定串口发送字节数据
  s8 e5 L( l$ {/ Uvoid USART_SendByteData(USART_TypeDef* USARTx,const uint8_t byteData)
通过指定的串口发送连续16位数据
void USART_SendData_Bit16(USART_TypeDef* USARTx,const uint16_t *Data, uint16_t Count)
通过指定的串口发送连续8位数据
4 W9 x! L- I/ f3 f+ U6 Ovoid USART_SendData(USART_TypeDef* USARTx, const uint8_t *Data, uint16_t Count)
1 [: P+ {& q5 [通过指定的串口发送字符串
uint16_t USART_SendString(USART_TypeDef* USARTx, const char *String)
- S1 a3 f5 ~- E' O, d
- A2 ^  c, e8 [7 i
  {- |6 M' _6 k, f6 h
, f1 x7 y! c# M6 B2 c