一、设计用途：

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

二、硬件电路：

' u" G7 {/ {6 a( P, z

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

; Q# L, T8 Y" J4 \6 m* K+ W

5 _. g8 T, Z$ S! Q) i- k

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

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

7 s- [% e& l* r9 I( ]
" v, R; e2 s& ~6 q$ E

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

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

硬件串口的噪声处理：

7 A' Y0 J! J( \, j5 x# R

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

3、 实现方式选择

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

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

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

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

自写第一种实现方式：

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

1 I$ p3 b+ @: V

1. #include "UartSet.h"
   8 l# j9 |" Z: ?( Y1 @8 o
2. #include "string.h"
   8 t. n- c1 Z4 t3 }" W2 F
3. 
   5 t" N6 Y! P7 L, ~7 y
4. uint8_t ucRecvData = 0;         //每次接收的字节
   0 w' e9 {- ]3 T+ \7 M
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   . ]; _* ]" X: i1 s3 J! k4 ~
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   
7. uint8_t ucSendBitCx = 0;        //发送位计数
   
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   7 h; E" x0 }1 A5 R' U+ S
9. 
   5 @! V: I9 }2 g; d' N
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    & ~& M, E+ p6 E! w, @8 S* u; j6 t5 e
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    6 @" W% }1 i  _3 F5 U+ t3 Q
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    
13. 
    
14. uint32_t Prescaler = 0;
    
15. uint32_t Period = 0;
    
16. UART gsUARTBuff;               //定义串口
    
17. 
    
18. TIM_HandleTypeDef htim6;
    
19. 
    
20. void MX_TIM6_Init(void)
    
21. {
    2 X% i1 r& Q2 `# |/ v4 @( c) s. i
22. 
    ) Y7 f# a4 K* x; R) {
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    ; b* P* f7 Q$ N1 Q1 m* l% o+ f
24. 
    
25.     htim6.Instance = TIM6;
      w6 ^7 r+ {& _# {1 ?( r- s
26.     htim6.Init.Prescaler = Prescaler;
    
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    2 S. |# T2 H: x* r/ ~- ?
28.     htim6.Init.Period = Period;
    # Z9 R9 M$ u; Z# b+ ?% `  r  f
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
30. 
    & m! I# j; |1 |9 Y% |9 i
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    / z! \3 G0 |1 A- V, k8 a
33. 
    
34.     HAL_TIM_Base_Init(&htim6);
    
35. 
    4 a) E( B9 I* t3 _$ _7 j( o
36. }
    
37. 
    
38. 
    & o& Y5 D) u+ t% Z5 b
39. void UART_GPIO_Init(void)
    
40. {
    . t1 G& Y1 g5 g9 j' K) ~
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
42. 
    & T, P1 p9 X* [
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    # `% P5 O& Q* j2 S  z9 z4 K
44. 
    4 C. T: Y2 P) O# v
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    " ]0 R; a* ?; c( a0 M5 b
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;
    2 B# z3 h1 a" v4 D
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    0 w# M" Y* s* G! r. h0 m- w
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    # q& Q* i) q, L1 ], n! |
55. 
    
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    / {' J6 U5 t/ V/ w* W, d% X' s3 e
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    5 R: R9 e- B" a. t- h2 `* Q3 A
58. 
    
59. }
    $ f1 }; F5 w7 g. v# b
60. 
    
61. 
    
62. /*******************************************************************************
    
63. * @FunctionName   : UART_Init.
    8 L$ c$ ^& a) H( V
64. * @Description    : 模拟串口结构体初始化.
    
65. * @Input          : None.
    # Z# F+ Q& h& D' k+ M
66. * @Output         : None.
    * I8 v4 K, b1 |/ @' c) P% J6 `9 K9 r
67. * @Return         : None.
    * I4 G: H! R6 I
68. * @Author&Data    : MrShuCai  2019.4.11.
    
69. *******************************************************************************/
    8 v0 q% m3 M1 w# O# `. [+ c" ~' A/ {0 o8 g
70. void UART_Init(void)
    : u% g2 v/ g: s& i& y
71. {
    
72.     gsUARTBuff.CheckType = NONE;
    
73.     gsUARTBuff.UartMaxLength = Uartlength;
    
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
75.     UART_GPIO_Init();
    
76. 
    ( R* Y. O) |. x0 S8 x
77.     if(BaudRate == 1200)
    5 M. x( `5 I5 _+ }$ e& O+ E
78.     {
    
79.         Prescaler = 15;
    
80.         Period = 623;
    
81.     }
    
82.     else if(BaudRate == 2400)
    
83.     {
    4 v& G9 O0 H5 N
84.         Prescaler = 15;
    / Z! p; V2 J6 ]; q, C
85.         Period = 207;
    : w" n2 O8 j  |& w# [0 J
86.     }
    
87.     else if(BaudRate == 4800)
    $ B/ K- p3 L. W8 Z
88.     {
    
89. //        Prescaler = 15;
    5 Q" {( z/ o7 q4 z/ I
90. //        Period = 50;  //9600
    
91.              Prescaler = 15;
    5 w* E: W! W- U  x; j* p
92.              Period = 103;
    : D- r/ m/ Q: {& H8 a
93.     }
    4 g% ]8 a0 W  N' ?7 d
94. 
    , i% y5 ^9 J* q7 D6 S+ s
95.     MX_TIM6_Init();
    . ~" f; o6 `7 i
96. }
    ! a2 V% A. @; m8 ?, O
97. 
    $ e- F. b5 O, Y8 {
98. 
    
99. /*******************************************************************************
    
100. * @FunctionName   : UART_Send_Data.
     
101. * @Description    : 模拟串口发送数据接口.
     8 D$ U. g" C1 V6 `5 e
102. * @Input          : None.
     " C# b+ @& {7 A  b3 V# L% T$ o5 Y
103. * @Output         : None.
     ' {  ?1 E( q! _
104. * @Return         : None.
     
105. * @Author&Data    : MrShuCai  2019.4.11.
     # d& P: q0 j  g- C& v# p' s
106. *******************************************************************************/
     3 p: ^3 N, F' |5 {% N: ?
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     % Z5 A: O: D' X' `4 p+ M4 V
108. {
     . y- N) Z% i6 ]
109.     gsUARTBuff.Sendlength = size;
     : R8 G7 [7 T* ~. t- z5 M4 r
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     / Y0 J6 {- A" q7 V  j9 v
111.     gsUARTBuff.TxEn = 1;
     : Q% ]3 r! C/ p* \0 L( P% O3 o6 T
112.     gsUARTBuff.RxEn = 0;
     ! w8 ~' f! G8 v8 t( ?
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
114.     HAL_TIM_Base_Start_IT(&htim6);
     
115. }
     * v- j5 ?3 H; j9 w
116. 
     
117. 
     : Q0 J2 }* P% r% w- G' i4 u
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     5 {. w: d6 m) I
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     
121. * @Input          : None.
     
122. * @Output         : None.
     7 D. E. u+ @/ T0 ]6 t, f4 T0 \
123. * @Return         : None.
     % w; F1 e4 ^+ v' l
124. * @Author&Data    : MrShuCai  2019.4.11.
     & a9 K5 \. J. n+ ]% w
125. *******************************************************************************/
     
126. void EXTI4_15_IRQHandler(void)
     9 X( L4 C5 x! @& |
127. {
     2 O2 k( \: ^2 a4 [
128. 
     5 X7 S# E2 E# `9 z' J7 g
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
130.     {
     0 i! W$ N1 N/ ~( M) \. ]
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
132. 
     
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
134.         {
     ' P. o: P, r& W5 @* E0 V
135.             gsUARTBuff.RxEn = 1;
     " j# @3 o  q' v* T7 D  Q' v1 w) F
136.             ucRecvData = 0;
     
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     
140.     }
     
141. }
     
142. 
     
143. /*******************************************************************************
     ) X$ g7 ^/ T3 U+ y& N. D
144. * @FunctionName   : TIM6_IRQHandler.
     
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     
146. * @Input          : None.
     6 \) x. t7 }3 y& F
147. * @Output         : None.
     
148. * @Return         : None.
     9 I# @" F% {5 n: l
149. * @Author&Data    : MrShuCai  2019.4.11.
       m3 v3 x1 u( u( O7 J# q7 @
150. *******************************************************************************/
     3 L/ b3 R2 u, t6 ]4 Z/ ]
151. void TIM6_IRQHandler(void)
     - L3 {6 M  r' \* A" y
152. {
     6 g- G+ J; r9 u2 `. Y% }) _" N
153.     HAL_TIM_IRQHandler(&htim6);
     
154. 
     
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     
156.     {
     
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     7 T  g3 O! d( W+ Z# s( `/ g
158.         {
     0 m% ?' k4 q0 N0 Y2 K5 J* L8 v
159.         case COM_START_BIT_DEAL :
     
160.         {
     
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     
162. 
       X5 z9 Z4 [/ m' C: N* Q
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     3 Q; [2 Q1 _  y# y5 L( {5 k
164.             {
     
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     5 X% L7 {+ k% _; e( [
166.                 ucAcquCx = 0;
     5 _2 I. e& I! ~$ i* `' i4 L' r
167.                 ucSendBitCx = 0;
     " p7 n# p1 R9 f. g, d( M( i+ C! n$ F
168.             }
     
169.         }
     # Z  w: v  H1 v/ C! z
170.         break;
     ) F7 x* y$ c0 N9 N; G
171. 
     
172.         case COM_DATA_BIT_DEAL :
     ) p% D( H  d3 y' i1 `$ v
173.         {
     1 [% J$ N. d( @9 L7 D/ ]
174. 
     - c& {% B# @2 ^
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     
176. 
     1 m" r- u3 B, w! y  C, O
177.             if(++ ucAcquCx >= 6)
     
178.             {
     
179.                 ucAcquCx = 0;
     
180.                            
     " o" e* ^; \2 `9 }& h
181.                 ucSendBitCx ++;
     # w8 w# {* N4 P9 J8 u
182. 
     8 U6 `/ c1 O" i9 D& _! U
183.                 if(ucSendBitCx >= 8)
     
184.                 {
     
185.                     if(gsUARTBuff.CheckType == NONE)
     
186.                     {
     
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     9 z1 ^5 N. a# ]" R: Y0 B
188.                     }
     & I7 R, l/ k& _3 _# |- v5 k
189.                     else
     ! x7 k# c2 g) }' }+ C
190.                     {
     ) p& G) ~# i3 E, M3 s9 J( i
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
192.                     }
     : O' v$ q/ P! y2 e& W
193.                 }
     
194.             }
     % x! r+ A4 n/ D
195.         }
     
196.         break;
     
197. 
     
198.         case COM_CHECK_BIT_DEAL :
     
199.         {
     $ B" `* [& N- X/ D- ~
200. 
     
201.         }
     7 R3 Y: j/ ~# V
202.         break;
     
203. 
     6 T  @+ g+ @9 I+ C1 ~
204.         case COM_STOP_BIT_DEAL :
     & f! t' ?1 f; Z6 \: t' ]
205.         {
     ' o( z( y; `# I7 B
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
207. 
     % z, T4 q5 I! ]( G
208.             if(++ ucAcquCx == 7)
     0 y$ [6 [& n: ]5 M
209.             {
     
210.                 ucAcquCx = 0;
     8 x! P- w; N3 m; R' c% U
211.                 ucSendBitCx = 0;
     
212. 
     ) q7 u- A+ `6 D. R- X# O9 h, T
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     9 m6 P: i3 k7 h
214.                 {
     
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
216.                     ucSendLengCx ++;
     7 F6 Y8 g0 n; s( X# S1 a
217.                 }
     
218.                 else
     " p2 v0 y6 p5 M
219.                 {
     
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
222.                     gsUARTBuff.TxEn = 0;
     
223.                     gsUARTBuff.RxEn = 1;
     3 I3 M  ?. s/ b% A% c& |, {, s
224. 
     
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     
226.                     TIM6->CNT = 0;
     
227.                 }
     9 l4 \2 _* X4 m9 W/ h9 N4 _
228.             }
     
229.         }
     
230.         break;
     6 S5 b* F. X3 r4 Y$ |9 H
231. 
     : S" X  F( J- W
232.         default:
     * z3 [; F; @7 t
233.             break;
       ^& y% P1 _' W/ }" H4 W$ ^# }8 o
234. 
     4 P( J$ _- ?& A4 S' R1 q$ k
235.         }
     1 u0 F% L0 T. _4 X3 p
236.     }
     & D  g3 O2 @* C; b+ ]* c
237. 
     
238. 
     
239.     if(gsUARTBuff.RxEn == 1)
       K8 u: N7 N' v, g9 z
240.     {
     " V! S, x4 x0 ~3 a
241.         switch(gsUARTBuff.UartStat)
     : l+ A8 F5 D- V" c  E/ b6 _7 p+ ?
242.         {
     
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     ) V+ [/ z) ~6 T/ s
247. 
     $ i3 R2 \8 V: d" P# c' a% q
248.             if(    ucAcquCx == 0)
     1 @. J3 x: C7 G6 X- ]0 O
249.             {
     8 R. o+ T5 P1 S% h# B! C
250.                 ucAcquCx = 1;
     
251.                 return ;
     
252.             }
     ; A# l. j; {; x! Z+ n/ {$ b
253. 
     , ]3 f, i; d* l6 b: V8 D
254.             if(ucRecvLastBit == ucRecvNowBit)
     
255.             {
     ' t5 [' l" f9 P1 [. t7 [8 l7 W$ E
256.                 ucRecvTrueCx ++;
     
257.             }
     : N4 `( P& S* n/ |- Y& \. u
258. 
     
259.             if(++ ucAcquCx >= 5)
     $ Y, x9 ^6 v, V
260.             {
     
261.                 if(ucRecvTrueCx >= 2)
     
262.                 {
     
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     ) e: [1 k7 \/ L
264.                     ucAcquCx = 0;
     
265.                     ucRecvTrueCx = 0;
     " g0 b% B7 s9 e( Y! P, }) [6 x' Q
266.                 }
     
267.                 else
     - W: d: k6 H3 H
268.                 {
     
269.                     ucAcquCx = 0;
     
270.                     ucRecvTrueCx = 0;
     ) i9 J4 Z+ ~9 E
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
272.                 }
     
273.             }
     . z: n( f5 j0 Y9 O0 ]
274.         }
     4 d# d3 H  U# ^
275.         break;
     " h( V/ j7 {2 B" I( d) i0 B- X
276. 
     6 i: k( l8 S5 M
277.         case COM_DATA_BIT_DEAL :                         //数据位
     - j) _- `; y$ A! Z5 {' G
278.         {
     / ~9 C7 b8 Y1 T
279. 
     
280.             ucRecvLastBit = ucRecvNowBit;
     * z: z* {$ N, M4 K& U
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     
283.             if(0 == ucAcquCx)
     
284.             {
     & ?. e$ |  I' Y
285.                 ucAcquCx = 1;
     ' D: x  y+ \" t$ t. E% b. ]" b
286.                 return;
     
287.             }
     
288. 
     
289.             if(ucRecvNowBit == ucRecvLastBit)
     # i% O6 L8 R) r+ o7 ?. K
290.             {
     6 l2 p; |  V( Q3 u5 b* a
291.                 ucRecvTrueCx ++;
     
292.             }
     
293. 
     
294. 
     : o! o6 }: Q1 v; P
295.             if(++ ucAcquCx >= 6)
     
296.             {
     * j6 Z# |0 @% i- v- @
297.                 ucAcquCx = 0;
     
298. 
     
299.                 if(ucRecvTrueCx >= 2)
     
300.                 {
     $ ^% Z% l5 Y" z$ @4 t% g0 `% z  B4 f
301.                     if(ucRecvLastBit == 1)
     1 s6 Q: L3 V) F0 U: q
302.                     {
     " I2 z9 m3 w; z2 y. D% h
303.                         ucRecvData |= (1 << ucRecvBitCx);
     ) E% C" K1 t+ ~/ O* M$ V
304.                     }
     $ [! B7 h( w0 z. q! e5 v$ Z
305.                     else
     
306.                     {
     
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     
308.                     }
     
309. 
     + b; s+ Q9 a" `. w
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     
313. 
     
314.                         if(gsUARTBuff.CheckType == NONE)
     % i# h4 f0 W9 n# ^4 b
315.                         {
     ' k3 u; L8 G7 Y5 c0 h% D% R& L
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
317.                         }
     
318.                         else
     4 r5 O& y6 x4 @+ u$ n: H
319.                         {
     
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
321.                         }
     ( d7 K; M) X* v- `' a
322.                     }
     
323.                     else
     2 ^3 e! U/ }7 K5 [, x
324.                     {
     & A" ~! J8 B9 v; d* O/ @
325.                         ucRecvBitCx ++;
     * X9 K1 L( R% E; e  `9 L
326.                     }
     
327.                 }
     " _& ~1 J% A) i
328.                 else
     ! u: R2 R" y$ E5 _
329.                 {
     
330.                     ucAcquCx = 0;
     
331.                     ucRecvTrueCx = 0;
     / S  t1 e3 E% n, h+ a# g
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     5 i/ z* E: P9 o
333.                 }
     
334.             }
     
335.         }
     
336.         break;
     
337. 
     
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     # {" Y6 x# M: u
339.         {
     2 k0 g3 u' W- ]* y" E$ V
340. 
     : T" v2 x+ c6 A3 K! w8 w' Q; M
341.         }
     
342.         break;
     
343. 
     
344.         case COM_STOP_BIT_DEAL :                         //停止位
     
345.         {
     $ X. u# ?/ c" g# p: B
346. 
     
347.             ucRecvLastBit = ucRecvNowBit;
     
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
349. 
     
350.             if(0 == ucAcquCx)
     9 D' e1 a0 w" T# I& M, ^3 k
351.             {
     
352.                 ucAcquCx = 1;
     2 J8 W: p! |, T* E9 G$ Z; T9 D
353.                 return;
     8 x/ P9 r3 e; \1 \
354.             }
     
355. 
     
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     
357.             {
     
358.                 ucRecvTrueCx ++;
     - |& K4 |: N& f: S2 {
359.             }
     
360. 
     1 h2 J9 Y/ T7 }0 ]
361. 
     
362.             if( ++ ucAcquCx >= 6)
     6 J  {) j6 ]& ~# N" P5 H6 t) m0 d
363.             {
     
364.                 ucAcquCx = 0;
     
365. 
     & R. ~6 K$ V8 B- j
366.                 if(ucRecvTrueCx >= 2)
     * [4 X" ~: y1 X$ Z; G# J$ g! T
367.                 {
     , I' B. ?$ E# j: S; p$ ^/ C2 a
368.                                       ucRecvTrueCx = 0;
     
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                     {
     * d: v* T0 A% N2 x7 d
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                         gsUARTBuff.Recvlength ++;
     0 D% q( P4 R5 z- A9 _
373.                     }
     ( G- I0 W& w8 s% G8 U- y
374. 
     + J+ w$ j4 y# ^- t7 @! A$ [' X
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     
377.                     TIM6->CNT = 0;
     3 I- p, n8 w' C+ X& R
378.                 }
     
379.                 else
     . ~  e* E: J) \
380.                 {
     , G. o- @  Q/ v9 y( N- F
381.                     ucRecvTrueCx = 0;
     
382.                 }
     
383.             }
     
384.         }
     ( A1 Z& @$ b. z6 V; ~1 w
385.         break;
     ) W1 h; \- u" z, V/ h% c
386. 
     
387.         default:
     # w! p5 N- t8 O" e8 ?
388.             break;
     6 l+ e: M; z$ l4 \
389. 
     2 }5 G, a) |4 ]' V9 d1 Z( [4 T' K
390.         }
     
391.     }
     
392. 
     ; U. r" n+ R2 s9 u  t# o) k
393. }

复制代码

4 s4 g8 \2 b6 e" Z

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

4、 最优实现

9 b, X" ^& I5 d

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

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

1. #include "UartSet.h"
   0 ^! m( o2 K* T3 n
2. #include "string.h"
   ( {7 j" }2 M5 V$ }% F; {2 }
3. 
   7 S  L" E/ j. {$ V; z( S, c  \
4. typedef enum
   " r2 e8 F! z8 i* o% O$ H
5. {
   
6.     TimeRecvStartStep1 = 0,
   
7.     TimeRecvStep2 = 1,
   
8.     TimeRecvStep3 = 2,
   
9.     TimeRecvStep1 = 3,
   9 T, v; k0 Q, R$ |  ^9 k0 a
10.     TimeSendStep = 4,
    
11. 
    
12. } TimeStep;
    & u2 Y' M5 L( s+ n
13. 
    
14. uint16_t TimeSet[5];
    
15. 
    5 h" ~% T8 t) `9 r4 [7 B
16. uint16_t TimeSetBuff[][5] = {{1199, 59, 59, 2378, 2498 }, //1200
    * g" C, H4 M# d+ l" e
17.     {539, 59, 59, 1128, 1247 },  //2400
    
18.     {239, 59, 59, 503, 624  },   //4800
    
19.     {149, 29, 29, 251, 311  },   //9600
    
20.     {0, 0, 0, 0, 0    },         //预留
    6 p% ^4 ^% d! s6 ?
21. };
    
22. 
    3 Q( I9 |! h( m- E
23. UART gsUARTBuff;                //定义串口
    
24. 
    ) p7 h5 f" o$ t0 y
25. uint8_t ucRecvData = 0;         //每次接收的字节
    ; `: X+ G- _7 m, z! s/ x
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    
28. uint8_t ucSendBitCx = 0;        //发送位计数
    
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    
30. 
    % b/ x- C2 l! T' n4 n" ]# i
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    
32. 
    
33. 
    . o4 {& o( \8 w# o& J; m
34. TIM_HandleTypeDef htim6;
    , _- ~# h5 K' V% C" h6 ?
35. 
    ; I; i( @( q2 L* T" Y; w
36. void MX_TIM6_Init(void)
    
37. {
    * m$ @9 K! N  S$ f
38. 
    7 }/ A8 l4 f8 U# T& ^7 B# P# N
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    
40. 
    5 K- _6 a# A( Q
41.     htim6.Instance = TIM6;
    % i( D) ~4 H8 Z5 v1 \' u6 g
42.     htim6.Init.Prescaler = 15;
    4 U/ _; V3 a/ ?; u% e( e6 D1 |% I$ }
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    , O8 R: D/ C2 o! a+ m
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    6 l+ o0 H1 T; |: S& T! ?& D/ E9 w! @
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
46. 
    
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    4 O6 N* T: W0 @$ C
49. 
    
50.     HAL_TIM_Base_Init(&htim6);
    + _. z1 u& Q$ O
51. 
    8 ~+ V) J: t* L9 n6 m( [
52. }
    
53. 
    ) r/ y! a8 Y, Y2 L4 B
54. 
    # y4 c( ]6 c3 _* r
55. void UART_GPIO_Init(void)
    ) M6 H6 G8 O, o) b1 s# |9 R* U% z# |9 K
56. {
    - j+ A" ?/ Z, _
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    # ~1 q, L) P( o, ?! D) V& l
58. 
    
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    0 k, D. G% @' O3 A. N. E% R
60. 
    
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    4 Z2 U4 J1 @& V! R, }: |
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    & z3 U5 x0 S2 j% N8 o  ?( s% `
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    
66. 
    
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    1 [9 w- ~" n1 ^; r0 [6 j. o
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    " r5 f% F8 o) j2 I. t3 X2 G7 o6 F6 b$ F
71. 
    
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    5 x+ l( Z7 \( l& S: V# r
74. 
    1 r6 ?  @( [+ G7 E" ]
75. }
    $ y! k; _8 e# m
76. 
    ' k) s" \; `0 {7 i, A" ]: U
77. 
    ' _. P  w# p8 a4 M: U5 P8 f1 g
78. /*******************************************************************************
    
79. * @FunctionName   : UART_Init.
    
80. * @Description    : 模拟串口结构体初始化.
    % p" M, y* M) b# r, w
81. * @Input          : None.
    
82. * @Output         : None.
      u& ^4 X: a$ j
83. * @Return         : None.
    
84. * @Author&Data    : MrShuCai  2019.4.11.
    9 b9 @( @- l6 z% b7 l
85. *******************************************************************************/
    % x3 M* ~! w* O; a+ a+ H
86. void UART_Init(void)
    
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    # Q, A- {2 _& o6 F
89.     gsUARTBuff.UartMaxLength = Uartlength;
    / e$ l4 A) w  ]& P3 \8 |4 C* ^- I0 b
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
91.     UART_GPIO_Init();
    
92. 
    : h% l* m/ f# p
93.     if(BaudRate == 1200)
    6 A4 n0 M! [4 l2 P8 I
94.     {
    % {3 w- b1 R% m% B* i+ d
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    
96.     }
    
97.     else if(BaudRate == 2400)
    5 L6 Y1 ?/ `2 T6 k/ B6 _
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    ) z* x5 D+ s" @1 S, k  M8 ]' y! E
100.     }
     
101.     else if(BaudRate == 4800)
     
102.     {
     
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
       o+ L% i; x6 \* s' M. Y
104.     }
     
105.     else if(BaudRate == 9600)
     ( r- Z9 L  B$ u: o
106.     {
     ; {' E: w1 Z* I4 E/ S+ z( r5 c
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     $ b- E; A; p3 u) v5 `4 A9 d
108.     }
     
109.     else
     
110.     {
     1 ~  j& b& Z& q' o
111. 
     3 g6 ?% a  }: `& M
112.     }
     
113. 
     3 l8 B* `# ~; x: E* y
114.     MX_TIM6_Init();
     ) m8 H9 v- N& r4 W
115. }
     
116. 
     
117. 
       j. v3 [  b, L# M- [$ d
118. /*******************************************************************************
     9 C$ d- d1 e7 o; a1 f
119. * @FunctionName   : UART_Send_Data.
     
120. * @Description    : 模拟串口发送数据接口.
     ) F: O2 `. h/ d9 [( }! v
121. * @Input          : None.
     
122. * @Output         : None.
     . g/ v9 ]; u. Y" J4 q
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     * o* i7 {& f; Q# u
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     9 c, D% @4 ]9 Y* p3 e4 X! r
127. {
     . a5 J9 D/ I  ?# A
128.     gsUARTBuff.Sendlength = size;
     . L" ?+ p* k- z* A
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     # a0 i5 j! _& K0 F5 e/ v4 S) P1 G
130.    
     
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     * L( Q4 d4 O" M( F% Y7 h; |
132.         {
     0 q7 b' g7 ^2 R4 Z% c- M. z
133.             gsUARTBuff.TxEn = 1;
     + \) i$ l+ V+ o. T1 ], j
134.             gsUARTBuff.RxEn = 0;
     ) G% N( }; g- ~0 w+ e0 z9 y
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ) p% ~" v) M$ L
136. 
     
137.             TIM6->ARR = TimeSet[TimeSendStep];
     3 E: X6 L9 n2 m! `
138.             TIM6->EGR = TIM_EGR_UG;
     , {( w, \/ q( O# P4 t
139. 
     
140.             HAL_TIM_Base_Start_IT(&htim6);
     1 m$ q6 w& d1 S( ], h
141.         }
     
142.       
     
143. }
     9 X( d2 O" r( Y$ |; T1 ^9 O) ^" T
144. 
     2 B- ~2 L7 j' E7 v7 _
145. 
     
146. /*******************************************************************************
     
147. * @FunctionName   : EXTI4_15_IRQHandler.
     
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     
149. * @Input          : None.
     
150. * @Output         : None.
     
151. * @Return         : None.
     
152. * @Author&Data    : MrShuCai  2019.4.11.
     
153. *******************************************************************************/
     ( U  |) r% W2 {, A; J# C6 n
154. void EXTI4_15_IRQHandler(void)
     , h1 ?0 O3 h5 `
155. {
     " C% r: X# `5 _. k( X( l
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
157.     {
     0 M" ^' L/ L2 z' K
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
159. 
     * {% g. O" P1 j: a/ r2 q) a- G
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     " o' z. t- q% m% q; _1 n  c; z% K: d( v% O( V
161.         {
     
162.             gsUARTBuff.RxEn = 1;
     $ s3 n% }7 X0 S0 w
163.             ucRecvData = 0;
     ! R2 W1 ]& T% r8 V( M5 [! R( c. [
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     . R( t- v+ c; S% v
165. 
     
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     5 w) T& k/ _. @& V5 v0 ?
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     
168.                       EXTI->IMR &= ~(0x10);
     
169.                       EXTI->EMR &= ~(0x10);
     
170.             HAL_TIM_Base_Start_IT(&htim6);
     
171.         }
     & G$ _$ W' B8 N9 y' l7 T
172.     }
     
173. 
     8 w2 C5 U: O6 l8 ~+ N0 `# K" G% p
174. }
     
175. 
     
176. 
     * O+ p5 {6 t% X) p
177. /*******************************************************************************
     
178. * @FunctionName   : BitValueChk.
     * ^9 O  u  g4 ~3 o, I$ p3 B; `
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     * J% U+ y% r6 U8 w: z: Y9 A
180. * @Input          : n 采集记录的位值.
     : W) \+ v; n1 z4 e& h
181. * @Output         : BitValue.
     
182. * @Return         : BitValue.
     
183. * @Author&Data    : MrShuCai  2019.5.1.
     
184. *******************************************************************************/
     
185. uint8_t BitValueChk(uint8_t n)
     
186. {
     
187.     uint8_t BitValCx = 0;
     
188. 
     
189.     for(BitValCx = 0; n; n >>= 1)
     8 T1 Q* S$ h: q. u
190.     {
     3 l5 [; B5 \0 t3 J
191.         BitValCx += n & 0x01;
     # I# v, N% f6 H: j; w
192.     }
     / I% \6 @  |- b$ J, Q: D% J
193. 
     
194.     return (BitValCx < 2) ? (0) : (1);
     : X! L( E' l: b+ J
195. 
     
196. }
     ' W( e+ f9 z. `
197. 
     
198. /*******************************************************************************
     2 f  t- j5 I2 @
199. * @FunctionName   : TIM6_IRQHandler.
     ) F& g* L. U6 ^: n  m6 [7 m
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     " |; C9 Z% N; _
201. * @Input          : None.
     
202. * @Output         : None.
     / W7 f9 U2 g/ |- o2 Y% P7 x6 q
203. * @Return         : None.
     
204. * @Author&Data    : MrShuCai  2019.4.11.
     . n$ N  J2 }3 S3 M( G2 l
205. *******************************************************************************/
     $ W6 t8 g! I" v/ g1 K8 D
206. void TIM6_IRQHandler(void)
     , p! Y' Y# B6 z' N7 D4 @( g
207. {
     
208. 
     
209.     HAL_TIM_IRQHandler(&htim6);
     
210. 
     
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     + V1 ~! t3 W+ w; W, M
214.         {
     
215.         case COM_START_BIT_DEAL :
     * E4 E6 Y, e& @0 g/ ]
216.         {
     7 |9 a" e2 q7 H# u9 |! I
217.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     2 X. X4 {. H$ N  g( T' N
218.             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
219.             ucSendBitCx = 0;
     . R3 i# r9 d' [
220.         }
     : b  \$ |3 ?0 k2 ~4 K  M
221.         break;
     
222. 
     
223.         case COM_DATA_BIT_DEAL :
     + F5 H% o# ^2 S2 s1 `
224.         {
     ! `. e: Z" f% ~0 `# f7 [7 N# B
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     $ @0 K& I8 U& _+ n3 [
226. 
     6 @. ]' T7 |% V2 X$ y+ L5 @0 l
227.             ucSendBitCx ++;
     
228. 
     
229.             if(ucSendBitCx >= 8)
     
230.             {
     0 }: p* c; M( l+ h4 v3 Y- z1 L6 _
231.                 if(gsUARTBuff.CheckType == NONE)
     
232.                 {
     ; [% B; v+ K8 p" F
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     % {6 O2 E( M6 C6 ?) }: Q
234.                 }
     
235.                 else
     
236.                 {
     9 R, z2 `" O! h6 ]9 ?3 Q5 T; H
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
238.                 }
     8 R% @6 }  V/ r
239.             }
       _) e1 u! {( V  P
240. 
     0 s' P- x# H6 c- P0 H3 i9 f! a
241.         }
     
242.         break;
     
243. 
     
244.         case COM_CHECK_BIT_DEAL :
     
245.         {
     
246. 
     8 T, M$ T" Z  K) ^7 F
247.         }
     : m5 |/ J5 |& ]5 X. z$ t6 B! Q
248.         break;
     $ I9 s' u9 Z5 Z5 E$ ^
249. 
     
250.         case COM_STOP_BIT_DEAL :
     
251.         {
     $ J$ M1 z- x& r7 J) ]7 F/ |" S) C: q
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
253. 
     
254.             ucSendBitCx = 0;
     & j% v! t9 {) u) {
255. 
     
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
257.             {
     
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     # S6 h! ^. k- ?7 h+ k  W$ h
259.                 ucSendLengCx ++;
     5 \) f3 s6 D  M$ H& X/ O4 o
260.             }
     " B6 s5 z! |% J; w8 p
261.             else
     2 e& z, h1 r6 I/ o5 u/ e- Q" S
262.             {
     + }: i) ^. ~, _
263.                 ucSendLengCx = 0;
     % h! b+ e( E) c2 a3 n
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     ) R; h& w  V4 i) Z  s4 ?7 j7 G
265.                 gsUARTBuff.TxEn = 0;
     
266.                 gsUARTBuff.RxEn = 1;
     
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     
268.                               EXTI->IMR |= 0x10;
     / ~  B8 V, M2 Y+ V3 k# D4 n" a
269.                           EXTI->EMR |= 0x10;
     
270.                 TIM6 ->CNT = 0;
     2 ~) J" Q# p1 d) x. c- S' d
271.             }
     ) A! L# @, D! l; F
272. 
     4 h$ o% i' q' w. H  V* w
273.         }
     3 v+ `4 J- m* x0 E& E4 c* g
274.         break;
     
275. 
     4 h/ [) z# e3 i# A8 B- a$ o
276.         default:
     
277.             break;
     
278. 
     5 F' T  g1 D. Q3 ]" d8 I
279.         }
     , t  e, m8 A; S
280.     }
     
281. 
     6 v) f0 W: r+ h
282. 
     2 }1 {% v4 N: Q/ g9 Q
283.     if(gsUARTBuff.RxEn == 1)
     
284.     {
     
285.         switch(gsUARTBuff.UartStat)
     ' e9 v4 k* j; p5 y, C1 N$ t
286.         {
     
287.                     case COM_START_BIT_DEAL :
     * ^2 l! I# c" r% e5 @, ?0 ~: a
288.                     {
     
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     3 y" u( J2 S! S; K6 N
290. 
     + _0 Z( B7 w4 t# V& L
291.                             if(++ ucAcquCx >= 3)
     
292.                             {
     ) x/ [+ F: m6 J2 T: g
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     
294.                                     {
     
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     ( o8 W. k5 `9 `/ g$ d
297.                                     }
     , L7 Z& k3 U- A- {* s/ D$ C
298.                                     else
     
299.                                     {
     ; M5 B$ p8 X) X) p
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
301.                                     }
     
302.                                     
     " i8 K, m# t0 {; o
303.                                     ucRecvBitBuff = 0;
     
304.                                     ucAcquCx = 0;
     " o. @  D$ \: k
305.                             }
     
306.                             else
     
307.                             {
     
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
309.                             }
     7 H7 x4 k2 ^; B
310. 
     
311. 
     
312.                     }
     
313.                     break;
     
314. 
     
315.                     case COM_DATA_BIT_DEAL :                         //数据位
       r4 k& ?7 u+ z; q( u/ _
316.                     {
     
317. 
     
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
319. 
     " s2 O1 ]" j9 ~
320.                             if(++ ucAcquCx >= 3)
     # N* Y; Y0 @% \) j% f
321.                             {
     / [6 I/ D4 h: @' [* [
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     
323. 
     / ~: X& V2 [0 p1 O, N
324.                                     if(ucRecvBitCx >= 7)
     
325.                                     {
       j! A9 r- G1 ^4 i; b
326.                                             ucRecvBitCx = 0;
     
327. 
     
328.                                             if(gsUARTBuff.CheckType == NONE)
     7 q5 U, l# ?0 V$ |" P) b' x* }
329.                                             {
     
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     7 K5 z' t. s1 d7 j2 P8 R9 j
331.                                             }
     , g/ ^2 ?/ p6 k3 I# Q  ]# P/ Z' ]9 g
332.                                             else
     
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     , t0 T: h6 R; X/ z
335.                                             }
     $ m1 E' H9 X  ?' q
336.                                     }
     
337.                                     else
     
338.                                     {
     7 l2 ]- |7 k) u& i5 Z
339.                                             ucRecvBitCx ++;
     
340.                                     }
       o, A1 L+ m$ n; O1 N9 r5 E- m  _
341. 
     
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     . z4 }. E% I7 J% K
343. 
     - n) P& C9 y3 Q/ k6 ^
344.                                     ucAcquCx = 0;
     
345.                                     ucRecvBitBuff = 0;
     
346.                             }
     
347.                             else
     
348.                             {
     
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
350.                             }
     3 l1 c" q- Z* G
351.                     }
     
352.                     break;
     
353. 
     
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     0 x0 ^" T0 Z1 D$ b( }* V
355.                     {
     2 v. x1 ~) P. Z  o! }5 O* k
356. 
     : K/ K, H( W8 }" g' W
357.                     }
     
358.                     break;
     
359. 
     
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     
361.                     {
     & P- o+ [8 q( L$ r
362. 
     / e( y( N/ U" \
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     
365.                             if( ++ ucAcquCx >= 3)
     + u6 x0 D7 \! r. Q% h! n  t' `
366.                             {
     7 O( H) e6 ^7 p4 M: u
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     - W: W: B0 v# Y% L6 S7 p2 j
368.                                     {
     : b& p; \4 v5 @' d) G( D2 `
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                                             {
     ) W& o$ n, T7 O' H; W$ j  M( [
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     3 F* Q7 S; y( m' N2 M( q+ P
372.                                                     gsUARTBuff.Recvlength ++;
     : ^. r1 o0 i8 S) X/ i# |% w
373.                                             }
     
374. 
     3 _5 Z# r' e- @9 _& Z  E
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
       p  h/ `( t; F) s/ D
377.                                             
     
378.                                             EXTI->IMR |= 0x10;
     
379.                                             EXTI->EMR |= 0x10;
     
380.                                             TIM6->CNT = 0;
     * W/ A* M8 a3 x" A
381.                                     }
     
382.                                     else
     1 a9 [: i& W5 x8 u, b9 A" e
383.                                     {
     / e0 V' O. l7 Q0 q8 U
384.                                             ucAcquCx = 0;
     : \2 t# d1 ?6 ^( X* q/ M" m1 O9 v
385.                                     }
     
386.                                     
     ! Q: R+ Q& F( |9 @6 b  S; |% L
387.                                     ucRecvBitBuff = 0;
     
388.                                     ucAcquCx = 0;
     
389.                             }
     3 J8 P+ f: M# M
390.                             else
     + @, A' L8 d! g8 |+ X
391.                             {
     4 {5 n, W6 N7 R  w
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     / r+ q- g* y% f6 }3 L
393.                             }
     6 F1 ~5 q; X. k7 }2 s8 P" l# D
394.                     }
     ; t' v4 @9 B* ^* ]
395.                     break;
     
396. 
     & O$ c! t: S9 N% q' O
397.                     default:
     
398.                             break;
     
399.                     }
     
400.     }
     
401. }

复制代码

" R  J* z+ `  R2 B

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

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

& G: B! \/ Y1 U3 E