一、设计用途：

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

二、硬件电路：

  H9 P2 v- |- M

7 ^+ {2 B9 y# u! X* S# o/ y( t" C+ D

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

" D0 `' U5 f4 Z6 O0 ~. Q

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

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

% l9 r2 Y. d* Q) {( N8 [

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

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

硬件串口的噪声处理：

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

' p) V9 g- e; N' Q

3、 实现方式选择

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

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

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

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

) e# k# I, A- ~9 `) Y- _

自写第一种实现方式：

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

1. #include "UartSet.h"
   
2. #include "string.h"
   
3. 
   
4. uint8_t ucRecvData = 0;         //每次接收的字节
   . s, S: j9 t" r% _8 ]7 X2 j
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   
7. uint8_t ucSendBitCx = 0;        //发送位计数
   + d) T- U* P8 q
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   
9. 
   , N% T1 j6 \  y5 {) N3 p
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    % L/ z! L( @9 n: o; I' A- ^# \, h* T
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    9 ^# X4 I/ M/ z; G7 ^
13. 
    
14. uint32_t Prescaler = 0;
    
15. uint32_t Period = 0;
    ( }0 h! ^- ~! S- \* d0 d& F! I4 h
16. UART gsUARTBuff;               //定义串口
    
17. 
    2 ^4 v$ v7 M) i* [  M0 U
18. TIM_HandleTypeDef htim6;
    # q9 z1 |  a1 F' M' P3 `
19. 
    
20. void MX_TIM6_Init(void)
    2 H- l- o+ D0 y! C& \; T
21. {
    2 K* X/ `. v4 M/ u% D: E3 b4 t5 ^
22. 
    ' ^0 n; N7 n% U; N
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    , ]9 }8 E+ `; v4 M: W: B5 B
24. 
    
25.     htim6.Instance = TIM6;
    0 u5 H/ x/ |( C& l2 f
26.     htim6.Init.Prescaler = Prescaler;
    
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    : n2 O( ]% W  \$ p* C* ~
28.     htim6.Init.Period = Period;
    
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
30. 
    . E* G7 K2 J( d
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    ! V8 w  ?+ O) \. I
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    7 ]5 P7 n/ I4 |9 d% v$ e
33. 
    
34.     HAL_TIM_Base_Init(&htim6);
    
35. 
    
36. }
    
37. 
    
38. 
    
39. void UART_GPIO_Init(void)
    
40. {
    3 q( P* h' w. _" n1 ~
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
42. 
    
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    , n4 i5 j' ]5 W+ ?
44. 
    
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    % v! G" B( v* B- G  k6 x) x1 z# V
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;
    # {, U7 p) x2 A
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    ' t% }1 ~7 ^$ V
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    " }% u7 H0 \# ]/ h( e$ O0 k: x$ f- x
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    6 F. A, z3 v& r) B
55. 
    ) k4 s3 j) b+ K+ W7 V
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    ! w' O+ |0 ~' g
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    7 B3 J5 d# ]  W1 Q' R
58. 
    
59. }
    
60. 
    
61. 
    9 D% \) L" D  r- C* O8 F
62. /*******************************************************************************
    
63. * @FunctionName   : UART_Init.
    # `  D$ s5 y' z3 q2 U. S
64. * @Description    : 模拟串口结构体初始化.
    6 \5 v# p. k, [3 ~% j
65. * @Input          : None.
    
66. * @Output         : None.
    
67. * @Return         : None.
    
68. * @Author&Data    : MrShuCai  2019.4.11.
    
69. *******************************************************************************/
    % W; Q& M. Z$ C+ G
70. void UART_Init(void)
    : Y+ s" C; n5 g
71. {
    + @7 I& A2 r7 O) d$ R
72.     gsUARTBuff.CheckType = NONE;
    
73.     gsUARTBuff.UartMaxLength = Uartlength;
    - w* {' S. J- B4 x8 w( \# O) ?
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
75.     UART_GPIO_Init();
    
76. 
    ) b7 `& K, k: G- u4 Q
77.     if(BaudRate == 1200)
    # V+ Y- u( d+ K; P7 c, H
78.     {
    
79.         Prescaler = 15;
    
80.         Period = 623;
    
81.     }
    
82.     else if(BaudRate == 2400)
    
83.     {
    
84.         Prescaler = 15;
    
85.         Period = 207;
    
86.     }
    
87.     else if(BaudRate == 4800)
    : @; |! x5 f5 H. j, R% t8 e2 I6 n
88.     {
    
89. //        Prescaler = 15;
    
90. //        Period = 50;  //9600
    
91.              Prescaler = 15;
    ) b5 H* q3 [( R
92.              Period = 103;
    
93.     }
    
94. 
    4 ^/ p: G( V) j) l
95.     MX_TIM6_Init();
    
96. }
    
97. 
    
98. 
    " V# u; t' t% @3 j
99. /*******************************************************************************
    
100. * @FunctionName   : UART_Send_Data.
     : C' N2 m' S& L, R' y
101. * @Description    : 模拟串口发送数据接口.
     
102. * @Input          : None.
     
103. * @Output         : None.
     
104. * @Return         : None.
     
105. * @Author&Data    : MrShuCai  2019.4.11.
     
106. *******************************************************************************/
     
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     
108. {
     " n2 f4 h& G6 A5 z8 j* l
109.     gsUARTBuff.Sendlength = size;
     
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
111.     gsUARTBuff.TxEn = 1;
     
112.     gsUARTBuff.RxEn = 0;
     
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     3 L& {( R( g) A
114.     HAL_TIM_Base_Start_IT(&htim6);
     / M. T6 y7 Z- x; P, C; h1 T' V
115. }
     
116. 
     
117. 
     
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     ; S/ T6 A. l5 m6 d& L
121. * @Input          : None.
     
122. * @Output         : None.
     1 O* a* `1 X* A- k3 l5 C
123. * @Return         : None.
     ! N3 n0 _$ h2 o* X$ y
124. * @Author&Data    : MrShuCai  2019.4.11.
     : v% w' X( p2 |. u$ G' ?
125. *******************************************************************************/
     ; s  H2 b+ b2 u: O+ a! B
126. void EXTI4_15_IRQHandler(void)
     . |, b1 G- J. x+ a- O  j
127. {
     : M9 H- A6 I! k8 @. ?: X$ u
128. 
     
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
130.     {
     
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     3 c2 f; x9 c3 {2 l  o3 R( d! X
132. 
     + f- {. n6 {5 v9 A9 ]2 {. G3 A
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     / v% O% E) @1 M3 ?4 p2 G" u( P
134.         {
     ( T/ {; k7 j1 I5 k* T  U& g
135.             gsUARTBuff.RxEn = 1;
     ; |( }( D2 M. F0 ?6 c
136.             ucRecvData = 0;
     
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
       l- I! Q4 q9 I! N9 x  t0 \+ i
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     # k& B8 r4 r9 F+ `; R  |
140.     }
     & j" v% \% @1 w
141. }
     4 C4 `/ B; L& D
142. 
     + U) o. D! B1 `; u
143. /*******************************************************************************
     
144. * @FunctionName   : TIM6_IRQHandler.
     
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     6 d6 c, C# T/ ^2 y& ]
146. * @Input          : None.
     6 H& L6 \* x; R, m
147. * @Output         : None.
     
148. * @Return         : None.
     
149. * @Author&Data    : MrShuCai  2019.4.11.
     ! s  G5 A/ H- C" r
150. *******************************************************************************/
     - W+ q' ]3 e! w2 @
151. void TIM6_IRQHandler(void)
     
152. {
     
153.     HAL_TIM_IRQHandler(&htim6);
     
154. 
     & v( u& m8 e0 k/ I- r1 m; ~
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     
156.     {
     9 u; k& }; z: @' q. K6 D( f. S* X
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     
158.         {
     
159.         case COM_START_BIT_DEAL :
     
160.         {
     
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     
162. 
     ; ^6 i, Z$ N; v3 U' W
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     
164.             {
     7 I& W( c! t% J) o; \% k
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     + X3 W: O. a0 J( C7 ?
166.                 ucAcquCx = 0;
     
167.                 ucSendBitCx = 0;
     - d' h4 P( y; Y7 h+ ^
168.             }
     1 }$ R- p" O1 B1 q% M0 a
169.         }
     
170.         break;
     
171. 
     
172.         case COM_DATA_BIT_DEAL :
     * Z- [% v4 ?. W5 H$ Z5 b* U: |) O
173.         {
     % X) p& {0 k( l0 s. r, \) D# ?- P
174. 
     ! v! v( V# V% ^  d- {
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     2 Y$ b. h& U0 s4 ]' _% I: b  t
176. 
     
177.             if(++ ucAcquCx >= 6)
     $ a' P$ |( @) [) m. g0 F0 H$ L
178.             {
     
179.                 ucAcquCx = 0;
     
180.                            
     + i* K5 I& b* I) g/ D
181.                 ucSendBitCx ++;
     " }/ S; _# A5 v' o$ D- H8 Q8 O
182. 
     
183.                 if(ucSendBitCx >= 8)
     
184.                 {
     " j9 h" Q1 M3 c  t$ d! m- \
185.                     if(gsUARTBuff.CheckType == NONE)
     
186.                     {
     5 O( h/ g' e* ]
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     + x' w; ~9 {3 V0 q% A# `5 }% i
188.                     }
     
189.                     else
     
190.                     {
     
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
192.                     }
     
193.                 }
     
194.             }
     
195.         }
     
196.         break;
     
197. 
     ; j4 e9 U1 Q  P
198.         case COM_CHECK_BIT_DEAL :
     . q7 I3 U3 a0 n: A1 ~
199.         {
     4 ^) s1 x1 j9 x" w" Y, J
200. 
     # f3 G- s! x% l) _, \
201.         }
     
202.         break;
     
203. 
     * P9 P' f2 c: S& W5 m  i1 H! Z' M
204.         case COM_STOP_BIT_DEAL :
     
205.         {
     
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
207. 
     * @& D4 S9 K+ O+ T
208.             if(++ ucAcquCx == 7)
     
209.             {
     $ T0 e" c3 l  c% j5 z
210.                 ucAcquCx = 0;
     ( `# }5 `/ c; k5 z
211.                 ucSendBitCx = 0;
     
212. 
       [1 A" O% W( c, A' M9 Q
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     + I4 c. b5 I" I8 F
214.                 {
     % o5 N$ j7 A! J1 W( a0 f$ K0 J& b
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
216.                     ucSendLengCx ++;
     
217.                 }
     
218.                 else
     
219.                 {
     
220.                     ucSendLengCx = 0;
     1 [5 ^& u/ H( {+ |# j
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     7 y, g9 Y" h* ~& h7 H5 g9 G" K  C5 ~
222.                     gsUARTBuff.TxEn = 0;
     ) d$ u* X# o) S- c4 u
223.                     gsUARTBuff.RxEn = 1;
     - ]- g$ ]; \' ]  I% m
224. 
     9 \6 i: S& P" f9 K* g0 [1 B5 [
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     " S* @( m  Y7 t* @$ ~
226.                     TIM6->CNT = 0;
     ' a" b' M: W- T
227.                 }
     
228.             }
     
229.         }
     2 u' `4 C4 j9 Q# Y: V: U
230.         break;
     
231. 
     
232.         default:
     
233.             break;
     
234. 
     + y3 t- G2 O) k$ j- A
235.         }
     
236.     }
     
237. 
     % ?. ~! o2 X+ N" F
238. 
     
239.     if(gsUARTBuff.RxEn == 1)
     
240.     {
     
241.         switch(gsUARTBuff.UartStat)
     
242.         {
     2 o0 {- e7 {& d/ e2 s
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     8 L. s8 W" x& o4 m. m1 m5 n
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
247. 
     
248.             if(    ucAcquCx == 0)
     
249.             {
     8 J6 u0 L' e6 {: z% f& ^, `
250.                 ucAcquCx = 1;
     ! V6 C% {# u( c  x  A* [; |
251.                 return ;
     2 L! e: `5 p! g3 W' D
252.             }
     + |3 t# J$ Y  u& Q
253. 
     / f4 U8 e' H7 v2 \: Y
254.             if(ucRecvLastBit == ucRecvNowBit)
     & ]& A6 i! D4 G
255.             {
     
256.                 ucRecvTrueCx ++;
     5 ?4 v" \5 I; T& D) D6 _
257.             }
     
258. 
     
259.             if(++ ucAcquCx >= 5)
     7 X9 o* S8 w' [. B6 l' D7 M5 R6 a: b
260.             {
     + A" z9 ?4 K. C7 i& v' Z/ t  {/ A
261.                 if(ucRecvTrueCx >= 2)
     1 U  Y- J$ J# w
262.                 {
     : [5 I0 e0 Q% C7 V3 h
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
264.                     ucAcquCx = 0;
     
265.                     ucRecvTrueCx = 0;
     2 i' l! ?: V* X
266.                 }
       T* s- H( Y/ M6 w5 u- n
267.                 else
     
268.                 {
     
269.                     ucAcquCx = 0;
     
270.                     ucRecvTrueCx = 0;
     5 C6 ?2 e" |+ o1 X0 Q! [
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     0 u% m4 L' X5 R, D, G$ ^3 Y* O
272.                 }
     
273.             }
     
274.         }
     0 c0 w8 J+ k( F( n
275.         break;
     
276. 
     . ]6 j4 N# v' p- \, h, r
277.         case COM_DATA_BIT_DEAL :                         //数据位
     & w- |( W+ r. H7 ?% h+ q
278.         {
     $ J: D) Y$ M% p) J
279. 
     
280.             ucRecvLastBit = ucRecvNowBit;
     ; a6 z2 e: D: x6 b+ L
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     * k+ B' f6 V! K/ Q1 g- y0 m2 A4 j. i
283.             if(0 == ucAcquCx)
     ; r* P8 d- U. J; O0 U5 Z5 U) V3 ~/ j* Z
284.             {
     + G9 v+ M) _- V" X, x5 x- E
285.                 ucAcquCx = 1;
     
286.                 return;
     * Y* S& d% j9 I2 i$ {) m& d
287.             }
     
288. 
     
289.             if(ucRecvNowBit == ucRecvLastBit)
     # s+ w8 s0 G6 [8 J$ E# h& s+ J7 n
290.             {
     7 s2 T% j% \; a9 y# q8 I
291.                 ucRecvTrueCx ++;
     2 o5 }3 A9 y- j; f1 @' q% [
292.             }
     $ D# |! `/ [7 L  h+ v
293. 
     
294. 
     
295.             if(++ ucAcquCx >= 6)
     
296.             {
     # d  }3 N9 q3 K: G5 n5 Y
297.                 ucAcquCx = 0;
     " g$ a. T; j9 T" H9 Z
298. 
     
299.                 if(ucRecvTrueCx >= 2)
     
300.                 {
     
301.                     if(ucRecvLastBit == 1)
     " ]8 t# l1 ]/ {' Y0 C
302.                     {
     2 t) w! j9 M9 i
303.                         ucRecvData |= (1 << ucRecvBitCx);
     
304.                     }
     
305.                     else
     6 L5 Z! v) h& V) v4 `$ a7 e
306.                     {
     
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     
308.                     }
     
309. 
     9 k- G8 x" E; ^
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     " w( O. H. t6 h8 x1 |# R
313. 
     * M- f% j1 P/ \: I! P5 l8 a: z
314.                         if(gsUARTBuff.CheckType == NONE)
     2 N& Y# h$ a9 C9 e( r2 W) I
315.                         {
     
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
317.                         }
     
318.                         else
     5 x/ F) z/ C* a9 ]" }( {. h
319.                         {
     , P9 m5 [. o( ^; a
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     0 @9 b& z# y' N0 m/ T
321.                         }
     
322.                     }
     5 }/ @8 t, c; o6 {, K$ i
323.                     else
     6 Z/ j+ X+ c4 U) D! [# j, h
324.                     {
     + {6 r& ]# D2 K( p. B% ^5 _
325.                         ucRecvBitCx ++;
     : t& L: M+ a6 [$ o; f, l7 z
326.                     }
     5 Q' p% w1 y2 a+ G6 n" U8 W, I
327.                 }
     - \! @4 j, [. j5 G
328.                 else
     . i( @1 W2 \" T! R2 U' ]
329.                 {
     
330.                     ucAcquCx = 0;
     0 c7 A. Q) L5 X0 k. Q2 N
331.                     ucRecvTrueCx = 0;
     0 h4 j/ x3 j/ u$ Q" s: S0 t- J
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     4 e6 {+ ?" o1 ^0 ?! U
333.                 }
     
334.             }
     ) i2 @1 I8 z: y
335.         }
     5 q+ l: C+ y8 z4 u
336.         break;
     
337. 
     4 W7 Y9 \6 K- j2 M" H# L
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     1 e! Y6 z# k& y4 \/ Y
339.         {
     
340. 
     ! t/ E' H$ t' h8 `$ ~% P
341.         }
     + R0 X8 D9 a# K: d% p
342.         break;
       h+ z$ X+ g" v; t
343. 
     
344.         case COM_STOP_BIT_DEAL :                         //停止位
     2 i  X: c( u4 Y* ^& L& {5 w5 a
345.         {
     : d7 ]& c5 t6 C+ i
346. 
     2 ?# T2 D2 I& Y7 F5 s0 t
347.             ucRecvLastBit = ucRecvNowBit;
     
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     $ y7 G  e' T- D! b3 g
349. 
     
350.             if(0 == ucAcquCx)
     2 ~0 t# d+ p4 n0 c
351.             {
     
352.                 ucAcquCx = 1;
     
353.                 return;
     1 v( q7 ?$ }- |* X" B  y
354.             }
     / B7 z# T5 b9 q* ]7 M9 C+ B) P3 X: s
355. 
     $ y: q% E  p9 Y, E- [% s$ Z* Z9 T
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     ' i0 B& I* I2 K2 Y1 f  m( W
357.             {
     
358.                 ucRecvTrueCx ++;
     3 v4 g3 S: `. D
359.             }
     
360. 
     
361. 
     
362.             if( ++ ucAcquCx >= 6)
     1 h# V# t9 W) W
363.             {
     
364.                 ucAcquCx = 0;
     $ |; }( w; e4 ?9 J) e
365. 
     
366.                 if(ucRecvTrueCx >= 2)
     # T4 F: J: n6 Q1 B: k0 O
367.                 {
     . `6 M9 j- @  g2 n$ D3 `
368.                                       ucRecvTrueCx = 0;
     $ f9 t. v& H5 t3 @1 B8 `
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     ; w# q' `4 W- Z8 {
370.                     {
     8 O, r0 v7 Y" b
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                         gsUARTBuff.Recvlength ++;
     5 ^+ ^0 {- t: Y- ~
373.                     }
     
374. 
     
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     3 P- y+ E% @5 y1 c
377.                     TIM6->CNT = 0;
     & a& N& ?9 E3 x/ ]' `) u
378.                 }
     
379.                 else
     
380.                 {
     
381.                     ucRecvTrueCx = 0;
     
382.                 }
     
383.             }
     
384.         }
     
385.         break;
     6 ^! t4 c& b! L3 s
386. 
     
387.         default:
       _4 o! S4 u" P. ^. E& @# R# J( U& x! Z
388.             break;
     % X  S/ A9 K# l0 ~4 E$ b
389. 
     
390.         }
     
391.     }
     
392. 
     4 ]% D; Z) F$ T' s$ n2 s
393. }

复制代码

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

3 f/ }& @+ u8 C+ c1 P- {' l

4、 最优实现

5 O+ n5 a; O2 Y  ]6 y

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

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

1. #include "UartSet.h"
   ) V# L" M1 C, w5 m6 Q/ |. l! {
2. #include "string.h"
   
3. 
   ! P1 B) W" d8 @- o, k1 M! Z7 @- g: M
4. typedef enum
   
5. {
   % M! G2 I( h' Z* _0 u5 V0 w
6.     TimeRecvStartStep1 = 0,
   * u" P$ {8 s: J4 m, p+ Z
7.     TimeRecvStep2 = 1,
   
8.     TimeRecvStep3 = 2,
   % Q' {4 _; U8 |% `, z
9.     TimeRecvStep1 = 3,
   + ~! E- R5 ?" e% h, R- ?8 V
10.     TimeSendStep = 4,
    
11. 
    
12. } TimeStep;
    
13. 
    , C$ e6 ?* P7 N% V" C0 F
14. uint16_t TimeSet[5];
    
15. 
    9 Z) F  X6 u# |& @5 R- N
16. uint16_t TimeSetBuff[][5] = {{1199, 59, 59, 2378, 2498 }, //1200
    , U& ?! u7 A$ j+ _5 @
17.     {539, 59, 59, 1128, 1247 },  //2400
    7 N2 L/ Z, Y7 }" P6 n8 f/ Y" Q
18.     {239, 59, 59, 503, 624  },   //4800
    ; `, [: ], L# m, o; K$ i* m3 r: x
19.     {149, 29, 29, 251, 311  },   //9600
    5 m! ]5 m& ~/ g/ K1 w7 S: }
20.     {0, 0, 0, 0, 0    },         //预留
    : o! W9 \9 g' g; ^5 g$ g+ b
21. };
      t4 @- F+ F. x2 S
22. 
    9 e2 s! @3 J3 x, ^2 C4 t
23. UART gsUARTBuff;                //定义串口
    ! U& i# K1 d/ l) T) }+ v
24. 
    ( L2 H4 O9 q: D9 D- `3 {
25. uint8_t ucRecvData = 0;         //每次接收的字节
    
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    0 {) {1 H. K1 H6 o# L) o
28. uint8_t ucSendBitCx = 0;        //发送位计数
    
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    
30. 
    
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    
32. 
    6 t* i. q' C5 n
33. 
    
34. TIM_HandleTypeDef htim6;
    
35. 
    
36. void MX_TIM6_Init(void)
    ; M. W' n, B  N( V; |
37. {
    
38. 
    
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    
40. 
    / P( U' E4 X+ F- `0 _& H, r# {* G' W
41.     htim6.Instance = TIM6;
    
42.     htim6.Init.Prescaler = 15;
    
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    0 \+ G( P3 Q, J) S
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    3 o- c+ i* g1 ^3 F' V
46. 
    
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
49. 
    
50.     HAL_TIM_Base_Init(&htim6);
    
51. 
    
52. }
    * E, }9 g8 t, b5 B( l: w
53. 
    
54. 
    # i1 z( k: D: W7 B  p
55. void UART_GPIO_Init(void)
    
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
    
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
60. 
    1 f# e& k- m% s" K9 \# J
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);
    
66. 
    9 X2 E8 w- L9 A$ V' e1 d
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
71. 
      p1 ]* I1 L+ m' {
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    7 w; ^2 X' n8 {6 O2 @5 K" v
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    5 }9 N2 m  u! ?2 K' n
74. 
    * V* @& m4 u) }* ]
75. }
    
76. 
    2 F+ u7 J) P1 _0 g6 J: v
77. 
    
78. /*******************************************************************************
    ! I" \5 K% E6 E" E) {" T4 D; |& T
79. * @FunctionName   : UART_Init.
    
80. * @Description    : 模拟串口结构体初始化.
    
81. * @Input          : None.
    * ^8 `% w# v6 E- D; A% b
82. * @Output         : None.
    , A( Q9 V8 J; |
83. * @Return         : None.
    
84. * @Author&Data    : MrShuCai  2019.4.11.
    8 }' \. K: ?' y# G
85. *******************************************************************************/
    
86. void UART_Init(void)
    : T9 E3 w/ R" W9 n
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    
89.     gsUARTBuff.UartMaxLength = Uartlength;
    
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
91.     UART_GPIO_Init();
    2 F" G1 C' n- g0 g& b( x
92. 
    
93.     if(BaudRate == 1200)
    2 q4 c( f+ z- F( T" Z6 ~
94.     {
    9 u% n: A5 t3 J& ^2 z" o0 J# B
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    
96.     }
    - u( L( B' @+ I+ L, K
97.     else if(BaudRate == 2400)
    # B* r6 E' q* }: x6 x" g4 o
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    
100.     }
     ' u" W$ Y- }! i; F
101.     else if(BaudRate == 4800)
     
102.     {
     8 u3 ~' G& }' R0 K. |5 Q$ d
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     9 y5 K7 T# D2 g
104.     }
     
105.     else if(BaudRate == 9600)
     
106.     {
       N, W$ {; n" n7 Y
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     
108.     }
     
109.     else
     
110.     {
     
111. 
     
112.     }
     9 W" I+ m! w1 ?  r/ q: ~
113. 
     7 l9 @9 R9 z( q$ H, {$ F) D8 m
114.     MX_TIM6_Init();
     . Q1 W# t% A/ ^" w- p' ]0 x
115. }
     
116. 
     0 |9 O1 D3 N6 D2 ~8 l8 U/ U
117. 
     ( W4 l/ n( p' V& i$ J: f/ F
118. /*******************************************************************************
     0 @$ `5 @% c4 o
119. * @FunctionName   : UART_Send_Data.
     6 i  \+ @3 |: i1 a+ b
120. * @Description    : 模拟串口发送数据接口.
     ! ^* S: j# Y0 P
121. * @Input          : None.
     
122. * @Output         : None.
     5 l) ~/ a! M- \5 _
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     - {3 [9 b/ X  V) H
127. {
     & \: ?6 x- n  {1 h  O* i; _( }; x
128.     gsUARTBuff.Sendlength = size;
     8 s; I) J2 `) }$ E' v
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
130.    
     * j# i/ d' J: r( e1 V
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     8 v+ y4 {- _( F/ n; C/ w) Q- z
132.         {
     
133.             gsUARTBuff.TxEn = 1;
     # @! W0 u/ u5 D  @5 ]3 N
134.             gsUARTBuff.RxEn = 0;
     
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     5 y5 I+ F# l% H- w
136. 
     2 Y; o9 [2 P  I' F$ P" u
137.             TIM6->ARR = TimeSet[TimeSendStep];
     
138.             TIM6->EGR = TIM_EGR_UG;
     
139. 
     % P1 u& _' k" N2 H% D7 B
140.             HAL_TIM_Base_Start_IT(&htim6);
     6 r: Z& u( ~- ?# z- y" M
141.         }
     
142.       
     
143. }
     
144. 
     : n, e: o1 R$ ~1 ]
145. 
     
146. /*******************************************************************************
     
147. * @FunctionName   : EXTI4_15_IRQHandler.
     
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     : d9 Y7 I* ~4 V8 K" L1 I* O, p
149. * @Input          : None.
     ; v. U+ U& A* R" J0 o! u; e; D5 b
150. * @Output         : None.
     
151. * @Return         : None.
     
152. * @Author&Data    : MrShuCai  2019.4.11.
     
153. *******************************************************************************/
     
154. void EXTI4_15_IRQHandler(void)
     2 R$ a% h# k2 }# D: @7 q& x" m
155. {
     
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     0 ]$ H7 \$ ]# I. }; v+ B9 a
157.     {
     
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     6 A  N  k# Z! h- M& x0 M
159. 
     
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     % W+ j& y: z: _
161.         {
     3 V; @6 G+ x& \; {5 v9 q# p
162.             gsUARTBuff.RxEn = 1;
     
163.             ucRecvData = 0;
     * D9 ^4 A1 H. i3 y) X5 N5 w
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     1 P) m% n' @" }, E8 `' _0 P
165. 
     7 j, z8 I  ~% u
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     
168.                       EXTI->IMR &= ~(0x10);
     , ~- h8 `( N* o7 s
169.                       EXTI->EMR &= ~(0x10);
     , ]9 t( h) F+ {5 d+ F
170.             HAL_TIM_Base_Start_IT(&htim6);
     
171.         }
     3 Y# W6 `4 m1 L, {% A( j5 s3 S8 R: c
172.     }
     ! ^! ^3 ~# G; [: W9 s7 h
173. 
     
174. }
     ' y# t2 g' H4 P# M
175. 
     - |( g0 U) O' r* {" _, c' \% v% o
176. 
     
177. /*******************************************************************************
     & h5 O0 W2 w8 p
178. * @FunctionName   : BitValueChk.
     
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     0 ?* l) _8 ^/ _7 _% d
180. * @Input          : n 采集记录的位值.
     
181. * @Output         : BitValue.
     
182. * @Return         : BitValue.
     
183. * @Author&Data    : MrShuCai  2019.5.1.
       I* b* ]' a6 {: i7 x
184. *******************************************************************************/
     ! a( {9 D% t6 P1 y3 X
185. uint8_t BitValueChk(uint8_t n)
     * ]+ c7 g1 w' a  Y% u
186. {
     
187.     uint8_t BitValCx = 0;
     
188. 
     
189.     for(BitValCx = 0; n; n >>= 1)
     
190.     {
     , C3 \' e" o  c/ _' q3 E
191.         BitValCx += n & 0x01;
     / K! u  |2 W4 g2 \
192.     }
     7 O7 [. c' z3 {9 ]/ i- V, t4 f& r9 Q
193. 
     
194.     return (BitValCx < 2) ? (0) : (1);
     3 A  C0 \  f) r$ m
195. 
     9 @# n* x# t! ^% F7 i% c
196. }
     % q" I% h! X. ^5 h$ T. X0 O- x
197. 
     1 X$ p0 Q4 h/ J; w; k* \8 \
198. /*******************************************************************************
       t$ X1 G% H- O! O% W. b' Q
199. * @FunctionName   : TIM6_IRQHandler.
     1 s, i# A/ t( d8 I) t1 [
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     
201. * @Input          : None.
     
202. * @Output         : None.
     
203. * @Return         : None.
     ' Z% q, e- b/ k3 R* |# g
204. * @Author&Data    : MrShuCai  2019.4.11.
     9 l6 F* D4 L* k6 J! |, z3 E
205. *******************************************************************************/
     1 z5 x& I' [9 ^8 f. p5 O
206. void TIM6_IRQHandler(void)
     
207. {
     
208. 
     ' `6 \7 E2 D* F- P- G8 y+ z
209.     HAL_TIM_IRQHandler(&htim6);
     
210. 
     
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     ) J; J/ A. V" b; m& @. y
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     : H) C# x7 W5 N! Y, \/ A5 [
214.         {
     9 \  f6 d. f; h4 L
215.         case COM_START_BIT_DEAL :
     % ~2 Y5 O6 X) e( f3 J1 v% O/ u- {( s
216.         {
     2 B# O8 l0 Y) G% F1 s  B$ Q7 {
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.         }
     4 f6 U* H+ C+ @0 e3 u
221.         break;
     : ^- n) }2 O2 y# g2 ]
222. 
     
223.         case COM_DATA_BIT_DEAL :
     0 J0 O1 ]7 A; j. ]4 c
224.         {
     1 f& p0 b! R( h- J: {  o
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     
226. 
     + V9 h+ T6 A4 s" p! E% A" L
227.             ucSendBitCx ++;
     
228. 
       x; v1 R6 A5 F0 {. o
229.             if(ucSendBitCx >= 8)
     5 U; _; \* w! `$ {
230.             {
     , w# z+ A2 @0 s2 _( M
231.                 if(gsUARTBuff.CheckType == NONE)
     
232.                 {
     & Z, e8 G' Q" K2 v& o" U
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     9 H. z* _( m; k. o$ K- ^+ j
234.                 }
     
235.                 else
     
236.                 {
     ! h& @/ Y' P9 p- L: q; X1 t
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
238.                 }
     9 d: e& D6 ?# x
239.             }
     , p/ y; G6 _$ M0 k& {
240. 
     % a$ D  A+ L. G" X) K6 L
241.         }
     % r; y9 X9 h6 d7 o' s2 k
242.         break;
     % h4 M; @7 J/ F* B7 r# n2 e- |5 V
243. 
     ; W! l) ?$ d! S! q- N' _* F$ s
244.         case COM_CHECK_BIT_DEAL :
     ! N7 |7 a3 _, }1 |, a4 h7 ^% y# O$ N
245.         {
     
246. 
     ! d6 M- _1 a# D4 \. P( X& i
247.         }
     , ^& B6 B$ }$ {
248.         break;
     $ X( A( E  i- B& U, H
249. 
     ( l6 i: U7 e5 O4 [. l
250.         case COM_STOP_BIT_DEAL :
     - Y- F6 R  Z, M; D# ~
251.         {
     - A8 r+ x4 y* c$ g
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     ) G, W$ R7 y3 \' X
253. 
     
254.             ucSendBitCx = 0;
     
255. 
     5 R% Z) q4 K6 i8 Z
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
257.             {
     ! D7 Z! D+ @3 s% v4 y
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     8 b% P7 P/ W1 ]6 H
260.             }
     8 [' ^5 ~5 I& j5 P
261.             else
     
262.             {
       M/ B( \# n( D
263.                 ucSendLengCx = 0;
       g% D3 Y7 k4 t. ?4 R
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
265.                 gsUARTBuff.TxEn = 0;
     * ~8 o2 x5 m& |2 d' y9 i* T( x  G
266.                 gsUARTBuff.RxEn = 1;
     $ W8 Y! J, [: Y, z, K+ a2 n! Y
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     ; F6 G" h9 ]9 r# J8 E
268.                               EXTI->IMR |= 0x10;
     
269.                           EXTI->EMR |= 0x10;
     
270.                 TIM6 ->CNT = 0;
     
271.             }
     9 B" H$ x5 X+ ]5 t
272. 
     $ U8 r' B$ @1 q( j1 B0 m9 E
273.         }
     8 R& ?$ H, r) D, G
274.         break;
     3 b, N8 ^/ l( Y# L# w6 i
275. 
     
276.         default:
     
277.             break;
     
278. 
     ( v+ e1 J% b4 s2 |
279.         }
     ! d  E) i" M" W2 X
280.     }
     & R8 ~4 G% c) d" \
281. 
     7 E' ^$ u: e6 {( `, o
282. 
     , z2 J  y& ?! t) o9 [
283.     if(gsUARTBuff.RxEn == 1)
     2 l" m1 ^% F5 r/ [7 u+ n# K6 N
284.     {
     6 _; M7 \0 W3 I* _+ |8 o% ~  E
285.         switch(gsUARTBuff.UartStat)
     
286.         {
     
287.                     case COM_START_BIT_DEAL :
     
288.                     {
     / G/ f! C" {) C- e' p7 I) s! j
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
290. 
     
291.                             if(++ ucAcquCx >= 3)
     3 I9 \0 ]0 ~+ a' J5 e6 x7 P
292.                             {
     
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     
294.                                     {
     
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     2 q5 k5 S5 J! }# B. t
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     
297.                                     }
     $ D% C1 S; E0 \
298.                                     else
     9 i2 x& b! X4 Z/ r, S$ f
299.                                     {
     
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     * N$ F4 {, \2 u3 r0 }: L
301.                                     }
     # x5 G% @0 _4 g9 s, M$ g% a; k
302.                                     
     
303.                                     ucRecvBitBuff = 0;
     
304.                                     ucAcquCx = 0;
     
305.                             }
     5 S; D6 p, B' D
306.                             else
     
307.                             {
     ( p$ ^/ U2 a5 G1 L. @, E! T# _
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
309.                             }
     $ W$ d; t0 @7 q$ E  g6 @
310. 
     ; D' O" j9 Y& V$ V* h  z3 p7 E
311. 
     ) [3 U' I) M! D6 `# X, \; L
312.                     }
     & d# q9 s. X8 F$ v8 g: m
313.                     break;
     
314. 
     $ i* L5 {/ Q+ u
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     ( B: J% G: r: a, u" q# v
316.                     {
     9 f/ K  b4 Z$ z7 L& Y. `* @
317. 
     
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     $ t) @8 i6 D' R3 j1 R- O( ^
319. 
     
320.                             if(++ ucAcquCx >= 3)
     
321.                             {
     4 z1 z+ r" D8 _* N) p" l
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     - M6 L% F% a8 n/ y& t7 S$ c
325.                                     {
     
326.                                             ucRecvBitCx = 0;
     , I; j5 x( d7 A( p+ u
327. 
     " d7 J1 s' D; a
328.                                             if(gsUARTBuff.CheckType == NONE)
     / @# n3 a8 m* o3 C
329.                                             {
     : o# J+ n% {4 ^- C* _7 @6 B' e
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
331.                                             }
     ' l/ }5 ^+ U/ F$ h& y& f1 X! j. h
332.                                             else
     ; P" q% M3 T9 c! z/ `- A8 y5 b& {' t+ A  @" K
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
335.                                             }
     
336.                                     }
     6 L1 Q* l: X) c2 g! h+ f& M9 M
337.                                     else
     0 D' {* F) n/ D' L+ f* C
338.                                     {
     / e/ Y* ?; I" z, X/ S
339.                                             ucRecvBitCx ++;
     
340.                                     }
     
341. 
     3 g- S2 Q! Y  \4 p
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
343. 
     ! O1 ?( Q' P! C1 V0 A
344.                                     ucAcquCx = 0;
     * o" O$ v' ?, c; ]; Q. C
345.                                     ucRecvBitBuff = 0;
     
346.                             }
     * C& x, s1 h- K6 A2 Q$ |* k
347.                             else
     3 W) w8 ^8 f* d5 W/ p
348.                             {
     
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
350.                             }
     
351.                     }
     3 i9 O8 D. C/ K
352.                     break;
     
353. 
     
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     ' A& i+ `; x9 D6 i0 L8 ~( M% a4 @
355.                     {
     + Y6 r, {. K1 y+ {2 {3 J, Y7 k# A
356. 
     - t& C$ l  `- o6 d
357.                     }
     
358.                     break;
     $ K% |* \  H* ~' c  S0 _* r
359. 
     4 q! C1 F) C+ p7 v* q( b
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     
361.                     {
     : T8 Y1 R3 [" F. w5 o. j4 O2 A
362. 
     
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     ' b  T# C7 }; O. [
365.                             if( ++ ucAcquCx >= 3)
       ^" J" h! T! |) B) G
366.                             {
     4 n; |0 n6 R, b
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     % g- d/ g5 ^0 w4 x4 L
368.                                     {
     
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                                             {
     ( m1 k0 V# W+ l2 U, E
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                                                     gsUARTBuff.Recvlength ++;
     - j1 b* X! g* X5 x
373.                                             }
     ; M" i6 c; a4 `& l" A
374. 
     
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     
377.                                             
     ' Y1 U5 P% V: s$ A; k  R
378.                                             EXTI->IMR |= 0x10;
     / T' r* r' C0 U4 |2 G
379.                                             EXTI->EMR |= 0x10;
     
380.                                             TIM6->CNT = 0;
     
381.                                     }
     ' ?4 I8 B9 M6 I0 v* Q
382.                                     else
     
383.                                     {
     ) `0 S! O; u! Z+ f5 f5 D: W3 i; G
384.                                             ucAcquCx = 0;
     
385.                                     }
     3 G+ r9 O6 G  g- r
386.                                     
     : J, C4 e  ~2 _$ W* `1 d
387.                                     ucRecvBitBuff = 0;
     
388.                                     ucAcquCx = 0;
     
389.                             }
     * I! _; D/ j; s3 O1 \1 l
390.                             else
     
391.                             {
     
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
393.                             }
     
394.                     }
     
395.                     break;
     9 \6 m7 }- V# @7 f- }) q" D
396. 
     
397.                     default:
     
398.                             break;
     ) J' t# g( q* T
399.                     }
     
400.     }
     
401. }

复制代码

) o: ]0 `6 k" W8 t

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

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