一、设计用途：

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

二、硬件电路：

4 B- L8 L: f5 u; Y5 p- j

& I" b2 r2 |% r+ l4 v5 q6 E+ F

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

* t9 E. ^* t4 j, O/ A& N. p% O7 P

: c' k8 k& @& D

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

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

5 g7 P" v" [. V

; x% f6 A) Q! |1 S* Q% i

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

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

* j( @( v3 w; o

硬件串口的噪声处理：

9 x7 I' M; U; z+ J9 s& ^( W

% K' K: C" n: f2 t# z

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

3、 实现方式选择

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

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

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

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

: [- F% u& K9 d4 V- M0 N

自写第一种实现方式：

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

1. #include "UartSet.h"
   ! |" N$ V$ Z! X$ [" }
2. #include "string.h"
     ]& F% Y, `. v# E
3. 
   7 \: r  `8 P: V0 {+ c! ~
4. uint8_t ucRecvData = 0;         //每次接收的字节
   
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   6 ]& G. N4 N0 j0 _2 @; M1 o
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   
7. uint8_t ucSendBitCx = 0;        //发送位计数
   ! h0 {# k$ ]* q4 I  I/ p
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   / H1 u! M% g% j8 B0 q% Y1 z8 m  O
9. 
   8 O5 E8 b. Z# E. ~" I3 F5 ?
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    ! ?2 f5 v4 w/ w* S, ?9 N1 Y8 m
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    ; F3 q# T& O( k9 W
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    
13. 
    
14. uint32_t Prescaler = 0;
    
15. uint32_t Period = 0;
    
16. UART gsUARTBuff;               //定义串口
    7 j  m7 I0 d" k6 w# k) ]5 Z
17. 
    8 y. u3 M5 a4 N' z7 o8 G
18. TIM_HandleTypeDef htim6;
    . t6 b. N+ W6 a
19. 
    - G- L# U: F, H$ Z5 l$ v
20. void MX_TIM6_Init(void)
    / y7 C7 y, z; |! `4 x0 t
21. {
    & h/ a: X" v) r% Q4 N$ q
22. 
    
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    9 j/ R$ t, S# h/ ^6 P
24. 
    
25.     htim6.Instance = TIM6;
    0 t( X* D3 z2 `. |  c
26.     htim6.Init.Prescaler = Prescaler;
    
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    % E, U9 g# g+ b' D, {
28.     htim6.Init.Period = Period;
    
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ' P9 Y$ G( v4 s% p3 \& O, C. h4 V  \
30. 
      g6 |9 N, t  @
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
33. 
    
34.     HAL_TIM_Base_Init(&htim6);
    ; R9 q( G, }, p$ V
35. 
    
36. }
    % j0 L! B" }$ q( I7 M# G  ~- K
37. 
    : Q0 [" W" C& y$ @
38. 
    
39. void UART_GPIO_Init(void)
    
40. {
    ; r) \" U& `3 c+ w* ~7 }9 z
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    8 f0 ]# w* f4 p  q4 C( a! G
42. 
    
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    7 B& O7 D! ?  r" ]+ O
44. 
    ( d. j+ G; b* q) U4 E3 t
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    ( e! K4 k! [' I, [" y0 }8 e  _
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
49.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    
50. 
    
51.     GPIO_InitStruct.Pin = COM_RX_Pin;
    - A7 f9 N' f' p5 D7 Y- s
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    , U$ Z7 d* m# g% C7 Z; m7 _* V
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
55. 
    
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
58. 
    
59. }
    
60. 
    8 o4 c2 M# s/ q, j; N! A" B* T+ J. {* V0 t
61. 
    ) G. E( J9 ]' x) {% X
62. /*******************************************************************************
    7 Q4 S& @) b# q
63. * @FunctionName   : UART_Init.
    ) ?9 N6 i) B! h$ O# X; ?  q: R
64. * @Description    : 模拟串口结构体初始化.
    
65. * @Input          : None.
    + w. x! N' {, I& q- h
66. * @Output         : None.
    . M  f2 Y0 i  y2 c6 ^4 x5 z" a
67. * @Return         : None.
    # F4 N: A; s4 L
68. * @Author&Data    : MrShuCai  2019.4.11.
    2 K1 N; V6 j: ?& ~9 [8 d8 E
69. *******************************************************************************/
    
70. void UART_Init(void)
    5 l" X# J3 F% x5 o/ g6 S
71. {
    
72.     gsUARTBuff.CheckType = NONE;
    
73.     gsUARTBuff.UartMaxLength = Uartlength;
    # Q1 B  a8 H* B
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
75.     UART_GPIO_Init();
    
76. 
    , z9 ~. L7 ^: `- P3 G" q
77.     if(BaudRate == 1200)
    6 j' M( ]4 S+ I0 N0 w) K
78.     {
    4 l. M; o$ b2 L, v# G- j
79.         Prescaler = 15;
    ' [" \9 V* c2 {1 ~5 Y2 ~
80.         Period = 623;
    
81.     }
    
82.     else if(BaudRate == 2400)
    
83.     {
    
84.         Prescaler = 15;
    
85.         Period = 207;
    
86.     }
    
87.     else if(BaudRate == 4800)
    9 l* k  w# X. i1 T0 f* t  P
88.     {
    % q2 z1 f1 B" T7 v1 K9 M# j' ~/ l3 O
89. //        Prescaler = 15;
    / [" A, |3 |7 J
90. //        Period = 50;  //9600
    8 b; u& R9 m, i* R* s6 I
91.              Prescaler = 15;
    * a: y3 Y6 k4 F; B& e, _3 a
92.              Period = 103;
    
93.     }
    + _5 j. K% w- ?: p
94. 
    + \+ j* V5 T7 ~) n- I
95.     MX_TIM6_Init();
    
96. }
    
97. 
    % ~( x6 m5 v3 D0 D
98. 
    
99. /*******************************************************************************
    ) [% M5 V" p: ]: ]# Y9 K
100. * @FunctionName   : UART_Send_Data.
     
101. * @Description    : 模拟串口发送数据接口.
     7 @& R+ B: d5 {: {
102. * @Input          : None.
     5 o) k7 C% x8 j4 d
103. * @Output         : None.
     
104. * @Return         : None.
     / R( D" }# i3 M4 P4 k& x7 j5 V5 b3 |* w
105. * @Author&Data    : MrShuCai  2019.4.11.
     
106. *******************************************************************************/
     9 G$ P/ w# N, w9 N. R
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     
108. {
     
109.     gsUARTBuff.Sendlength = size;
     
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     3 x! i) r: a9 Y1 W1 `8 z: v
111.     gsUARTBuff.TxEn = 1;
     
112.     gsUARTBuff.RxEn = 0;
     
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
114.     HAL_TIM_Base_Start_IT(&htim6);
     
115. }
       h# r+ l! O; Y8 r, j# I5 K' [: [& @
116. 
     8 e7 e- x9 n' W2 ]4 P& m
117. 
     ; n& c- F- e! W/ r
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     7 j) x; P' |6 M! B5 U7 b3 G1 f% n7 r
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     4 V4 k9 a' x2 L- s8 N  [& G
121. * @Input          : None.
     
122. * @Output         : None.
     : p4 y0 U; g- u$ f
123. * @Return         : None.
     ) g$ t3 ?; _$ C* W
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     % u( ?. m& L' \( F/ B/ R
126. void EXTI4_15_IRQHandler(void)
     . u2 |; e) |0 k7 w
127. {
     # N# i- A% ^. {
128. 
     
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
130.     {
     
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
132. 
     
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
134.         {
     
135.             gsUARTBuff.RxEn = 1;
     
136.             ucRecvData = 0;
     
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     # K6 x8 {2 ^0 J& m  ]- |' ^* y
138.             HAL_TIM_Base_Start_IT(&htim6);
     ' t% ]- N+ w8 i) `% X  g, G
139.         }
     1 K+ \; S; I1 t( H: x! e. ]8 N1 N
140.     }
     $ f3 \2 a' Q2 O
141. }
     
142. 
     
143. /*******************************************************************************
     
144. * @FunctionName   : TIM6_IRQHandler.
     
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     5 i! C- J2 p; i; S, a, ^
146. * @Input          : None.
     " w' M" K1 {5 s0 Y- U
147. * @Output         : None.
     
148. * @Return         : None.
     
149. * @Author&Data    : MrShuCai  2019.4.11.
     
150. *******************************************************************************/
     
151. void TIM6_IRQHandler(void)
     
152. {
     
153.     HAL_TIM_IRQHandler(&htim6);
     
154. 
     
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     * P8 h1 a. O9 |( s5 Z
156.     {
     5 l: \. Y# |6 H6 ~  g* A
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     
158.         {
     
159.         case COM_START_BIT_DEAL :
     
160.         {
     1 H8 Y2 d5 F, c( z
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     & X2 P* G/ _3 O& _" f( U6 t
162. 
     
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     4 U0 T: a0 z6 B6 |3 {! m
164.             {
     9 \; n/ [* r' b$ g
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
166.                 ucAcquCx = 0;
     
167.                 ucSendBitCx = 0;
     1 U8 B, L; Z7 O3 h5 p5 G% @
168.             }
     
169.         }
     
170.         break;
     : }" \5 ~4 x* b7 t& M# p7 N$ {
171. 
     0 w) }2 S8 ?3 Z1 R- X( ~
172.         case COM_DATA_BIT_DEAL :
     " N& _, H+ f1 I/ D9 ]0 X
173.         {
     & [  U* h: b6 ]" `: a
174. 
     
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     ; f4 h! \: l* S9 y$ J0 a* O* T3 D2 V
176. 
     
177.             if(++ ucAcquCx >= 6)
     
178.             {
     ( C* V8 u2 N1 N! u) S
179.                 ucAcquCx = 0;
     
180.                            
     
181.                 ucSendBitCx ++;
     9 {6 p1 ^1 \( Z( e$ u5 g6 p% \$ B
182. 
     
183.                 if(ucSendBitCx >= 8)
     / m; ^% a  m7 @  O+ t- k7 z9 O
184.                 {
     + ?/ S5 n3 e7 G7 a% e
185.                     if(gsUARTBuff.CheckType == NONE)
     
186.                     {
     4 q, v3 t- Z0 R# S" _) Z2 b
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
188.                     }
     ; _8 C. _; \# E2 T. M
189.                     else
     
190.                     {
     0 \  K' i# E2 [  z+ n" S" M
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
192.                     }
     - P4 w+ H! c3 J* j
193.                 }
     
194.             }
     
195.         }
     : _4 _6 [3 m  N# G) [* T
196.         break;
     
197. 
     : e; F2 f4 B( i- N" h% W5 {
198.         case COM_CHECK_BIT_DEAL :
     $ `9 j  ^$ s8 Q& E) R3 |9 p; a
199.         {
     
200. 
     
201.         }
     ' M9 _* }: ^" r) t9 v% P$ Q
202.         break;
     . f( }' z5 A# t* l( i" s
203. 
     4 @2 D7 }2 A$ n
204.         case COM_STOP_BIT_DEAL :
     1 m- g+ L& _" q" j$ J
205.         {
     ' x9 U* X7 _- \
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     2 z2 n  T$ I5 A9 ?( v6 j8 ^
207. 
     
208.             if(++ ucAcquCx == 7)
     
209.             {
     : q" N$ I: j. C( |, q+ r$ P
210.                 ucAcquCx = 0;
     
211.                 ucSendBitCx = 0;
       l" L* t9 w/ H
212. 
     
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
214.                 {
     4 }4 }' S8 ?, c2 C
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
216.                     ucSendLengCx ++;
     4 N% X0 Y( e5 ]- Z" A5 Q6 o
217.                 }
     * r3 \7 }6 _0 P
218.                 else
     
219.                 {
     . x% P- G* A2 A
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
222.                     gsUARTBuff.TxEn = 0;
     6 [4 [, K. S# |  z7 r4 l! u  N
223.                     gsUARTBuff.RxEn = 1;
     
224. 
     6 p: p- e6 S( j- h3 }1 `
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     % j/ c6 o) \) Z4 }3 _
226.                     TIM6->CNT = 0;
     
227.                 }
     ! x: g! I+ ?. C% I5 X
228.             }
     " ~( \% Y% C5 z: g
229.         }
     5 N6 \# G9 F. b& O
230.         break;
     
231. 
     % Y# G% K) [6 S  K
232.         default:
     7 ?* X( V) B3 y
233.             break;
     
234. 
     
235.         }
     ( o! d+ q& `, a
236.     }
     0 X7 o* q* d; r# L
237. 
     8 \. Z( h# I5 m! d
238. 
     + B. x+ A; M6 E/ ]- s+ u
239.     if(gsUARTBuff.RxEn == 1)
     , B3 {4 p0 Y9 S: W
240.     {
     8 {3 v! }7 j4 g: \
241.         switch(gsUARTBuff.UartStat)
     
242.         {
     
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     / s9 X1 c  t5 X
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
247. 
     
248.             if(    ucAcquCx == 0)
     5 K: i8 r" W' v7 ]' ^! \/ Q
249.             {
     
250.                 ucAcquCx = 1;
     
251.                 return ;
     
252.             }
     
253. 
     
254.             if(ucRecvLastBit == ucRecvNowBit)
     - T8 B. H6 R: d1 X
255.             {
     * ]+ Q$ a% p4 B- Q
256.                 ucRecvTrueCx ++;
     & |$ w& v2 h& z0 p4 C' K
257.             }
     
258. 
     
259.             if(++ ucAcquCx >= 5)
     
260.             {
     
261.                 if(ucRecvTrueCx >= 2)
     
262.                 {
     0 |, D5 R# L4 p. y6 f1 S9 A
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     ! r/ q5 a6 Q4 R" |( t
264.                     ucAcquCx = 0;
     ' t7 _- K3 S: J$ z% V; ]
265.                     ucRecvTrueCx = 0;
     
266.                 }
     0 o) H* i2 z, F9 ]: w8 x2 t
267.                 else
     # T4 D9 Z; X. E/ v
268.                 {
     & f% [. z1 {. F! ^. ]8 i: e( |  V
269.                     ucAcquCx = 0;
     
270.                     ucRecvTrueCx = 0;
     7 F( [( y8 f+ U0 o8 c. Z/ J
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
272.                 }
     5 p% D4 s4 y& ^  X) c& x7 G9 h4 B& @
273.             }
     
274.         }
     ' t, ]5 ?: t5 X( h
275.         break;
     
276. 
     
277.         case COM_DATA_BIT_DEAL :                         //数据位
     7 G' ?+ L6 n' w  Z
278.         {
     # P+ Y- E2 @  j# }, [/ H& Q
279. 
     : p# j# c- h6 e$ I# \
280.             ucRecvLastBit = ucRecvNowBit;
     5 {  G& u% L% E) @
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     
283.             if(0 == ucAcquCx)
     
284.             {
     : B, [5 y$ o2 ?. L
285.                 ucAcquCx = 1;
     
286.                 return;
     
287.             }
     ) r! M7 Z, Z( W8 Y/ B
288. 
     
289.             if(ucRecvNowBit == ucRecvLastBit)
     2 C* \4 T0 T- L" u2 c+ K" Q
290.             {
     
291.                 ucRecvTrueCx ++;
     . f- y7 H& ~- G
292.             }
     
293. 
     
294. 
     
295.             if(++ ucAcquCx >= 6)
     5 c" |/ B; t( e5 |# w" L6 ?+ w
296.             {
     
297.                 ucAcquCx = 0;
     
298. 
     
299.                 if(ucRecvTrueCx >= 2)
     
300.                 {
     
301.                     if(ucRecvLastBit == 1)
     2 Y. A* U! F/ G
302.                     {
     
303.                         ucRecvData |= (1 << ucRecvBitCx);
     . P8 k) Q. b4 C& @! A
304.                     }
     
305.                     else
       k6 f& Q* W- @  _
306.                     {
     
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     - ]& L3 M. V* d& B
308.                     }
     
309. 
     
310.                     if(ucRecvBitCx >= 7)
     ' P0 q7 \4 u* g1 i5 B
311.                     {
     
312.                         ucRecvBitCx = 0;
     8 L: ^/ z9 X2 i7 [+ R+ Z5 Y
313. 
     
314.                         if(gsUARTBuff.CheckType == NONE)
     
315.                         {
     ; X7 Z" r5 p% |. _( m; ^! ]
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
317.                         }
     
318.                         else
     * t% V) x: a0 Q. {- l/ g! B0 {/ |
319.                         {
     
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     5 `  h3 F- d% s
321.                         }
     : U8 v' Y( q" O3 M
322.                     }
     7 g6 ~0 i: D! M9 j9 h4 ]. l
323.                     else
     5 v9 a. e' G" X2 k
324.                     {
     % f* j) U6 I$ ]# }( ]. a
325.                         ucRecvBitCx ++;
     5 K! }' c3 }' X# i- C, g
326.                     }
     
327.                 }
     
328.                 else
     
329.                 {
     + V3 o1 v+ t, d
330.                     ucAcquCx = 0;
     5 r9 ^# K$ U6 a5 q* N% m
331.                     ucRecvTrueCx = 0;
       E; [( \7 k: E2 [
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
333.                 }
     
334.             }
     / X. \8 [& G6 \
335.         }
     4 K  _6 ~) w7 `1 S( V  w8 q
336.         break;
     ' V6 v3 [9 ^" R1 V
337. 
     
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     6 S( {# f( l' q* F/ ^' q
339.         {
       l* {) D/ j* j6 o
340. 
     6 a, n  I) r* o$ x2 s+ |$ Z
341.         }
     
342.         break;
     
343. 
     % i! v, W' ?* o) E
344.         case COM_STOP_BIT_DEAL :                         //停止位
     
345.         {
     , @0 F  S7 v: q% [
346. 
     0 Q; `0 z# p" O" h0 V- F
347.             ucRecvLastBit = ucRecvNowBit;
     ( t7 O/ p  q! h$ {* p2 a# a; _
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
349. 
     
350.             if(0 == ucAcquCx)
     ! x( `8 z$ W. |2 p$ p; V1 c% Y
351.             {
     $ _" B% s! J' `. m$ \
352.                 ucAcquCx = 1;
     
353.                 return;
     + z. K& @1 ]+ j5 D# u
354.             }
     : x9 k  h, N5 S9 V! B2 J4 l
355. 
     
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
       t# J0 N9 @8 @$ v. o
357.             {
     
358.                 ucRecvTrueCx ++;
     # J+ n8 o/ n9 D! \9 [, W
359.             }
     
360. 
     
361. 
     
362.             if( ++ ucAcquCx >= 6)
     
363.             {
     
364.                 ucAcquCx = 0;
     
365. 
     ' |: d# M: Z$ u, H& ?/ X
366.                 if(ucRecvTrueCx >= 2)
     ) a& o9 @% c3 D: K
367.                 {
     + s) K+ n" b8 z' b
368.                                       ucRecvTrueCx = 0;
     
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     & q3 B$ q  a( X
370.                     {
     / e/ k4 L' H4 T% O6 `! p3 i
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     : Z* f  p$ n- X+ A) E
372.                         gsUARTBuff.Recvlength ++;
     
373.                     }
     5 r. ?& M# y, O" f& x
374. 
     $ _' x4 ~1 v5 [
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     
377.                     TIM6->CNT = 0;
     
378.                 }
     ' B/ t' C, a1 w! Q3 v
379.                 else
     / k8 [* E; J  P0 h. ^% ~* ~
380.                 {
     
381.                     ucRecvTrueCx = 0;
     
382.                 }
     3 J2 v2 l* t; Q; G/ }& g
383.             }
     , q1 T2 G, g# I
384.         }
     
385.         break;
     
386. 
     
387.         default:
     0 n1 N% v$ v" X& t: c
388.             break;
     
389. 
     
390.         }
     
391.     }
     
392. 
     . j* r8 ~3 {: [- w9 u; A* a
393. }

复制代码

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

2 Q! _! p. T7 E! k, h+ _2 {

4、 最优实现

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

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

1. #include "UartSet.h"
   
2. #include "string.h"
   
3. 
   
4. typedef enum
   
5. {
   * U7 U8 C4 G, h$ `% c$ @# ]
6.     TimeRecvStartStep1 = 0,
   
7.     TimeRecvStep2 = 1,
   0 z+ _0 x! e: Q, H$ j2 g
8.     TimeRecvStep3 = 2,
   & ^7 l& l& v/ B  z2 {9 q
9.     TimeRecvStep1 = 3,
   
10.     TimeSendStep = 4,
    
11. 
    ; n5 e+ e) o) h6 ^8 _/ i: h
12. } TimeStep;
    ! y# ^; S: c; t. v- s
13. 
    . a0 G. T/ l2 g& i& t! g5 E6 S3 q
14. uint16_t TimeSet[5];
    # J/ @% v  P9 D
15. 
    1 C; X# b! g" r+ E) o6 c" q2 a
16. uint16_t TimeSetBuff[][5] = {{1199, 59, 59, 2378, 2498 }, //1200
    
17.     {539, 59, 59, 1128, 1247 },  //2400
    - w" c$ @2 C2 C
18.     {239, 59, 59, 503, 624  },   //4800
    
19.     {149, 29, 29, 251, 311  },   //9600
    " n- X7 E, Z# l" X
20.     {0, 0, 0, 0, 0    },         //预留
    
21. };
    
22. 
    & ?+ D( s  d5 n4 B4 A! f
23. UART gsUARTBuff;                //定义串口
    & t& |3 N3 G' r1 {
24. 
    2 Y- y% |) p5 l8 [- l7 l  K7 v' H4 s
25. uint8_t ucRecvData = 0;         //每次接收的字节
    2 x8 i* B' J( \' }$ L
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    
28. uint8_t ucSendBitCx = 0;        //发送位计数
    - Z  A5 f# e3 \$ x5 z3 J
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    6 i3 G$ k: o& Z" b6 l
30. 
    
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    
32. 
    
33. 
    
34. TIM_HandleTypeDef htim6;
    * Q% {+ e0 S3 M* r$ v
35. 
    
36. void MX_TIM6_Init(void)
    
37. {
    7 F4 k0 B4 _$ [7 ~
38. 
    ' f, N- E+ n+ `
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    , B- D4 u6 _2 _. w
40. 
    
41.     htim6.Instance = TIM6;
    
42.     htim6.Init.Prescaler = 15;
    # I6 f0 Q7 Y% y# a- ^" V; L
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    6 x0 d* A1 O1 y9 k9 E/ e4 g4 T4 m
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    1 u( Y4 M* d8 v$ ?
46. 
    6 E5 x: F8 q* g* N/ w1 }
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    3 n, L8 }; U6 ~! l# g9 h
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
49. 
    , O8 ?( n/ b3 ]0 g- W. \6 j
50.     HAL_TIM_Base_Init(&htim6);
    9 N6 S8 _# D1 [- D
51. 
    
52. }
    0 ]% {' [$ b$ f" A  N9 [# G& \
53. 
    
54. 
    
55. void UART_GPIO_Init(void)
    
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    5 e$ a( B/ b  n% D2 f  R: ~
58. 
    
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    / @: R  K4 F8 `- d" i' f; J
60. 
    
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    & g  }5 N9 R6 @, }8 D
66. 
    
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    ! U; v" z- F4 q4 P" n' X) j% N) ?
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    * u, u3 e. Y9 z9 `/ G2 e
71. 
    
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    7 K7 k2 E3 K' |6 l5 R
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
74. 
    ! u7 e7 L5 D1 k6 P( P- R# `
75. }
    , R" M" i( X( D5 r
76. 
    
77. 
    * ]# m8 a, y  ?4 l( R. i) i3 C
78. /*******************************************************************************
    
79. * @FunctionName   : UART_Init.
    " n6 D0 m- N/ t* v5 I" ?
80. * @Description    : 模拟串口结构体初始化.
    - S2 Z8 i7 [7 t
81. * @Input          : None.
    
82. * @Output         : None.
    
83. * @Return         : None.
    
84. * @Author&Data    : MrShuCai  2019.4.11.
    % e) d% q  U! V, ?! j( H6 G1 j; n
85. *******************************************************************************/
    : V0 E" p' N0 E( K& u& W
86. void UART_Init(void)
    
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    
89.     gsUARTBuff.UartMaxLength = Uartlength;
    5 i, q: o6 E8 j6 [6 A# A; z: z
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
91.     UART_GPIO_Init();
    1 d; X  d$ Q& N
92. 
    
93.     if(BaudRate == 1200)
    3 k5 L7 T2 M$ j, ]
94.     {
    
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    
96.     }
    ; L+ E1 x" J) {: M
97.     else if(BaudRate == 2400)
    
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    / [7 T' {- M0 Y) u) i
100.     }
     
101.     else if(BaudRate == 4800)
     
102.     {
     " V% Z  g& l# P) }" m( u
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     $ o( Q5 w! v7 ?) h7 r( s4 e
104.     }
     2 ?8 n! N' k0 F2 x1 L
105.     else if(BaudRate == 9600)
     
106.     {
     
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     + m% K0 t( T+ }: c
108.     }
     
109.     else
     2 t: H  }( ]  ?
110.     {
     
111. 
     . ]+ R9 |' Z( X  p5 u1 ]( ~9 l
112.     }
     + K: A, ?0 y7 `7 T+ E
113. 
     
114.     MX_TIM6_Init();
     0 R; _, I; S0 {; T% p% j
115. }
     
116. 
     
117. 
     4 M5 z( ^+ _4 g' n6 T; f+ X' O% c" j
118. /*******************************************************************************
     3 @+ _, P+ W  t0 s+ u6 X, K
119. * @FunctionName   : UART_Send_Data.
     
120. * @Description    : 模拟串口发送数据接口.
     
121. * @Input          : None.
     - k4 B9 C# W$ `3 Y
122. * @Output         : None.
     + o2 U* C: F6 L$ v! u# v8 w
123. * @Return         : None.
     2 d* c4 C9 \- h4 r
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     9 c# Z0 m& E6 u( g
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     
127. {
     
128.     gsUARTBuff.Sendlength = size;
     7 p  Q; Z; {9 m5 d: z
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
130.    
     ! ?/ O& L, O8 m+ \( r
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
132.         {
     
133.             gsUARTBuff.TxEn = 1;
     " e' V% W  B$ y: f
134.             gsUARTBuff.RxEn = 0;
     
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
136. 
     ( T2 z/ r$ v3 R) X. o+ p/ x
137.             TIM6->ARR = TimeSet[TimeSendStep];
     
138.             TIM6->EGR = TIM_EGR_UG;
     
139. 
     ) G" r' U8 h/ d# a: {
140.             HAL_TIM_Base_Start_IT(&htim6);
     ! m  L! g- b9 E( h6 v
141.         }
     
142.       
     1 V7 k5 i# {! E( G
143. }
     
144. 
     ' l! A$ n& ]0 ~* B  Z, f* f
145. 
     8 o% s! b4 m# D) ]. g, j8 Y/ T
146. /*******************************************************************************
     
147. * @FunctionName   : EXTI4_15_IRQHandler.
     : R; X0 t0 b) i2 w! n1 Z& S
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     ' J. m/ T4 f, @
149. * @Input          : None.
     
150. * @Output         : None.
     - [( G; z6 U: J8 i
151. * @Return         : None.
     
152. * @Author&Data    : MrShuCai  2019.4.11.
     ; y1 m8 v: B% f6 [8 i+ b
153. *******************************************************************************/
     # @. _4 r5 ]" [& ^2 O: L: D* r
154. void EXTI4_15_IRQHandler(void)
     7 O! u7 l( x. o+ B& ?
155. {
     
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
157.     {
     # d4 Z* S3 f+ A2 l7 `
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     / Q' V' ?! w: T3 q3 G
159. 
     0 R" L7 [0 Q5 H5 V) Y
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     " R: ]: d* B/ p0 v. b# C! J9 U: x
161.         {
     : s7 D* w  Y7 @; V8 L2 j+ e2 |6 U7 B
162.             gsUARTBuff.RxEn = 1;
     
163.             ucRecvData = 0;
     
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     * d' [; d- _+ o7 ^' W* f: K
165. 
     
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     ( D% h; h) \7 U" ~
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
       @  o. X" u( m2 ]0 C/ Z
168.                       EXTI->IMR &= ~(0x10);
     
169.                       EXTI->EMR &= ~(0x10);
     4 R$ N) F. V  }0 o% |9 }  Y  M
170.             HAL_TIM_Base_Start_IT(&htim6);
     ; c. B5 t$ P9 t( e  h$ ]# k5 X. P
171.         }
     0 s9 A$ a- |! B$ }' y* T$ h4 t
172.     }
     9 r7 Q8 ~% n4 k: e; {+ d
173. 
     
174. }
     
175. 
     7 ?) C+ t+ t* C
176. 
     
177. /*******************************************************************************
     6 U: }9 M2 I/ o# _% Z" [
178. * @FunctionName   : BitValueChk.
     & B  t% q0 c7 P4 ]% [# V- a0 O
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     
180. * @Input          : n 采集记录的位值.
     
181. * @Output         : BitValue.
     ' ?+ X% F  J  L
182. * @Return         : BitValue.
     
183. * @Author&Data    : MrShuCai  2019.5.1.
     . s3 s0 ^) p4 D6 z1 H: Z: [
184. *******************************************************************************/
     
185. uint8_t BitValueChk(uint8_t n)
     0 `" C2 ^" O" C* a* o
186. {
     - c) e5 L. v& b4 R
187.     uint8_t BitValCx = 0;
     + a. A% z% D! K! q
188. 
     
189.     for(BitValCx = 0; n; n >>= 1)
     
190.     {
     
191.         BitValCx += n & 0x01;
     
192.     }
     , j  t" o; H6 Q) P. ~  p' `% F
193. 
     $ t' D1 V3 {) ~2 c; {( W" T3 t4 g) d+ t3 \
194.     return (BitValCx < 2) ? (0) : (1);
     / o6 `( e0 R5 V+ q6 R9 A" L
195. 
     
196. }
     
197. 
     3 [8 i2 Y! k+ h' H' P7 T
198. /*******************************************************************************
     6 X3 N! {% g- t3 [, R5 F/ u" `
199. * @FunctionName   : TIM6_IRQHandler.
     
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     - J' P! B5 d. }0 }: e  S1 t
201. * @Input          : None.
     
202. * @Output         : None.
     
203. * @Return         : None.
     % Y4 ^0 ^5 M( ]& W4 g4 x, r
204. * @Author&Data    : MrShuCai  2019.4.11.
     , }& @/ J0 I  d% Q8 d" f0 ?. C( C
205. *******************************************************************************/
     
206. void TIM6_IRQHandler(void)
     
207. {
     
208. 
     
209.     HAL_TIM_IRQHandler(&htim6);
       D$ B+ J6 G, V  \/ v
210. 
     - E- s5 N2 f' S# b2 z
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     0 g# n' F( K6 x* }& ~, t
214.         {
     9 [; L/ o$ P7 c. \6 ^) c
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;
     1 F. G7 t$ t0 E2 y, i' v' Z
219.             ucSendBitCx = 0;
     / Z; K; ^* i& y. F( i
220.         }
     % {4 k; x7 i( A9 T& v' }
221.         break;
     
222. 
     0 d8 o7 W' _4 t* ~% y
223.         case COM_DATA_BIT_DEAL :
     
224.         {
     0 u; A  b! ]# v: `7 v6 o
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     # e# O/ U* ~: \
226. 
     2 A1 e6 x/ K0 e2 I) m/ L9 j& Y
227.             ucSendBitCx ++;
     ) |9 k- ^3 I! o! |; _
228. 
     
229.             if(ucSendBitCx >= 8)
     
230.             {
     
231.                 if(gsUARTBuff.CheckType == NONE)
     
232.                 {
     7 |6 b. M( u0 j5 B' |9 C
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
234.                 }
     
235.                 else
     + M5 a% N1 y! B: D  q" Q, c) h- [$ P; K
236.                 {
     . y3 I! q- \' Q0 [( i
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
238.                 }
     
239.             }
     6 V2 V8 _& w4 \5 D7 u: L, l6 q6 o
240. 
       s) H3 J2 I6 g& o* B
241.         }
     
242.         break;
     
243. 
     
244.         case COM_CHECK_BIT_DEAL :
     
245.         {
     + ^* a! S, w5 K, V& x- S6 [
246. 
     $ v/ R7 @9 y9 ?( q
247.         }
     
248.         break;
     
249. 
     . a0 ]. C4 c) L( c
250.         case COM_STOP_BIT_DEAL :
     
251.         {
     
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     $ p4 \% e, T# g6 K+ I
253. 
     1 V! Z5 {8 p, C  W9 Q. c" |! ~
254.             ucSendBitCx = 0;
     
255. 
     ( ~4 [* D- h% r6 }8 a, f6 o. a
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     # ^4 @# r) Q/ }' }6 d( o
257.             {
     # H7 X5 `& D6 I7 ]' u: p" J
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     & y  H$ i2 [& c  M; I
260.             }
     % G2 n, q/ H5 v) o; f
261.             else
     
262.             {
     + [) Q% }, z/ U7 U1 i# I0 q
263.                 ucSendLengCx = 0;
     
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
265.                 gsUARTBuff.TxEn = 0;
     
266.                 gsUARTBuff.RxEn = 1;
     
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     6 ~. @0 Q# a. @. A3 Q. p7 L9 D3 w+ ]+ N
268.                               EXTI->IMR |= 0x10;
     , Y1 N' j/ _! G. }- O7 Z3 Q
269.                           EXTI->EMR |= 0x10;
     
270.                 TIM6 ->CNT = 0;
     ! a$ u8 V) I7 y
271.             }
     
272. 
     
273.         }
     
274.         break;
     
275. 
     9 T: S8 l' L; U) y! a& g
276.         default:
     7 g; k4 o' L4 J' o) H
277.             break;
     
278. 
     
279.         }
     
280.     }
     & e- G  [( F. P; Q7 M
281. 
     
282. 
     2 L; W0 @0 f1 t
283.     if(gsUARTBuff.RxEn == 1)
     
284.     {
     . H2 J0 \# T5 s5 k9 A
285.         switch(gsUARTBuff.UartStat)
     
286.         {
     0 h; X! I( w9 u: F3 O
287.                     case COM_START_BIT_DEAL :
     
288.                     {
     
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
290. 
     2 H; M; [1 s0 V, h6 ~' l
291.                             if(++ ucAcquCx >= 3)
     3 v( u5 d8 ]1 }8 R8 x$ a$ q7 {1 T' C
292.                             {
     9 [6 w# K- P- \" C
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     ( p; C/ a4 Q: U6 }
294.                                     {
     $ K4 O) X* R2 w- I+ U
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     " P; I9 w& l- l  @* X- Q& u6 Q! e
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     
297.                                     }
     4 V# U& n& @. ]* [1 Z; K6 p
298.                                     else
     
299.                                     {
     ' D( N: t1 a1 j: O- i
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
301.                                     }
     
302.                                     
     ; @1 }* ~$ |* i- T) t; {- v( A- m% @6 a
303.                                     ucRecvBitBuff = 0;
     
304.                                     ucAcquCx = 0;
     $ Q/ w0 ]. j4 K+ }) G
305.                             }
     ' h: X! H. F7 f7 h. Y5 C2 I, `% n
306.                             else
     
307.                             {
     : N( F5 }1 L6 e% ~# j2 u, i9 X, v1 k% Q
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     & j. F. B: C0 x4 P* T6 R7 r
309.                             }
     
310. 
     / T! a5 Z) O$ }  J+ n: L: r* U
311. 
     
312.                     }
     9 C4 O/ ~  S; h+ J# `
313.                     break;
     
314. 
     " T% N" {/ z! l& C
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     
316.                     {
     ; ^7 S' x4 k5 F: K- m; b, Q
317. 
     9 `: v7 ?9 s# i! Z, O7 ^
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
319. 
     # X% K/ z" ?) j- F1 ?
320.                             if(++ ucAcquCx >= 3)
     
321.                             {
     
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     
325.                                     {
     - E! e$ y* U& ^8 f% o& r7 k. B) s
326.                                             ucRecvBitCx = 0;
     
327. 
     + `3 e8 l" C: a( R4 f
328.                                             if(gsUARTBuff.CheckType == NONE)
     
329.                                             {
     ' {5 S2 \- b- A* x
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
       z" w: l, r: L/ U. v+ Y
331.                                             }
     
332.                                             else
     
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     $ D: I& w3 g# @6 ?" l. Q
335.                                             }
     * O) m, I6 I$ Q- L: H% S' n
336.                                     }
     , F  X8 n- u8 R- h5 V
337.                                     else
     
338.                                     {
     
339.                                             ucRecvBitCx ++;
     : h3 ~$ D6 L# ?9 G- h
340.                                     }
     
341. 
     - M* W8 E9 R/ ^! E. d) }" ]
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     . C% ^4 a3 u1 f% i
343. 
     5 ]4 R7 g9 f0 t3 [" g
344.                                     ucAcquCx = 0;
     $ D9 U% a( C7 T
345.                                     ucRecvBitBuff = 0;
     
346.                             }
     3 r% K1 K  [6 |' Z
347.                             else
     
348.                             {
     ' N; N8 O( v! t4 y( {
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     - r0 H1 ]& Q2 R0 T# Q2 X
350.                             }
     # D6 f5 ?6 p9 q' y( L: }
351.                     }
     
352.                     break;
     . Z/ O( b' W/ M7 }7 x3 ?
353. 
     
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     
355.                     {
     2 h) A3 u+ d: g% R
356. 
     
357.                     }
     * n3 |: s; d4 d
358.                     break;
     
359. 
     5 @# y& q$ Z3 L6 a+ ]
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     1 ~4 F& o  `; i& _$ }% A  R
361.                     {
     
362. 
     
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     * s2 l4 W" Q: V! ?/ x
365.                             if( ++ ucAcquCx >= 3)
     
366.                             {
     
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     % ]( k- ~: f1 D3 l6 \" L( j8 {; L4 g  B
368.                                     {
     
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     9 D& e2 n2 Y0 ?1 T" y# q# o8 b
370.                                             {
     : T' y& b0 }9 [- [( d/ ?
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                                                     gsUARTBuff.Recvlength ++;
     2 B" c9 Q4 C7 p( a
373.                                             }
     % r3 D2 @9 b, k( E; B0 M. W
374. 
     
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     
377.                                             
     # ^9 r4 `% ^- G0 k
378.                                             EXTI->IMR |= 0x10;
     7 d" Z6 k4 w4 \" i8 E3 q% R" e8 A, [
379.                                             EXTI->EMR |= 0x10;
     
380.                                             TIM6->CNT = 0;
     ( {% ^/ a7 |; P3 H" E) _7 n3 ^: c
381.                                     }
     . h6 C# S3 [- t' s
382.                                     else
     
383.                                     {
     ) R5 S; h' l% ^. W# `; b( U
384.                                             ucAcquCx = 0;
     0 g9 A( A3 B% a. ~+ M0 C
385.                                     }
     
386.                                     
     
387.                                     ucRecvBitBuff = 0;
     0 P* L3 m* s" Y
388.                                     ucAcquCx = 0;
     
389.                             }
     & O5 `' i* U$ m3 c: r3 S
390.                             else
     
391.                             {
     , q5 i/ F. @+ F1 S* [
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
393.                             }
     
394.                     }
     
395.                     break;
     
396. 
     9 |0 P5 p4 N5 z
397.                     default:
     " l9 v0 g- y0 w
398.                             break;
     
399.                     }
     ! y+ X( {5 P1 i# l
400.     }
     ' [* J% [7 y2 E& |* H& b$ b
401. }

复制代码

4 I3 G9 r1 l$ y  ^. J

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

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

9 R& P6 V) w2 a. I2 ?7 E" w% T0 H" Y  z