一、设计用途：

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

二、硬件电路：

' U- ^- a: m. Z4 C2 b; W* @  D

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

& ?- \: X0 s! c  }6 g

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

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

" d6 \, p7 H. C6 |2 {7 y

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

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

硬件串口的噪声处理：

) v9 h2 e, n. C/ s9 m3 `2 m0 a

' z, ^  N/ R+ r

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

3、 实现方式选择

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

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

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

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

自写第一种实现方式：

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

1. #include "UartSet.h"
   / i4 g% i/ i& O( X4 M
2. #include "string.h"
   
3. 
   8 j: \* i3 ?: j& W
4. uint8_t ucRecvData = 0;         //每次接收的字节
   
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   
7. uint8_t ucSendBitCx = 0;        //发送位计数
   / N' \8 Q- p! I( I/ w  g
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   
9. 
   
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    8 e3 i' |- \2 q8 q5 `
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    
13. 
    
14. uint32_t Prescaler = 0;
    4 S! h3 ^( J* y5 u6 B) l4 m
15. uint32_t Period = 0;
    $ e- ]8 c& ^! U/ Q7 z
16. UART gsUARTBuff;               //定义串口
    
17. 
    
18. TIM_HandleTypeDef htim6;
    - G( ]) [# M" H
19. 
    
20. void MX_TIM6_Init(void)
    . l3 L. ^# l5 D1 O- @0 D) d5 [
21. {
    
22. 
      ?- Z: |& T% ?+ F3 p% f
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    * z- ?  V2 g/ H! {2 N% z
24. 
    * \6 R. a0 D1 `5 ~6 t$ ^" p8 `
25.     htim6.Instance = TIM6;
    
26.     htim6.Init.Prescaler = Prescaler;
    $ I. E5 P7 `$ ~1 V
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    4 V; A) i* N3 s+ {
28.     htim6.Init.Period = Period;
    8 a8 A  h# A# N1 h+ ?
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
30. 
    
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    4 \% p, s# ~- L& S
33. 
    5 i; u, g/ S2 S# F
34.     HAL_TIM_Base_Init(&htim6);
    
35. 
    3 z5 W9 q. @3 [+ J6 Q
36. }
    
37. 
    
38. 
    
39. void UART_GPIO_Init(void)
    
40. {
    & ^: Z- q& I' E7 V: A; b- f
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    3 P+ n. l, T1 M3 n  n0 F5 z- P
42. 
    * P  T' P  Z7 }7 y5 Z$ U& V
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
44. 
    
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    9 c3 {/ y/ x) L  g6 k( `: `3 ^; y
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    " L7 L& k( r' E+ f4 P! ?" {, _* T: Y
49.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    0 f0 U4 R, s6 q+ T; F
50. 
    & ~. O7 ^# @" P: j# M  ^
51.     GPIO_InitStruct.Pin = COM_RX_Pin;
    ( E1 G' e' a( M7 ]
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    5 F  j1 C: t3 O3 m3 K
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    # W; ]" _2 ]7 x' j3 d; y
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    8 V, E8 z, Q) i5 V
55. 
    6 q# L9 u$ V# \/ U" e5 f8 V
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
58. 
    
59. }
    
60. 
    
61. 
    
62. /*******************************************************************************
    ( T0 p$ e- ?4 _$ ]
63. * @FunctionName   : UART_Init.
    9 `$ i; {( M, O" e5 `
64. * @Description    : 模拟串口结构体初始化.
    0 n' y( r. Y: W
65. * @Input          : None.
    
66. * @Output         : None.
    + ]. j4 U6 C& R1 e
67. * @Return         : None.
    
68. * @Author&Data    : MrShuCai  2019.4.11.
    1 _$ E3 ]# K, r. o% @% L
69. *******************************************************************************/
    8 x# b  |9 n0 o$ g% O$ e
70. void UART_Init(void)
    4 E1 v* `; l. @7 G* P0 b
71. {
    
72.     gsUARTBuff.CheckType = NONE;
    . e% u& M. I+ ?  d$ W8 T
73.     gsUARTBuff.UartMaxLength = Uartlength;
    
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
75.     UART_GPIO_Init();
    ; [- I  D& u8 P4 _
76. 
    2 D, R& X# j$ s$ C* ]" n: m
77.     if(BaudRate == 1200)
    
78.     {
    ' ]8 K, H9 C& f0 l) y
79.         Prescaler = 15;
      d6 x3 S0 N- Q- a* C, g, G6 ^+ L$ T
80.         Period = 623;
    8 j' z1 r1 z  V
81.     }
    
82.     else if(BaudRate == 2400)
    
83.     {
    8 E' N% }# j( y. [6 G- H9 q2 w- i
84.         Prescaler = 15;
    
85.         Period = 207;
    
86.     }
    / D7 d4 z6 u+ |3 I! }' K1 f9 e% A
87.     else if(BaudRate == 4800)
    
88.     {
    ! C8 B- G( }& ^% G# A+ U, |
89. //        Prescaler = 15;
    " o2 i# [, [& c5 q
90. //        Period = 50;  //9600
    " @0 {7 b! J5 i! _4 H
91.              Prescaler = 15;
    # t6 v8 j! f# W7 b- C' ]8 ]. f
92.              Period = 103;
    ( [+ p+ H& c' m. a) o
93.     }
    
94. 
    
95.     MX_TIM6_Init();
    
96. }
    ' c) f/ f  n- O4 o/ J, U
97. 
    
98. 
    0 ^8 E' L( w: y/ u7 }# G
99. /*******************************************************************************
    1 Z5 s# K9 Y, n4 f* a' [2 Q
100. * @FunctionName   : UART_Send_Data.
     " t2 ?6 R, v4 j( [9 ?5 ?- D! D$ G
101. * @Description    : 模拟串口发送数据接口.
     
102. * @Input          : None.
     " h* Y& z/ [. H: _8 b: Q
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)
     6 _- W- F& {6 Y& C! q; T
108. {
     
109.     gsUARTBuff.Sendlength = size;
     # [5 H8 s6 h5 t8 B; \* e
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     ! F" K( z8 M9 z& O2 K/ K
111.     gsUARTBuff.TxEn = 1;
     8 P7 {) J; l% i# Q9 i7 y: ^8 W$ {6 }
112.     gsUARTBuff.RxEn = 0;
     
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
114.     HAL_TIM_Base_Start_IT(&htim6);
     0 Z! H9 K6 N" X& d
115. }
     
116. 
     4 e& v, B; T" b7 n
117. 
     . L, P8 ?/ {( e4 I9 H
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     # x8 K; w& |! ]. z! X  x' q. a0 a
121. * @Input          : None.
     5 l4 n8 `. O+ o* i
122. * @Output         : None.
     
123. * @Return         : None.
     ( Q6 D4 q) [3 M- d* Z) J
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     8 U( S/ u& y0 H* F
126. void EXTI4_15_IRQHandler(void)
     - S$ V0 j: d& s1 p( ?
127. {
     $ d5 s6 m6 W3 l- |4 {, U& e. K
128. 
     2 _- `  K6 `2 y9 x; r5 B# h/ I
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     ( [+ x: l" \0 f8 M! y. D9 @0 _
130.     {
     
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
132. 
     8 v' i+ r& p, i; f2 C; o( x3 s2 R& V3 A
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     ! t! u1 z7 j1 R8 g( o" F
134.         {
     
135.             gsUARTBuff.RxEn = 1;
     
136.             ucRecvData = 0;
     8 b8 o4 G: p* z+ `+ e! T# C; Y
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     : v  b1 i% d0 s+ z& g
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     
140.     }
     + |& T# c" D3 v" D
141. }
     
142. 
     
143. /*******************************************************************************
     
144. * @FunctionName   : TIM6_IRQHandler.
     # n: w# ~& M' F  r# d4 p- o# E6 M
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     * j$ U/ a- b  ?
146. * @Input          : None.
     
147. * @Output         : None.
     ; `2 p7 h+ @. X
148. * @Return         : None.
     3 R  o! h. \; R. s- Y" \7 P6 l) t5 K
149. * @Author&Data    : MrShuCai  2019.4.11.
     
150. *******************************************************************************/
     9 ]/ {. P' V+ ?6 ]# ^
151. void TIM6_IRQHandler(void)
     . d/ u4 I, J* Y2 B! h; Z
152. {
     ' [( g9 j2 w; j) a# m
153.     HAL_TIM_IRQHandler(&htim6);
     
154. 
     
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     
156.     {
     
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     7 v4 [' Q+ K$ O
158.         {
     
159.         case COM_START_BIT_DEAL :
     
160.         {
     
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     
162. 
     5 l% m8 k7 v- ]" d6 m) s# e
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     % E; W0 D" k* L; H& d
164.             {
     % ^. L$ B4 F4 i( j, m
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     ' |5 u7 r: P0 L: X" i3 V
166.                 ucAcquCx = 0;
     
167.                 ucSendBitCx = 0;
     & `8 U! \% W; k
168.             }
     4 E% o/ H, _* G0 x5 M2 p7 x
169.         }
     
170.         break;
     ) ^! A0 z7 i5 E( }3 q& J
171. 
       i% ^, a3 k! h7 q. I
172.         case COM_DATA_BIT_DEAL :
     
173.         {
     4 `% K0 l: X9 M
174. 
     
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     
176. 
     
177.             if(++ ucAcquCx >= 6)
     
178.             {
     
179.                 ucAcquCx = 0;
     
180.                            
     
181.                 ucSendBitCx ++;
     
182. 
     
183.                 if(ucSendBitCx >= 8)
     / d% g; l6 E  E: z
184.                 {
     
185.                     if(gsUARTBuff.CheckType == NONE)
     
186.                     {
     7 {% ]( Q; v9 C3 W8 K- s2 h7 X
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
188.                     }
     ( h* o9 r  Q- q4 X
189.                     else
     
190.                     {
     
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     0 X; ^/ o2 @7 o4 a$ \1 t! b7 K
192.                     }
     
193.                 }
     
194.             }
     7 B# B: V: @/ V5 t! x
195.         }
     
196.         break;
     
197. 
     
198.         case COM_CHECK_BIT_DEAL :
     9 l# B2 N2 D# m- I5 L9 Y+ u  o& N
199.         {
     
200. 
     
201.         }
     ' u2 z9 U) a/ t* ~" R
202.         break;
     
203. 
     ' k/ [: R2 a! k: A$ Z
204.         case COM_STOP_BIT_DEAL :
     
205.         {
     ! M1 ?' m8 F# f( _
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
207. 
     
208.             if(++ ucAcquCx == 7)
     
209.             {
     2 Z4 j7 f+ [. [: {3 O* }9 G
210.                 ucAcquCx = 0;
     ' j2 l5 r- A' x9 q1 e" g
211.                 ucSendBitCx = 0;
     ) u( e4 ^4 W$ Q. ^
212. 
     7 \6 J7 M$ ?* n$ l
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     * `& D7 ?* ~( I9 E1 L( E0 B
214.                 {
     
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
216.                     ucSendLengCx ++;
     , F, ~0 m7 f  `4 G& X+ J
217.                 }
     
218.                 else
     
219.                 {
     + {! @/ _* S* T
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     ) |5 {0 L( x# t8 a9 U5 A# G
222.                     gsUARTBuff.TxEn = 0;
     
223.                     gsUARTBuff.RxEn = 1;
     
224. 
       Y9 Z/ O* H. d6 ?; A+ h6 L
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     
226.                     TIM6->CNT = 0;
     
227.                 }
     
228.             }
     - M  p+ ~; J' P7 y( l9 S
229.         }
     
230.         break;
     
231. 
     
232.         default:
     7 G0 E& g: C5 @- O4 F# F. i
233.             break;
     
234. 
     
235.         }
     
236.     }
     
237. 
     
238. 
     7 M4 u+ i) }0 U8 x
239.     if(gsUARTBuff.RxEn == 1)
     6 i* s$ l" e) I( t
240.     {
     
241.         switch(gsUARTBuff.UartStat)
     % {9 E2 D& m# J9 {5 r
242.         {
     * k) \2 z! x! q  p
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     / A# f( B% u$ z1 b! Y( i
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     5 B2 p% |! P9 v, z
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     6 k; s  `/ S3 s7 G" @# k% p1 l
247. 
     . j& V, C5 |9 ?
248.             if(    ucAcquCx == 0)
     
249.             {
     8 o, X4 o5 h; M8 t5 p2 H
250.                 ucAcquCx = 1;
     3 A/ H. c  F- v" w, T* {8 P" a
251.                 return ;
     2 W3 |, B0 ?3 @" p% N  n7 t
252.             }
     
253. 
     
254.             if(ucRecvLastBit == ucRecvNowBit)
     6 b7 A$ ?8 Y. t# M9 H7 a8 E, b, C
255.             {
     
256.                 ucRecvTrueCx ++;
     ) I- S- B" }" o' \; U9 B* W- m
257.             }
     4 @$ M* v7 w2 M. g
258. 
     
259.             if(++ ucAcquCx >= 5)
     
260.             {
     
261.                 if(ucRecvTrueCx >= 2)
     / R' c% d5 t) M1 L% S
262.                 {
     
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     ' x. x9 D/ W" R
264.                     ucAcquCx = 0;
     3 |/ Y0 `. T7 ?: t) [
265.                     ucRecvTrueCx = 0;
     
266.                 }
     
267.                 else
     
268.                 {
     
269.                     ucAcquCx = 0;
     ) i8 f" b# T2 P& Y2 I( @( c/ \8 }
270.                     ucRecvTrueCx = 0;
     
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     ( c) j; B6 Y2 {$ T
272.                 }
     
273.             }
     
274.         }
     
275.         break;
     / d# |8 g  C! A# ~- @
276. 
     
277.         case COM_DATA_BIT_DEAL :                         //数据位
     / R, I" ]6 \+ _) \/ H
278.         {
     
279. 
     5 G1 s" t( {* k3 j7 c* `
280.             ucRecvLastBit = ucRecvNowBit;
     
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     
283.             if(0 == ucAcquCx)
     ! j+ H3 q( x2 S: M
284.             {
     
285.                 ucAcquCx = 1;
     
286.                 return;
     
287.             }
     
288. 
     
289.             if(ucRecvNowBit == ucRecvLastBit)
       `  z1 u  l* d. E, D. m
290.             {
     3 ]+ ]7 p* [  x! K
291.                 ucRecvTrueCx ++;
     
292.             }
     " L1 f: y) W( H7 Z- Y1 l
293. 
     
294. 
     ! d( l9 ^" g. L1 a0 ]6 H
295.             if(++ ucAcquCx >= 6)
     9 \6 F' M2 \  p( I" C! g( S( A
296.             {
     
297.                 ucAcquCx = 0;
     " E8 V% G" Z& x$ k7 z, A
298. 
     * T7 E/ h: n; |6 _7 P* G# |/ q
299.                 if(ucRecvTrueCx >= 2)
     2 n( b! t! Y8 I5 r9 r
300.                 {
     
301.                     if(ucRecvLastBit == 1)
     & w2 w7 E# I6 \6 W8 Q
302.                     {
     
303.                         ucRecvData |= (1 << ucRecvBitCx);
     
304.                     }
     
305.                     else
     
306.                     {
       `) C+ g0 i% _; J& [, c, A
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     : n, c% L, d* @' y/ H
308.                     }
     
309. 
     
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     1 O4 g5 A* z8 N% R/ p) g6 J+ Z
313. 
     
314.                         if(gsUARTBuff.CheckType == NONE)
     
315.                         {
     + L/ e  [3 N7 P! A
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
317.                         }
     # h& h, I/ p5 x; ~8 z) ]
318.                         else
     
319.                         {
     " m( m# k& k  k' j' i' i8 X' `
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
321.                         }
     
322.                     }
     7 e! J+ x: E9 T7 @& p0 s. B8 }, h
323.                     else
     
324.                     {
     
325.                         ucRecvBitCx ++;
     - M4 R+ y1 L& R' E/ N
326.                     }
     3 |* ~9 D! [" R6 @6 `1 m
327.                 }
     , n- j, x9 {. b: f, A5 c
328.                 else
     
329.                 {
     7 z1 _0 S1 d$ J
330.                     ucAcquCx = 0;
     / A0 v9 ]: u8 M* J% |! S; Z9 F
331.                     ucRecvTrueCx = 0;
     ! ~' e" `0 D* u8 `% Z
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     - q. f; p* z  E% Q: ^" P1 M7 E* r7 `5 h
333.                 }
     
334.             }
     
335.         }
     
336.         break;
     
337. 
     * o0 o! j3 j( `+ ~8 I
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     : w, Z! [/ ^+ S! S
339.         {
       @2 ^3 Z8 r- A3 T
340. 
     
341.         }
     * h- t9 |- m, N$ \6 ~. Y, E" r! d
342.         break;
     
343. 
     ( N$ \4 I: A) c) I
344.         case COM_STOP_BIT_DEAL :                         //停止位
     ) c' ]8 _3 v( i! w8 N; ]
345.         {
     
346. 
     0 o& r/ q/ K- m, N
347.             ucRecvLastBit = ucRecvNowBit;
     
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     ( J: Y( R* U; C1 h  L8 m
349. 
     " {. P# B7 ?2 C
350.             if(0 == ucAcquCx)
     
351.             {
     7 k! Z% s* r: K  K9 w, Y3 q
352.                 ucAcquCx = 1;
     
353.                 return;
     
354.             }
     
355. 
     
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     
357.             {
     
358.                 ucRecvTrueCx ++;
     0 [. p% s1 J. H; _2 H" E) `
359.             }
     
360. 
     
361. 
     
362.             if( ++ ucAcquCx >= 6)
       I- b2 K- r. B% t2 Y4 m
363.             {
     1 x+ a* D0 n% ]4 S' T
364.                 ucAcquCx = 0;
     * {3 e* P7 b' N9 u8 C* N8 P
365. 
     3 `* n& |8 A" \$ c9 Y+ l
366.                 if(ucRecvTrueCx >= 2)
     
367.                 {
     
368.                                       ucRecvTrueCx = 0;
     
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                     {
     ! Z/ K" ?  z0 S/ O* a
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     3 E9 ?2 Z. s4 [- a1 ?; F& F
372.                         gsUARTBuff.Recvlength ++;
     
373.                     }
     
374. 
     9 z/ N7 a2 ]% ]' U: f' m; o+ y
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     & Q; o) @, a' |! q9 O) y' E7 Z
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     ) Z( n7 d  j& L6 E$ i& [" P  v
377.                     TIM6->CNT = 0;
     
378.                 }
     ; q( I% Z6 P+ r  h
379.                 else
     
380.                 {
     % t# t3 U5 H* ~7 H
381.                     ucRecvTrueCx = 0;
     
382.                 }
     & D6 I3 ?8 s& A% R& }+ ]8 W% ~1 O
383.             }
     * r* Y, b4 K" `4 O% r0 t
384.         }
     
385.         break;
     9 Q# B+ X2 l, }
386. 
     
387.         default:
     
388.             break;
     
389. 
     $ O1 C  G. u% |$ ^) ?+ S
390.         }
     
391.     }
     
392. 
     , H3 ^7 e/ K$ p% l5 s
393. }

复制代码

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

4、 最优实现

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

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

1. #include "UartSet.h"
   6 G  r- Y3 l" L
2. #include "string.h"
   
3. 
   
4. typedef enum
   ) y8 l3 [8 h: p9 I4 b6 m. R/ p6 ?! W
5. {
   
6.     TimeRecvStartStep1 = 0,
   
7.     TimeRecvStep2 = 1,
   7 k! w0 Y0 c, d% y9 s3 j
8.     TimeRecvStep3 = 2,
   ; \9 Q+ _2 H1 L/ m3 U$ N$ j+ ]5 z
9.     TimeRecvStep1 = 3,
   
10.     TimeSendStep = 4,
    
11. 
    $ {6 `/ c" y" f7 [2 r6 N4 _
12. } TimeStep;
    8 W2 X3 K1 V, T; ^
13. 
    ) [+ r6 Y; k, T
14. uint16_t TimeSet[5];
    
15. 
    + z+ Q/ }! J, Y* k
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
    
19.     {149, 29, 29, 251, 311  },   //9600
    . G% W0 i% Y* J2 i3 q$ X
20.     {0, 0, 0, 0, 0    },         //预留
      ^  Z- @6 ?* T) G, N) ?! G  W
21. };
    ! l- }6 z! p' P/ s  W9 C5 l
22. 
    
23. UART gsUARTBuff;                //定义串口
    / L8 D7 z0 ]8 ]$ w5 C  j4 p8 I
24. 
    8 s2 y: b8 k( G" y& A- ]
25. uint8_t ucRecvData = 0;         //每次接收的字节
    ; A- Z2 E2 x3 @8 h
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    & L1 x8 H; [  x0 h( N3 b
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    ) i$ G" L2 c6 c
28. uint8_t ucSendBitCx = 0;        //发送位计数
    - z" L/ y" F8 ?7 U) u
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    % u5 a0 ^! h+ r( P& G5 v- F/ V2 f/ @
30. 
    
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    
32. 
    3 Q/ C0 T5 b! J5 P
33. 
    ( G7 p5 F% {. Q! A4 h
34. TIM_HandleTypeDef htim6;
    3 T& r0 z/ b+ m- a: ]7 h4 N+ |
35. 
    
36. void MX_TIM6_Init(void)
    
37. {
    
38. 
    
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    
40. 
    
41.     htim6.Instance = TIM6;
    0 V! f# j& F9 g5 u6 X8 J
42.     htim6.Init.Prescaler = 15;
    0 |8 w6 _' ?  d0 N$ ?- v* s7 Q
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
46. 
    
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    ( ^6 V: S$ l" e7 t
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    ! K% C; p; Y! }. |; U$ x) e5 E
49. 
    - _7 D- v7 s% G  Y+ g
50.     HAL_TIM_Base_Init(&htim6);
    3 b; S0 Y+ Q2 A: v0 ^- v. s7 c$ C
51. 
      F  R* r  X' B- ~. P2 M0 S
52. }
    
53. 
    
54. 
    
55. void UART_GPIO_Init(void)
    
56. {
    ; H6 }5 w* N9 H3 u( B) P
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    & R. j0 C4 @) e- n
58. 
    
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    7 O0 W5 T4 T' R; J* j, \# i8 X
60. 
    5 L/ A! C9 Y( n# Q( M! I7 l
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    8 d  I) y1 h9 s7 s, r( x' q3 r
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    - W6 k+ S. l8 S$ K/ C8 Z# E+ ]
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    + N5 Q" I* s/ f; W
66. 
    
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    : ^- \7 P1 A- _8 Y8 R; v
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    $ J& x1 N8 t3 f/ S! r
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
71. 
    1 y) l! D  J+ J+ J. O9 Q
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    ' H* w+ h8 b/ N: ]6 [. a  O
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
74. 
    
75. }
    
76. 
    ! ^$ v  y0 ^2 h% K" l- F
77. 
    
78. /*******************************************************************************
    
79. * @FunctionName   : UART_Init.
    2 L! ^7 A# Q7 T6 r" b
80. * @Description    : 模拟串口结构体初始化.
    
81. * @Input          : None.
    $ i7 o/ t8 y( E: S% q$ z
82. * @Output         : None.
    
83. * @Return         : None.
    $ S# d' ^; J* d
84. * @Author&Data    : MrShuCai  2019.4.11.
    
85. *******************************************************************************/
    4 V6 Y. [4 O+ D
86. void UART_Init(void)
    
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    & H2 v* h; ?1 `! E# [! j/ y
89.     gsUARTBuff.UartMaxLength = Uartlength;
    9 N$ s( q; @# A. A! H. z
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    & i, G- R- ~( _  r# ^. i
91.     UART_GPIO_Init();
    ) a8 ~+ q+ a# i+ D( N( D( t- v
92. 
    " H+ n5 u0 G2 W1 [: z
93.     if(BaudRate == 1200)
    
94.     {
    
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    
96.     }
    
97.     else if(BaudRate == 2400)
    
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    
100.     }
     / q1 k5 S7 o/ g8 `" N# m7 W
101.     else if(BaudRate == 4800)
     / n- F  T# L' I# z& \$ h
102.     {
     1 X% L- K, H# z* i! p
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     
104.     }
     * u9 s- b9 ]/ |9 [$ T4 e
105.     else if(BaudRate == 9600)
     + m0 c6 T7 H3 i. V3 Q( S5 q
106.     {
     
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     9 t, N& e$ V, f1 A: l
108.     }
     
109.     else
     
110.     {
     
111. 
     ' E) c. z5 }. M8 L9 k
112.     }
     / c/ ]; M9 o9 F  h
113. 
     9 D# P6 w3 O' P5 O+ X, b" n
114.     MX_TIM6_Init();
     
115. }
     
116. 
     3 K& T) I" v" Z% k
117. 
     # V# S& V% ~5 v% [* x: Y
118. /*******************************************************************************
     
119. * @FunctionName   : UART_Send_Data.
     
120. * @Description    : 模拟串口发送数据接口.
     $ k; @5 C% J6 l2 J
121. * @Input          : None.
     
122. * @Output         : None.
     ; Q- g1 A. x/ L0 A6 G$ v
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     $ @1 C* K$ K1 k9 Y9 s1 s+ g
125. *******************************************************************************/
     
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     
127. {
     . Q) ?) m- B9 q6 q
128.     gsUARTBuff.Sendlength = size;
     
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
130.    
     
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
132.         {
     3 A- u! v) @9 o- z' i# }5 O4 n8 q% W
133.             gsUARTBuff.TxEn = 1;
     % B% r. q/ z4 Q1 v
134.             gsUARTBuff.RxEn = 0;
     
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     : v# @6 ^( c' V  j3 R" `
136. 
     
137.             TIM6->ARR = TimeSet[TimeSendStep];
     & {  T6 G. Q" _% m% V, n" x$ ?# i% x
138.             TIM6->EGR = TIM_EGR_UG;
     & C* B+ ~: t. V8 j6 U" @
139. 
     ; E: g, i$ E$ C$ e
140.             HAL_TIM_Base_Start_IT(&htim6);
     
141.         }
     / L, z. }2 E7 }7 l: z* \
142.       
     
143. }
     
144. 
     ' V/ w) o& f" W
145. 
     
146. /*******************************************************************************
     ( Y8 c& E  K) R
147. * @FunctionName   : EXTI4_15_IRQHandler.
     ) @7 \/ F  d; U" F7 s! e2 @
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     
149. * @Input          : None.
     3 x- }& m9 S+ |! ^1 h6 G+ ^$ F
150. * @Output         : None.
     
151. * @Return         : None.
     
152. * @Author&Data    : MrShuCai  2019.4.11.
     
153. *******************************************************************************/
     8 N- ]* B2 g/ ~
154. void EXTI4_15_IRQHandler(void)
     5 g5 O! B! M0 n! {* w2 _( T
155. {
     
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     0 k, O/ [: i& t7 O" s" ?3 {
157.     {
     & j. o' m9 |; O1 p+ ]+ R" p$ n
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
159. 
       b0 o- [. p9 R' [) J: }' q2 x. c
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     0 |1 b) s8 n1 e5 w$ |, G
161.         {
     3 w) P6 Q' \2 O& I+ p
162.             gsUARTBuff.RxEn = 1;
       `* k/ d! J, f) Q. |6 E& }( v
163.             ucRecvData = 0;
     ( n3 D7 `7 h: c, S% w1 Z
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ' z5 ~- h9 v. [& @
165. 
     
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     
168.                       EXTI->IMR &= ~(0x10);
     
169.                       EXTI->EMR &= ~(0x10);
     6 m2 W4 O% r6 B  J8 v
170.             HAL_TIM_Base_Start_IT(&htim6);
     ; G3 E$ _& O1 f0 h6 p3 Q
171.         }
     
172.     }
     
173. 
     + U- f$ H0 F6 {+ M6 V5 V
174. }
     
175. 
     & b. m/ R8 f  z. h
176. 
     
177. /*******************************************************************************
     ; L* w. f5 P- s, ]0 }2 ?: k1 _( }
178. * @FunctionName   : BitValueChk.
     
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     . v! }* v; K6 ]
180. * @Input          : n 采集记录的位值.
     * s3 ?/ q* n; a2 H2 ~0 _$ A/ V
181. * @Output         : BitValue.
     
182. * @Return         : BitValue.
     
183. * @Author&Data    : MrShuCai  2019.5.1.
     
184. *******************************************************************************/
     5 k/ z; B7 ]0 ~9 W% \* o) Q! v
185. uint8_t BitValueChk(uint8_t n)
     
186. {
     5 v0 O- ~3 S! l% j
187.     uint8_t BitValCx = 0;
     : r; _: h# x2 X+ Z
188. 
     
189.     for(BitValCx = 0; n; n >>= 1)
     
190.     {
     
191.         BitValCx += n & 0x01;
     9 C$ H6 O8 h- w# s& ]
192.     }
     , ]/ B+ A' `2 I; U# H. Q  r* N6 Z
193. 
     4 H3 n7 E: _8 \! ~! f$ t, @
194.     return (BitValCx < 2) ? (0) : (1);
     
195. 
     , B# g, V7 V; {* z3 x& z
196. }
     0 a: o8 ?1 P2 z' \8 e4 r$ N: ~
197. 
     * I# p7 `. Y1 Y/ E1 a# Z" o# A
198. /*******************************************************************************
     
199. * @FunctionName   : TIM6_IRQHandler.
     
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     , z! I: C, F) B7 G2 [
201. * @Input          : None.
     
202. * @Output         : None.
     
203. * @Return         : None.
     
204. * @Author&Data    : MrShuCai  2019.4.11.
     
205. *******************************************************************************/
     
206. void TIM6_IRQHandler(void)
     
207. {
     
208. 
     : K  j) z, S6 v: [! n/ S
209.     HAL_TIM_IRQHandler(&htim6);
     9 G" W7 l" a; ^4 y. W9 M
210. 
     : D6 @4 J1 C# S" K5 C
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     * K, A, G% u% O
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     ' d  e5 ?$ w" E( u7 [+ R
214.         {
     : w: L  p$ i6 p7 M# t
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;
     ) o7 {: [! {8 N7 b. m- K8 T  w
219.             ucSendBitCx = 0;
     - C$ R# u0 ^8 q/ W  ~
220.         }
     / Q; k, Z3 I+ R2 g
221.         break;
     
222. 
     
223.         case COM_DATA_BIT_DEAL :
     
224.         {
     5 i5 n1 F; I3 O+ {( T# L$ H8 ?& e
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     % c8 I/ c7 Q, I6 |- o
226. 
     0 P! ?" w) e8 ?* ]- m& c* H
227.             ucSendBitCx ++;
     
228. 
     
229.             if(ucSendBitCx >= 8)
     
230.             {
     
231.                 if(gsUARTBuff.CheckType == NONE)
     
232.                 {
     
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     / s8 f# w; E5 X+ t. X
234.                 }
     
235.                 else
     ! `0 s3 I" @1 e. }3 a# L
236.                 {
     ( u: b7 M" h4 M4 [( j: J
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
238.                 }
     & b) K8 H6 K- V& x9 _% s* p$ m! `0 L
239.             }
       C1 ]7 y! @2 W: t* {) @
240. 
     " t5 h, {: m! w# ]
241.         }
     / Z1 R/ l9 z1 n' `
242.         break;
     
243. 
       p* Y# L' w" K. H. }7 M/ v
244.         case COM_CHECK_BIT_DEAL :
     
245.         {
     
246. 
     ) ~5 W' m: D/ A1 F
247.         }
     4 L& z' O6 q+ \, @+ S' b. K3 g
248.         break;
     3 N7 ?8 a. n, n. B1 w* X5 x; U
249. 
     
250.         case COM_STOP_BIT_DEAL :
     
251.         {
     5 y0 r$ a$ {$ I1 c
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     ; a) H: s6 E3 @+ |  e" L
253. 
     3 m. X2 V. o/ D5 f. V" H
254.             ucSendBitCx = 0;
     
255. 
     
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
257.             {
     
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     
260.             }
     % p- C" H* ^' P6 K/ H0 B
261.             else
     
262.             {
     
263.                 ucSendLengCx = 0;
     
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
265.                 gsUARTBuff.TxEn = 0;
     ( E7 f8 B) `* v8 i$ W1 E2 G
266.                 gsUARTBuff.RxEn = 1;
     
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     
268.                               EXTI->IMR |= 0x10;
     & `8 D* m2 {. A8 k+ Y
269.                           EXTI->EMR |= 0x10;
     - h0 {; H! _) f* ~/ V- v- A0 X: V  J4 k
270.                 TIM6 ->CNT = 0;
     
271.             }
     
272. 
     
273.         }
     
274.         break;
     
275. 
     & h- O2 L' r8 _$ O7 F  x* G4 O
276.         default:
     ' x4 [+ Q- L0 Q& M8 g
277.             break;
     + r5 ]; P$ t1 y
278. 
     
279.         }
     
280.     }
     9 [' a% M/ N3 @+ P+ g
281. 
     
282. 
     * v( T% S7 y* p* u. ^' e7 ?- S# `
283.     if(gsUARTBuff.RxEn == 1)
     ' r0 G4 Q8 [; s7 L/ F- U6 K
284.     {
     
285.         switch(gsUARTBuff.UartStat)
     
286.         {
     
287.                     case COM_START_BIT_DEAL :
     ! ~+ p9 _5 x% D8 u9 G4 {
288.                     {
     1 j; J6 \+ o* M( _9 z- z) {
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     5 z. r; \" ]/ ?- R' H6 |  W8 M9 E8 P
290. 
     
291.                             if(++ ucAcquCx >= 3)
     
292.                             {
     
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     * s( A. r$ J8 M. Y; S. ~* t, Z% q
294.                                     {
     ( y7 q6 n, o" h) O2 t7 p0 K
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     & V" ?  e+ u6 q* F
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     
297.                                     }
     3 S* a9 e7 v) S4 N) b+ F! H& L0 }
298.                                     else
     " ~0 U9 M! A3 H% j6 H& }" S
299.                                     {
     . U3 v! C2 f6 p9 B! y" g
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
301.                                     }
     # k! w8 m0 R- u2 k* r
302.                                     
     2 W- B% Y0 S& c3 W+ V; H
303.                                     ucRecvBitBuff = 0;
     9 O; o8 Q& j5 P0 m, {3 D
304.                                     ucAcquCx = 0;
     . u' D) r  O/ p# |: V
305.                             }
     9 c9 p' c6 n0 @, y! c4 J1 R- G
306.                             else
     
307.                             {
       u1 k9 t- T5 e1 j: k' L7 ~
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     / O) l0 o& b, S" ^+ _+ I
309.                             }
     
310. 
     
311. 
     ) i7 i% n/ }' T( D5 C
312.                     }
     
313.                     break;
     
314. 
     
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     
316.                     {
     6 a* x7 D' b3 b+ u* _3 D/ G# I! o
317. 
     2 s  S/ M0 ?- ^8 e
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     , E, Z" K# ]- k1 m6 h6 Y
319. 
     4 {, Y1 Q' A7 q. }. c; l( ~( m4 `- D
320.                             if(++ ucAcquCx >= 3)
     
321.                             {
     0 q0 u4 E' {! |! w
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     
325.                                     {
     
326.                                             ucRecvBitCx = 0;
     
327. 
     & q+ H$ {( j0 q8 W& _9 H! z
328.                                             if(gsUARTBuff.CheckType == NONE)
     1 E3 \9 O5 H* \7 z9 {9 {
329.                                             {
     $ p. u2 b/ N; t
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
331.                                             }
     
332.                                             else
     
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
335.                                             }
     
336.                                     }
     
337.                                     else
     & T/ b  Q8 _& o& b. m
338.                                     {
     
339.                                             ucRecvBitCx ++;
     . h/ M( m8 s! {8 W2 j
340.                                     }
     8 q7 ^6 J9 H) X2 v. a: Y
341. 
     3 f$ m2 [* z% w+ n  n, _7 T
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
343. 
     . O0 O0 }& [. A% n" z  v, d; H" N
344.                                     ucAcquCx = 0;
     9 e. H  h: v0 Y( z+ h7 J
345.                                     ucRecvBitBuff = 0;
     4 H, j5 H4 t" d1 D" U! g
346.                             }
     
347.                             else
     2 Q: K7 v) ~9 s# \6 h, D
348.                             {
     ; T% h3 C  Q1 M; Q8 G
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     + l1 O$ I! E8 o* O: Y
350.                             }
     
351.                     }
     0 F! `& `3 \) g! c3 T6 g" S
352.                     break;
     1 f2 G5 @8 Q/ N9 J$ c) x
353. 
       i6 f* b6 D3 |3 G% h+ p- {' Y
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     / p6 t# u" @+ G3 I0 W$ t% U( E
355.                     {
     
356. 
     , r& B9 _7 Q, K
357.                     }
     
358.                     break;
     , |# I. f& C5 l) s7 _3 F
359. 
     " x+ z, v4 X7 c; g7 X' [' c
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     ) d2 a3 E; b. S( b- z6 @
361.                     {
     
362. 
     0 t1 o# A. ]' a4 T2 x8 ~' l1 \
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     6 A! Q' O5 a6 A
365.                             if( ++ ucAcquCx >= 3)
     
366.                             {
     
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     : a  R- F- T+ M- P1 x
368.                                     {
     + O1 S/ i, F: J
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                                             {
     * @' X$ N- F! L7 w' ?8 @  K- a, b
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     ) c- r8 M  [" S! Y( f
372.                                                     gsUARTBuff.Recvlength ++;
     
373.                                             }
     
374. 
     ; T3 [8 W* J9 B
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     
377.                                             
     
378.                                             EXTI->IMR |= 0x10;
     
379.                                             EXTI->EMR |= 0x10;
     & a, E; N# P7 E3 a9 ?- e: y
380.                                             TIM6->CNT = 0;
     
381.                                     }
     " e8 {! _, t/ `$ z
382.                                     else
     0 g6 e9 D; R2 M5 e6 E' V
383.                                     {
     
384.                                             ucAcquCx = 0;
     
385.                                     }
     
386.                                     
     
387.                                     ucRecvBitBuff = 0;
     / A& X, M: G2 _& U( ~4 o: J" ^& O
388.                                     ucAcquCx = 0;
     
389.                             }
     : t; D  u8 E+ M$ X
390.                             else
     
391.                             {
     
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
393.                             }
     
394.                     }
     
395.                     break;
     , C0 p4 y- u" S5 p! I& g
396. 
     
397.                     default:
     $ S- b7 D  D. d4 E, C
398.                             break;
     # s$ z4 k  q) J' X. E% ^% e4 E3 n+ b  |
399.                     }
     
400.     }
     
401. }

复制代码

9 Y& b$ W* J; ]

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

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

$ [; j1 a; q  X3 h; v