一、设计用途：

公司PCB制成板降成本，选择的MCU比项目需求少一个串口，为满足制成板成本和项目对串口需求，选择模拟一路串口。

二、硬件电路：

+ u% w+ u7 ^2 r. j8 t

! g9 E# _% A; B7 [. a
; k# r/ n; F/ O3 ^7 {

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

串口是一种很常用的通信接口，按位(bit)发送和接收字节，串口通信是异步传输，端口能够在一根线上发送数据同时在另一根线上接收数据。串口通信最重要的参数是比特率、数据位、停止位和奇偶校验。对于两个进行通信的端口，这些参数必须匹配，在我们单片机设计中发送和接收一个字节的位格式一般由起始信号位，数据位，停止位组成，很少有校验位，但是可以有。

2、 串口STM32串口硬件实现原理

既然想要模拟串口通信，那就需要设计得最接近于硬件串口，那么硬件串口是怎样实现数据的采集的呢?

! V3 B) V$ _8 @0 g

以设置过采样率为8时进行分析：

在硬件串口接收线空闲时，串口一般会以一定频率去采集接收线上电平信号，如果辨认出一个特殊序列，1110X0X0X0X0X0X0 则确认接收到起始帧，触发接收中断。在前面判断三个1后如果后面采集到的位中有1则会降噪声位置1，所以在模拟串口时也需要加入噪声处理。

硬件串口的噪声处理：

' Y9 f2 q9 E3 V8 ?4 G" w

% E! r  q. z& k* y0 {  ]4 Z( F

简单来说，噪声处理就是将采集到的正中间的三位值进行判定，取三个中至少两个相同值作为最终采集值。

3、 实现方式选择

在网上大概看了一些前辈做的模拟串口，大致分为以下几种：

1、 阻塞式：接收使用中断，发送直接在主函数中进行，接收时以波特率的位时间进行定时采集，尽量的将采集点位于位中间。

2、 非阻塞式：使用一个定时器或者两个定时器，将接收和发送作于中断中，但接收方式基本一致，都只采集一次，未将噪声考虑进入。

也许每个行业对噪声的关注度都不太一样，但是在我这项目中噪声确是一个不得不面对的一个问题，只为通信更可靠。

  V* ]* }; @, U: K- c: f) |* E- \- g

自写第一种实现方式：

以波特率位时间的1/6进行中断采集，将每一位均分六等份，采集五次，然后取中间三次进行值判断。

, }8 U" f9 P$ z& B$ h. j' s

1. #include "UartSet.h"
   
2. #include "string.h"
   
3. 
   
4. uint8_t ucRecvData = 0;         //每次接收的字节
   % R* ^* Y. T* _" a* y0 T
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   1 R8 j, x2 g% A0 f: c
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   
7. uint8_t ucSendBitCx = 0;        //发送位计数
   9 ?; u: \1 O; E3 ?/ P9 g% w7 _5 I
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   8 f- n2 p* Z& V$ H
9. 
   $ f, @/ |+ d% D3 x* j" h
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    ; a- a1 d8 U; `, G2 m: m
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    
13. 
    
14. uint32_t Prescaler = 0;
    $ R9 b& J" X! o
15. uint32_t Period = 0;
    ' U- [' G9 s5 D7 N$ L
16. UART gsUARTBuff;               //定义串口
    
17. 
    4 x$ b4 T& d7 L  J- [% y' f7 ]
18. TIM_HandleTypeDef htim6;
    
19. 
    
20. void MX_TIM6_Init(void)
    
21. {
    
22. 
    4 P) b% d& Z7 i" `. Y
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    
24. 
    2 C0 c- H5 q& u9 k  y, m
25.     htim6.Instance = TIM6;
    
26.     htim6.Init.Prescaler = Prescaler;
      O2 s8 b% B$ F5 G3 b( y; X$ l
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    : |/ d! y9 \* `! {9 r
28.     htim6.Init.Period = Period;
      A+ T5 e1 s/ r* F. J
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    2 T: G0 l3 m* V- I; n) V. ?& L$ |
30. 
    
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    0 i3 |8 Z' L+ \6 V$ t9 C& u6 P, P
33. 
    " A% f+ U6 s. V# W" {# n% Y
34.     HAL_TIM_Base_Init(&htim6);
    7 r% @5 W7 |0 Y
35. 
    
36. }
    ) T2 h0 o/ v# q  g# J) Y3 c
37. 
    0 N6 E  }8 H! O- f; o
38. 
    
39. void UART_GPIO_Init(void)
      P, p' n- m5 D1 L1 B* W4 p5 a
40. {
    " L  T% s1 L4 k' N, ]
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    # X) Q0 k+ M* M# E6 K( L
42. 
    # f- Y. U, {8 v; K$ m  `
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    1 x/ K6 r% [; b: G4 l  m: o
44. 
    
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    5 H9 z1 g. a# h
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    ) F& g5 ^) U$ h$ l1 G" d' t
49.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    
50. 
    
51.     GPIO_InitStruct.Pin = COM_RX_Pin;
    
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
55. 
    
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    ( }+ H7 o7 R1 P% j& K
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
58. 
    2 i6 o2 W9 c, X& K# W
59. }
    5 q9 O+ @! \: P  e5 v- h7 e# T
60. 
    
61. 
    5 A5 Z$ Y3 J* s1 B" ~
62. /*******************************************************************************
    : F& K  S, p/ \6 p/ H
63. * @FunctionName   : UART_Init.
    
64. * @Description    : 模拟串口结构体初始化.
    4 p; B$ Y0 z' W  O# b% x* v
65. * @Input          : None.
    4 Q) C! b1 U4 B/ w& w
66. * @Output         : None.
    
67. * @Return         : None.
    
68. * @Author&Data    : MrShuCai  2019.4.11.
    
69. *******************************************************************************/
    
70. void UART_Init(void)
    
71. {
    
72.     gsUARTBuff.CheckType = NONE;
    
73.     gsUARTBuff.UartMaxLength = Uartlength;
    
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
75.     UART_GPIO_Init();
    : h6 {$ d3 R; w4 \
76. 
    
77.     if(BaudRate == 1200)
    
78.     {
    3 S3 s7 H) A& z! s+ ^* m5 K) J
79.         Prescaler = 15;
    5 X: n( k& i1 t* w( |3 X4 Q
80.         Period = 623;
    
81.     }
    4 G$ m. p- B2 U: ~+ g* v& k  F
82.     else if(BaudRate == 2400)
    , z/ a6 |/ B9 t& O3 N: u
83.     {
    
84.         Prescaler = 15;
    
85.         Period = 207;
    
86.     }
    
87.     else if(BaudRate == 4800)
    
88.     {
    
89. //        Prescaler = 15;
      s* d- _& t: W
90. //        Period = 50;  //9600
    
91.              Prescaler = 15;
    ) j; O! _  {2 t
92.              Period = 103;
    
93.     }
    8 L9 p/ B% g  `* }  H- p
94. 
    
95.     MX_TIM6_Init();
    
96. }
    
97. 
    1 P' H+ M) o/ Q( ~2 l
98. 
    , a+ f) f7 I2 L9 s
99. /*******************************************************************************
    * N( e% ?9 ^& H% O+ Y& N1 @, ^4 {
100. * @FunctionName   : UART_Send_Data.
     
101. * @Description    : 模拟串口发送数据接口.
     
102. * @Input          : None.
     
103. * @Output         : None.
     9 W- M7 h( t1 T
104. * @Return         : None.
     
105. * @Author&Data    : MrShuCai  2019.4.11.
     
106. *******************************************************************************/
     + h7 h' Y: ?: F/ u" F8 c
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     " u. c- z. k" `6 |( e
108. {
     
109.     gsUARTBuff.Sendlength = size;
     
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
111.     gsUARTBuff.TxEn = 1;
     
112.     gsUARTBuff.RxEn = 0;
     + [, P+ |6 h; L. m# `9 r
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
114.     HAL_TIM_Base_Start_IT(&htim6);
     ! y7 I3 }: j9 b. r0 D; j" t
115. }
     - C' o  M% t) }' v/ c
116. 
     
117. 
     
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     8 R# t1 _, f* W6 W
121. * @Input          : None.
     + y/ I/ F8 H. R0 h. y; C' B
122. * @Output         : None.
     
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     2 m# J: j- U; y; v
125. *******************************************************************************/
     
126. void EXTI4_15_IRQHandler(void)
     
127. {
     0 {& d2 m, z: F3 o8 @/ B2 r' [) X
128. 
       E& k  \* j8 l( j# i; Q. Y
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     , f- x$ _. Z* n9 D9 }
130.     {
     
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
132. 
     
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     1 ?1 `5 Z6 A, \) T9 w: ?) ]4 z6 g
134.         {
     
135.             gsUARTBuff.RxEn = 1;
     
136.             ucRecvData = 0;
     * A/ n( m  R" V  r  Y9 S5 I
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ( b4 Z% }# C3 ]' t; S7 H
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     & |9 z6 {, o& `# c/ U- m/ f
140.     }
     % G5 S* c: \. [6 o1 p8 q' w) k
141. }
     6 i! r: |( l7 H* D/ u7 Y
142. 
     , j* G) q4 Y+ `. R- o7 L* i
143. /*******************************************************************************
     . U) h' i8 k. Z& I7 m' k  U
144. * @FunctionName   : TIM6_IRQHandler.
     * }1 ]( R4 }, n7 M) t
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     
146. * @Input          : None.
     
147. * @Output         : None.
     - P7 T: v5 S! \# s! L0 S9 V8 j
148. * @Return         : None.
     0 `* l" ~- E6 N  y! p/ a2 N. X
149. * @Author&Data    : MrShuCai  2019.4.11.
     
150. *******************************************************************************/
     
151. void TIM6_IRQHandler(void)
     $ A( H: d/ R, ^
152. {
     0 u! G0 ~' t- R3 d3 d: y8 a6 I0 ?/ I8 B
153.     HAL_TIM_IRQHandler(&htim6);
     9 h* C- Y" @. P; u. h5 ?
154. 
     / u; c4 K& Y$ u) H
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     - j+ e7 U+ ~. m) S  c6 |( Q( p
156.     {
     
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     + r; c; l/ v6 j4 _
158.         {
     0 r" E0 F; a) [% _% V4 G3 g  X: \; x
159.         case COM_START_BIT_DEAL :
     
160.         {
     
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     ; R4 p' Q5 @8 x' Y# H( ~2 C
162. 
     
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     
164.             {
     
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
166.                 ucAcquCx = 0;
     
167.                 ucSendBitCx = 0;
     2 t) x, P/ d  j) U+ Z0 D
168.             }
     % g6 v6 z2 w8 C4 p/ l
169.         }
     
170.         break;
     
171. 
     / N* R* V: E0 ^$ K
172.         case COM_DATA_BIT_DEAL :
     
173.         {
     6 O0 D  c& Z! z, Z$ D% \, v
174. 
     
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     6 g- u) W5 }- T9 _+ t' h
176. 
     " Z4 A% [7 j6 \6 B5 x* b
177.             if(++ ucAcquCx >= 6)
     
178.             {
     # z2 X, I9 C9 t( [9 T/ J/ M6 Q% H
179.                 ucAcquCx = 0;
     / C0 i. Y+ X( j8 g' \% d
180.                            
     ; C, {$ G0 |6 i; M+ R6 B
181.                 ucSendBitCx ++;
     6 x# b0 |% w  H+ y4 ?- D
182. 
     * i/ a3 }6 m) a5 K4 ~  h6 O# M% a- s
183.                 if(ucSendBitCx >= 8)
     
184.                 {
     
185.                     if(gsUARTBuff.CheckType == NONE)
     ! d$ W# C* V) w1 ~7 s4 b
186.                     {
     
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     5 c& e1 p- r. ]$ S2 P9 \& k
188.                     }
     7 `! q% L5 `. v7 F) H
189.                     else
     
190.                     {
     
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
192.                     }
     0 W% \( _- f1 [: m1 a
193.                 }
     
194.             }
     
195.         }
     
196.         break;
     % E" c; w2 B" i
197. 
     9 B$ Q( p! x% s) a' k) c' j
198.         case COM_CHECK_BIT_DEAL :
     8 B. p2 o7 i( ?) a4 @
199.         {
     
200. 
     
201.         }
     : e7 K( R/ F2 S* Y
202.         break;
     
203. 
     
204.         case COM_STOP_BIT_DEAL :
     
205.         {
     ' g4 j' y5 U  S7 k2 f" n
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
207. 
     
208.             if(++ ucAcquCx == 7)
     
209.             {
     
210.                 ucAcquCx = 0;
     ; v( D- a4 H2 Y) x* X
211.                 ucSendBitCx = 0;
     . X0 s4 ?, l9 q7 p3 O* N$ e
212. 
     
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     + m+ B' V, M0 q+ B
214.                 {
     
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     2 S( f5 U7 J& a# A
216.                     ucSendLengCx ++;
     
217.                 }
     
218.                 else
     
219.                 {
     4 w5 p) |- N$ P& [; c
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     0 v2 d+ n1 |3 i- @4 T% n
222.                     gsUARTBuff.TxEn = 0;
     1 {2 O. `+ N) _3 V+ Z. B' C7 w
223.                     gsUARTBuff.RxEn = 1;
     6 E) x+ N! u& D9 W; [6 g1 y) F8 I
224. 
     , `& N1 O) E. k6 F1 r7 U3 g  \
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     . }9 ?2 I/ q1 @3 Q
226.                     TIM6->CNT = 0;
     
227.                 }
     
228.             }
     % P% j( w& x0 U5 U( h9 p
229.         }
       t7 }; W7 D: w7 Y. m
230.         break;
     
231. 
     7 e  {3 x9 T* U, ~# i: L' S
232.         default:
     
233.             break;
     " B; G, G  o& a8 Y* l* p) y
234. 
     
235.         }
     
236.     }
     4 i+ p5 Q7 E( \) M
237. 
     / J4 c" g1 b( }# @( U! H* f" v$ a
238. 
     1 @6 m3 T7 v- e) M' {; ~/ i
239.     if(gsUARTBuff.RxEn == 1)
     
240.     {
     
241.         switch(gsUARTBuff.UartStat)
     
242.         {
     * w. Q. S" r* P( q# w0 \, o
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     6 F6 N" E, v' Z2 |7 o7 m
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     ! s* v: x5 d6 T& c; \& ~! i
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
247. 
     
248.             if(    ucAcquCx == 0)
     1 H  G( r4 ~5 p8 {
249.             {
     
250.                 ucAcquCx = 1;
     / k" o7 U: `! G( u, p) E
251.                 return ;
     
252.             }
     
253. 
     
254.             if(ucRecvLastBit == ucRecvNowBit)
     
255.             {
     
256.                 ucRecvTrueCx ++;
     
257.             }
     
258. 
     - y& L8 w/ Y  e
259.             if(++ ucAcquCx >= 5)
     + U- g5 I; Z8 t; E2 ?3 t
260.             {
     
261.                 if(ucRecvTrueCx >= 2)
     
262.                 {
     " _! x) t  `- x6 n3 Q/ D
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     8 r( s: u6 a3 P% Q, I
264.                     ucAcquCx = 0;
     
265.                     ucRecvTrueCx = 0;
     
266.                 }
       g) ~  `; U3 N5 v* U
267.                 else
     
268.                 {
     - n2 L; `$ O& O" X' P. ~
269.                     ucAcquCx = 0;
     
270.                     ucRecvTrueCx = 0;
     & h) F% Q' G$ E% H& ]* ^
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
272.                 }
     
273.             }
     
274.         }
     $ r0 D! r% n: m: X4 P+ k
275.         break;
     
276. 
     ! S. |8 _* X8 t. o' ]
277.         case COM_DATA_BIT_DEAL :                         //数据位
     6 f- n$ g( O# m; \0 Z
278.         {
     
279. 
     
280.             ucRecvLastBit = ucRecvNowBit;
     
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     
283.             if(0 == ucAcquCx)
     2 H' N7 @# k3 S$ d" m) l$ m( `
284.             {
     , m) o& ~9 T) Q3 y/ E0 ]* F
285.                 ucAcquCx = 1;
     3 I. z" l% b% x: |* w
286.                 return;
     * T" }) z) g' h
287.             }
     
288. 
     
289.             if(ucRecvNowBit == ucRecvLastBit)
     
290.             {
     0 j/ h+ T* W3 a, [
291.                 ucRecvTrueCx ++;
     
292.             }
     
293. 
     3 ]' q* J' T: K
294. 
     ; J9 ^% s% q: V" a! I( }
295.             if(++ ucAcquCx >= 6)
     9 p8 d6 [1 T6 ?  ^" j
296.             {
     
297.                 ucAcquCx = 0;
     % K6 P2 q6 T4 W) |* J
298. 
     
299.                 if(ucRecvTrueCx >= 2)
     
300.                 {
     " d8 @. [6 U2 F3 V, g9 Q
301.                     if(ucRecvLastBit == 1)
     " c% }. R. Q# \! w8 j7 p
302.                     {
     0 X' J. k6 a0 D; C! V
303.                         ucRecvData |= (1 << ucRecvBitCx);
     
304.                     }
     
305.                     else
     , |- P" P: f: _% [1 C( X
306.                     {
     
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     
308.                     }
     
309. 
     
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     
313. 
     5 W: l# K3 B7 J/ z% j
314.                         if(gsUARTBuff.CheckType == NONE)
     
315.                         {
     # n: e+ [6 p; r# R9 U& \+ }
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
317.                         }
     9 b+ i7 U& d6 ~, n
318.                         else
     6 q+ `* _5 S: y! C3 Y
319.                         {
     
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
321.                         }
     
322.                     }
     
323.                     else
     
324.                     {
     9 B! i: q) I* l/ e8 ?/ h; m2 r6 w
325.                         ucRecvBitCx ++;
     
326.                     }
     
327.                 }
     
328.                 else
     " v4 R% a! e* K& b* ~& X
329.                 {
     * o7 ?+ o/ l/ F4 R
330.                     ucAcquCx = 0;
     . A8 m8 U) ^" ^3 o* `5 C: W
331.                     ucRecvTrueCx = 0;
     
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     * [* A; ]* t2 A( Q
333.                 }
     
334.             }
     
335.         }
     
336.         break;
     . j+ N, B- H" a) z" J
337. 
     
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     
339.         {
     , q7 y# N6 P+ A/ \: F. b, H
340. 
     ; H; |' k( T5 e% l
341.         }
     
342.         break;
     
343. 
     0 C' d" M1 K# g$ p. o
344.         case COM_STOP_BIT_DEAL :                         //停止位
     
345.         {
     : W+ u1 S4 a2 d% j; T, n) _0 h! {. J
346. 
     
347.             ucRecvLastBit = ucRecvNowBit;
     ( f8 i. P% X0 r
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     : W  u7 E( W  d( n: i
349. 
     : L% b1 c# B/ d- y  ?# l" e2 @
350.             if(0 == ucAcquCx)
     - i/ ^% M; f( v& i
351.             {
     " G+ K$ @: |$ \) V/ v7 B1 H8 n
352.                 ucAcquCx = 1;
     
353.                 return;
     
354.             }
     7 ~& j. D% O" U3 ?0 u
355. 
     
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     
357.             {
     
358.                 ucRecvTrueCx ++;
     8 z+ O: K! t9 G+ L
359.             }
     $ N- E5 `4 l4 ~( X
360. 
     
361. 
     + ^% O1 q3 L$ H# }# O
362.             if( ++ ucAcquCx >= 6)
     
363.             {
     
364.                 ucAcquCx = 0;
     
365. 
     + o2 H& R* n- r" w8 s  Z/ w
366.                 if(ucRecvTrueCx >= 2)
     
367.                 {
     & `% X- D7 p9 V# x: M
368.                                       ucRecvTrueCx = 0;
     
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     % G+ W5 T: ~# n4 j! W
370.                     {
     : ^# t, d2 Q* y: |1 B  Y; n
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                         gsUARTBuff.Recvlength ++;
     
373.                     }
     
374. 
     
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     - ~1 a/ }' ?) c9 |; b- Q
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     
377.                     TIM6->CNT = 0;
     7 a: k' ^8 _9 b+ x+ b! o
378.                 }
     4 q7 `5 {  i4 S# T" x% O2 f
379.                 else
     3 R( y+ U) K0 \: ?1 r7 P+ e
380.                 {
     
381.                     ucRecvTrueCx = 0;
     8 `/ [, `! U4 J* a
382.                 }
     2 l: b0 n4 I2 [: c0 r* j# p
383.             }
     
384.         }
     . N; {4 i  F4 M3 K: S+ {
385.         break;
     
386. 
     
387.         default:
     ( e: i9 ?# Y& n; u8 A
388.             break;
     
389. 
     
390.         }
     
391.     }
     
392. 
     ! I$ n" u; A7 S2 t5 f  c4 M# `
393. }

复制代码

在使用中已经达到要求，无错误识别，但是由于在电路中使用了光耦，所以波形存在一定形变，不能及时将电平立即拉低，同时中断次数还是比较频繁的，为减少误判和减少中断次数，采取另一种方式。

3 P) o) z, p( K' O4 f

4、 最优实现

8 Z6 A" @! \+ @1 ~& x( ~- C& f

减少中断次数，每位只需中断三次，同时为避免光耦导致的滞后，将前面部分过滤不采集，只在中间快速采集三次，动态实现定时器定时时间调整。

比如在4800波特率下，一位208us，则定时器从起始位开始，定时序列为80，20，20，168，20，20，168，20，20，168......这样的序列。168为前一位的最后定时时间加当前位的前80us时间，也就是上图的起始位的4位置到第0位的2位置的时间。

1. #include "UartSet.h"
   8 D( j5 X; \3 w" |2 u1 {
2. #include "string.h"
   
3. 
   8 \  ?1 R* J3 S! M) v
4. typedef enum
   % X5 D$ h0 B3 O5 {- m
5. {
   . y! S: L+ U9 K0 D; j
6.     TimeRecvStartStep1 = 0,
   
7.     TimeRecvStep2 = 1,
   + ~' C$ D. M* I5 V7 ?
8.     TimeRecvStep3 = 2,
   
9.     TimeRecvStep1 = 3,
   ' @$ x6 Y6 @! t' b) i1 C
10.     TimeSendStep = 4,
    6 \7 d. j$ O+ B" q) {0 C, p
11. 
    9 ?' `2 o5 G! ?1 z
12. } TimeStep;
    / L7 k8 Y! h% g
13. 
    4 G  h& m' ~( r- O/ J% ~, y
14. uint16_t TimeSet[5];
    
15. 
    
16. uint16_t TimeSetBuff[][5] = {{1199, 59, 59, 2378, 2498 }, //1200
    
17.     {539, 59, 59, 1128, 1247 },  //2400
    
18.     {239, 59, 59, 503, 624  },   //4800
    ! {; N6 i# V) M! G" G5 H& d
19.     {149, 29, 29, 251, 311  },   //9600
    % G6 d+ @% \0 U8 Q
20.     {0, 0, 0, 0, 0    },         //预留
    
21. };
    
22. 
    
23. UART gsUARTBuff;                //定义串口
    2 K! w! w$ k! t, S# B, c
24. 
    
25. uint8_t ucRecvData = 0;         //每次接收的字节
    : G# `4 W$ z& h$ J: r
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    , H- x) B" e+ m3 S; z& z; v
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    " n0 H1 M6 H; r  ^
28. uint8_t ucSendBitCx = 0;        //发送位计数
    2 T& u$ Z9 W6 B6 ?, o
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    
30. 
    3 Z3 `+ K& f) ^' h
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    
32. 
    
33. 
    
34. TIM_HandleTypeDef htim6;
    
35. 
      u; b! I$ g4 X- [
36. void MX_TIM6_Init(void)
    0 {1 K8 X% R, d) x, v( M8 ?, B
37. {
    6 Y9 X6 d! `$ `+ E$ T, w5 W
38. 
    2 L  m: T) H7 Z. E8 Q" q
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    
40. 
    
41.     htim6.Instance = TIM6;
    9 _! L) W, G# p
42.     htim6.Init.Prescaler = 15;
    ' }, C# r( H/ a* m- C
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    ! u! R, @" z& |& Z& t. {% B9 h
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    ( i- P7 G3 V7 w( z: X! a" |
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
46. 
    
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    1 K- @7 ^$ f. j6 H" s) @
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
49. 
      A) {& ]" S* D* p& r0 T
50.     HAL_TIM_Base_Init(&htim6);
    
51. 
    
52. }
    ' s* r8 J; v0 g! v% |5 P# Z6 Z: }
53. 
    
54. 
    
55. void UART_GPIO_Init(void)
    & p9 B) [; e' }
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    $ q. P7 y/ O* Q2 }; f7 v/ N1 B9 T  o
58. 
    , Z3 z7 \) ^1 C
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    0 l7 F, u# K. N# c8 z
60. 
    
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    6 R5 [  T2 E& x$ Q0 D- D4 e9 ~$ l
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    2 n; R4 p+ b3 K, a9 R
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    6 j( a4 a0 f1 }' B
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    - M" U+ [( [" K. {1 Q3 i* A5 T
66. 
    ) [% n) P9 X- X" e$ p
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    : ]1 K/ C! d: r0 x7 u
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    8 q: j$ l9 B  R; s
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
71. 
    ( L# }; I3 A3 H& C
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    * R$ I9 ]& ?1 I- R" ~8 \9 M5 d6 H
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    " ?; t% P6 q! S
74. 
    
75. }
    1 o; H, I; I- w" A
76. 
    ! }# U) N; z. J& \0 {. H, K
77. 
    
78. /*******************************************************************************
    
79. * @FunctionName   : UART_Init.
    
80. * @Description    : 模拟串口结构体初始化.
    
81. * @Input          : None.
    ' w$ Y4 u3 I: t) ?, U. E
82. * @Output         : None.
    
83. * @Return         : None.
    
84. * @Author&Data    : MrShuCai  2019.4.11.
    
85. *******************************************************************************/
      V) n4 l  i# \3 U9 |9 M5 t% Z
86. void UART_Init(void)
    
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    
89.     gsUARTBuff.UartMaxLength = Uartlength;
    5 _7 N& W& O1 h# L. P9 H
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    1 {3 f  ?- J, Q  N
91.     UART_GPIO_Init();
    3 T0 w! `" g+ z& z
92. 
    0 `! }: e7 _. H* ~: Z0 i! Z$ p
93.     if(BaudRate == 1200)
    9 L7 S% j1 o( ~4 v) J
94.     {
    
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    8 N6 J' o$ f" W
96.     }
    ( @0 T6 Y& _7 j1 K) ^, ~
97.     else if(BaudRate == 2400)
    
98.     {
    ( C, u5 o- |* d
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    
100.     }
     
101.     else if(BaudRate == 4800)
     9 d& i! H& _5 {5 u. }
102.     {
     5 Y, O8 R9 R! O  R. X5 ^
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     
104.     }
     3 q" u7 u# J' q% p4 [% d3 Z' v! w
105.     else if(BaudRate == 9600)
     
106.     {
     
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     9 ]9 S# p& X8 C0 c+ G
108.     }
     6 s2 ^" V" ]- e  u/ _) \$ L
109.     else
     ; Q+ y3 \% l' ?# \$ ~! G
110.     {
     
111. 
     0 y( ^9 N  q% T: N0 F
112.     }
     7 S( S0 w5 z! \/ G1 X  H+ a+ N
113. 
     4 z, ?3 A7 B/ Y' M! x# I. C
114.     MX_TIM6_Init();
     - e# j$ D( S* x  S! e! Q% E
115. }
     6 }' e; I0 P: x
116. 
     
117. 
     0 R9 W; c8 y5 h
118. /*******************************************************************************
     4 Z. j9 p% M7 W6 m+ p3 C+ H
119. * @FunctionName   : UART_Send_Data.
     ; D6 P1 H3 o/ s
120. * @Description    : 模拟串口发送数据接口.
     
121. * @Input          : None.
     . @- o- j: o2 e9 p! t% c
122. * @Output         : None.
     8 u( V4 z# s* I: K* F+ T: y
123. * @Return         : None.
     4 N) S$ h/ }: ]- \( x. ~8 x9 B
124. * @Author&Data    : MrShuCai  2019.4.11.
     8 g- b3 p) f- K7 N* }
125. *******************************************************************************/
     ; C6 m! y* l' {4 U
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     ( p# |& J2 L( F2 I# ~
127. {
     
128.     gsUARTBuff.Sendlength = size;
     
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
130.    
     6 C9 w8 }' `& f& O
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
132.         {
     
133.             gsUARTBuff.TxEn = 1;
     
134.             gsUARTBuff.RxEn = 0;
     
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
136. 
     " t& ~6 X1 O4 p% I
137.             TIM6->ARR = TimeSet[TimeSendStep];
     
138.             TIM6->EGR = TIM_EGR_UG;
     
139. 
     
140.             HAL_TIM_Base_Start_IT(&htim6);
     + W, }( F: v4 Z. N0 b
141.         }
     7 O% {" @2 s# ~+ Z  F! G/ u
142.       
     6 y: o8 P( c5 E
143. }
     
144. 
     2 |0 s9 G6 y# q! S. s2 Z& K
145. 
     6 ?% }/ e" {2 T  \* y$ Y7 Z
146. /*******************************************************************************
     
147. * @FunctionName   : EXTI4_15_IRQHandler.
     8 R0 j- |) g: A! T
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     8 _, Y9 U' K+ p9 Y4 _
149. * @Input          : None.
     ' M% i0 s4 v9 c! L  H; ]. _  e. t
150. * @Output         : None.
     
151. * @Return         : None.
     6 b& L- d- `  I4 |
152. * @Author&Data    : MrShuCai  2019.4.11.
     * X2 d$ E8 a4 l% B
153. *******************************************************************************/
     , e; s$ O# x- y; X
154. void EXTI4_15_IRQHandler(void)
     
155. {
     
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     " S# ]. F6 J) z# ]2 @3 B( z% M* }
157.     {
     ; I' e) g7 ?) j/ l
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     5 f! ?9 [8 a1 I' u- N& E
159. 
     
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
161.         {
     
162.             gsUARTBuff.RxEn = 1;
     
163.             ucRecvData = 0;
     $ t7 m3 V6 V. c0 k+ ^
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     - y' B1 i( g- e* }
165. 
     
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     * u0 ]. g3 g2 x; [9 I
168.                       EXTI->IMR &= ~(0x10);
     8 D5 I% i! L( O7 T5 w, J
169.                       EXTI->EMR &= ~(0x10);
     
170.             HAL_TIM_Base_Start_IT(&htim6);
     
171.         }
     3 m5 E3 x" b( y7 ]' _! U
172.     }
     1 O& x& @, e" P
173. 
     
174. }
     2 Z( H, |3 e8 ^& E" c' q1 i1 J8 i
175. 
     - G) m$ ]; d8 w( A. u4 F4 r9 Q) H
176. 
     4 d+ H3 X( N7 J& W( F. x7 X6 @
177. /*******************************************************************************
     
178. * @FunctionName   : BitValueChk.
     ; Q, U, r5 P" Z
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     
180. * @Input          : n 采集记录的位值.
     
181. * @Output         : BitValue.
     1 F. s* l2 r) K! P" r
182. * @Return         : BitValue.
     
183. * @Author&Data    : MrShuCai  2019.5.1.
       Q! k9 L3 Z$ S* i7 e
184. *******************************************************************************/
     ! v) f$ O, v6 O- T/ a+ v: M
185. uint8_t BitValueChk(uint8_t n)
     4 D3 t& x, `( c! G: a+ u
186. {
     1 |& Q+ v0 M( {
187.     uint8_t BitValCx = 0;
     , w; L5 r/ ]$ E0 T7 l
188. 
     1 I  }' l" V! w0 W
189.     for(BitValCx = 0; n; n >>= 1)
     3 l. W( u: L/ I5 `7 C+ C$ }
190.     {
     
191.         BitValCx += n & 0x01;
     / g2 k3 t- v9 X
192.     }
     
193. 
     " w0 C- l- M* p; U8 C: o
194.     return (BitValCx < 2) ? (0) : (1);
     
195. 
     
196. }
     
197. 
     % x4 T- m& a8 K0 N8 y
198. /*******************************************************************************
     
199. * @FunctionName   : TIM6_IRQHandler.
     
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     
201. * @Input          : None.
     % s# V  F# o4 {0 p) G2 j
202. * @Output         : None.
     4 y- m/ q0 ~6 [0 x) r; k( _
203. * @Return         : None.
     
204. * @Author&Data    : MrShuCai  2019.4.11.
     , B' U3 n' s# l8 U) ]7 _5 J
205. *******************************************************************************/
     9 x. S+ o8 ~7 Z' q) h3 Z
206. void TIM6_IRQHandler(void)
     
207. {
     5 V9 L" R7 U7 r0 [- N7 j5 ]
208. 
     , j( T: B0 z' e) Z# _
209.     HAL_TIM_IRQHandler(&htim6);
     
210. 
     
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     % d4 @3 D, ]' Q
212.     {
     
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     
214.         {
     
215.         case COM_START_BIT_DEAL :
     
216.         {
     
217.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     
218.             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
219.             ucSendBitCx = 0;
     
220.         }
       g8 c: u- m$ S& O/ L
221.         break;
     : D8 ~: _9 S; |! v; z) V3 M2 t
222. 
     - B1 V0 h# |) n0 e' l: j6 C4 N
223.         case COM_DATA_BIT_DEAL :
     
224.         {
     + S: o* i( p$ c+ S+ x" X" [
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     1 E* V2 x, J( F0 Z% `4 p
226. 
     % I* N: O" H6 I3 v
227.             ucSendBitCx ++;
     
228. 
     
229.             if(ucSendBitCx >= 8)
     & ?! p+ c) e  `7 t6 v3 y  F+ _% S
230.             {
     # T3 t. q6 S; Q2 N/ n+ L& Q& N0 ?
231.                 if(gsUARTBuff.CheckType == NONE)
     - d2 g& L" k% M& u: e. Z
232.                 {
     ( O* `! x' H- o. P8 N# K
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
234.                 }
     1 e( A% e- p% H  j) o. Z, i/ c
235.                 else
     
236.                 {
     ' [4 M( \9 E# ]- ?
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     4 X( [. \3 Z( h4 J* L2 p
238.                 }
     
239.             }
     
240. 
     - I0 @! ^: U) W( R# ]% _
241.         }
     , z  ?/ I+ x5 ^# s. I* L
242.         break;
     
243. 
     8 @7 ?; I6 e$ ^0 O8 J+ V
244.         case COM_CHECK_BIT_DEAL :
     + K1 x# \8 h' u2 m
245.         {
     
246. 
     
247.         }
     / K/ c  P' k+ v) e4 @7 s  G
248.         break;
     3 `; |' [: m! l, ]0 O6 _3 ^3 W, j+ e( `
249. 
     % W  u. ?, a( z
250.         case COM_STOP_BIT_DEAL :
     4 u; k! F8 w, ~& _% K
251.         {
     
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     ! ?0 f* B2 W/ Y& P1 \3 C
253. 
     
254.             ucSendBitCx = 0;
     ) Y2 P) Y) y; S/ q
255. 
     - B7 H/ k9 k$ C# E0 B
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
257.             {
     ) o! o  m. z0 G& c: [4 r8 W1 l. L$ t& u
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     ; u8 ~' l0 B3 w$ W! c
260.             }
     
261.             else
     
262.             {
     
263.                 ucSendLengCx = 0;
     
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     ! ^9 V2 B1 c! ^/ }8 G  j( f2 }# A
265.                 gsUARTBuff.TxEn = 0;
     6 L( X/ ~- V: E: A6 c" m) S1 G* F$ u
266.                 gsUARTBuff.RxEn = 1;
     
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     
268.                               EXTI->IMR |= 0x10;
     7 B4 G" k2 C2 ?
269.                           EXTI->EMR |= 0x10;
     
270.                 TIM6 ->CNT = 0;
     2 s( Y, z' b# M% K
271.             }
     ( p, n& v& i: j' b7 W% G" M
272. 
     5 O1 ?  w( `, g/ P* F' j4 b
273.         }
     ) P) M9 O" ^- }3 z. A% m: S
274.         break;
     
275. 
     ) Q9 Y; i& _. V; L& c& s
276.         default:
     
277.             break;
     $ M8 |' a% O  g8 [9 `
278. 
     
279.         }
     * g3 ?' t, R1 d3 U
280.     }
     2 m  L7 P% D6 T1 b: K: @
281. 
     5 j# j/ V/ J# ]( [9 C$ z
282. 
     
283.     if(gsUARTBuff.RxEn == 1)
     6 b5 G& d1 D' y) _$ p% U/ ]3 L
284.     {
     $ @3 ?# B! q( V
285.         switch(gsUARTBuff.UartStat)
     , b; Z' K2 ^, r! |/ O9 Q: j" f+ F
286.         {
     
287.                     case COM_START_BIT_DEAL :
     9 q8 [* U. W' F
288.                     {
     & B8 Q+ ?, ?6 M0 f
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
290. 
     9 U4 R! Y: s5 |
291.                             if(++ ucAcquCx >= 3)
     $ N- @1 a! s" y1 Y5 B; v
292.                             {
     
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     & R: b+ C) v: w( O) W
294.                                     {
     
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     
297.                                     }
     
298.                                     else
     6 W+ Y- f0 F. R; D
299.                                     {
     
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     # f4 c3 r, c; A& V1 e" u* W+ _
301.                                     }
     % q4 Q' l( {  E( k) t7 V+ [
302.                                     
     
303.                                     ucRecvBitBuff = 0;
     
304.                                     ucAcquCx = 0;
     
305.                             }
     
306.                             else
     
307.                             {
     
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     , y+ T  @% V/ _8 B
309.                             }
     9 L. a/ a5 }2 ^2 u. p1 z
310. 
     : S" Q" z& ~' y; t9 M
311. 
     
312.                     }
     ! w# i& l$ j! g) I7 c: M0 Q
313.                     break;
     ( e; |2 k5 {" n( e1 ]8 N
314. 
     5 f5 \0 z  l/ G7 U
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     & L! ~: _" ~# n! M4 c1 H
316.                     {
     7 D7 b( l; K& Z* K% n
317. 
     
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     % _0 L4 e2 T6 _" ?6 F" u* }
319. 
     & g' q3 c  P0 k3 o
320.                             if(++ ucAcquCx >= 3)
     " d  A. e: C- R4 p. b- ?
321.                             {
     
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
       u9 m/ w$ J5 j
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     
325.                                     {
     
326.                                             ucRecvBitCx = 0;
     ) i; V+ ^6 i. [
327. 
     , z2 p' J& a/ b$ U
328.                                             if(gsUARTBuff.CheckType == NONE)
     
329.                                             {
     6 o/ n* n% z, X) S) R8 d
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
       m) `' J8 a9 d7 i5 ~; q
331.                                             }
     
332.                                             else
     / ^& y4 _, {7 k! ^* S- z
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     9 i" g  A% v- i' t* K
335.                                             }
     
336.                                     }
     4 c; X3 R( Z- t5 x, p! l# |4 R
337.                                     else
     ) k4 D' C/ W$ z/ z% L) Z
338.                                     {
     , x3 ~% |% l" v( q( T% \# M
339.                                             ucRecvBitCx ++;
     
340.                                     }
     4 ~# E+ i4 g+ T* q7 M+ S, T
341. 
     - z& _4 z# r. S- [$ c- o% Q9 X
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     & q( \# L# k9 l; V
343. 
     
344.                                     ucAcquCx = 0;
     
345.                                     ucRecvBitBuff = 0;
     7 v8 }5 m( E4 A8 H  U1 C
346.                             }
     
347.                             else
     " ?/ t" J- H) g! d7 W
348.                             {
     # M  H- ~5 e4 G6 x7 m
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
350.                             }
     6 C& B9 i1 r8 e# o/ d
351.                     }
     
352.                     break;
       R% j& V$ N% |6 [- d
353. 
     & u5 h6 S) j. N
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     
355.                     {
     
356. 
     , G9 d) P' Y) d2 p- Q3 C
357.                     }
     
358.                     break;
     # N- a/ C( f2 N& ~7 v
359. 
     
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     
361.                     {
     
362. 
     / t# z* d6 q1 p( ^- X4 B2 M
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     - K9 @8 S% ^9 r1 n5 C  Q
365.                             if( ++ ucAcquCx >= 3)
     
366.                             {
     ! d$ u4 h! j& R: _, E3 n& h
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     
368.                                     {
     5 I5 B6 j4 ?* `- i2 Y) h$ m& A7 q
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                                             {
     / O* K; M' m, Y. I* M
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     4 ^: a! o7 T2 m. a0 V1 w
372.                                                     gsUARTBuff.Recvlength ++;
     
373.                                             }
     
374. 
     
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     
377.                                             
     
378.                                             EXTI->IMR |= 0x10;
     / n; m( X! g$ }: L+ g0 j& r* @
379.                                             EXTI->EMR |= 0x10;
     
380.                                             TIM6->CNT = 0;
     % ]* q9 p( r: K
381.                                     }
     2 |. ^  L) }/ Q: S8 s% }- ^; X+ J
382.                                     else
     - y9 Z1 e& {! j" Z/ m* b
383.                                     {
     
384.                                             ucAcquCx = 0;
     
385.                                     }
     / |5 s9 o, Z) `1 I1 C
386.                                     
     1 P% w) J3 G  {: n$ I( t
387.                                     ucRecvBitBuff = 0;
     ! A' l, N- F. E. Y* ?
388.                                     ucAcquCx = 0;
     
389.                             }
     
390.                             else
     
391.                             {
     ( r, B; x0 M2 @& l1 ]; W
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
393.                             }
     + q1 M: g% M1 F' A, B8 h
394.                     }
     
395.                     break;
     
396. 
     6 i6 w% `! G2 g. g$ ^
397.                     default:
     
398.                             break;
     $ G- q  _+ O8 `3 h7 x( n
399.                     }
     1 t" o" l( c/ k) n  c
400.     }
     
401. }

复制代码

/ X+ O! _6 s$ Y" d% z

发送就以波特率时间定时发送位状态即可，实现简单。

仅供初学或者有兴趣的朋友参考，第一种方法由于后来放弃，只是大致实现，推荐第二种，欢迎大家指点。