一、设计用途：

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

二、硬件电路：

. Y3 K# K! A; E" e, M0 [; `

) q4 B; X& Q  I  l4 w
1 U  p( @1 G/ @' N, c

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

8 g  x2 i$ w! W7 a

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

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

- F/ g2 B0 H9 T
/ u( o7 x# e% a' ]6 M

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

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

硬件串口的噪声处理：

. J9 m' ]2 r$ O& ^; k) U

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

  a2 Y6 R; e9 Z& S2 |. P+ `. q

3、 实现方式选择

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

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

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

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

; `1 [9 Q  W) p! b- P7 f

自写第一种实现方式：

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

1. #include "UartSet.h"
   
2. #include "string.h"
   
3. 
   
4. uint8_t ucRecvData = 0;         //每次接收的字节
   
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   - v) L) T+ D. Y' z. W1 c& h
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   - |: H# F; W) [) N# j* ?6 X9 V
7. uint8_t ucSendBitCx = 0;        //发送位计数
   
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   ) z: B6 \# Y$ v) R; U+ Y( ?# Z+ I( ~
9. 
   
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    . p: ~/ }# G+ @2 p! e3 A$ y3 p
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    4 \7 l2 k+ b  \) o" f2 C- e+ X
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    6 @! l! x* u8 T; N
13. 
    
14. uint32_t Prescaler = 0;
    
15. uint32_t Period = 0;
    
16. UART gsUARTBuff;               //定义串口
    ; Y( O* \* y( o7 T- _
17. 
    
18. TIM_HandleTypeDef htim6;
    
19. 
    " F* a6 M  A" F: d& w
20. void MX_TIM6_Init(void)
    
21. {
    # E* N6 h9 K1 H$ G/ _5 Q
22. 
    
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    * h$ I9 P8 v% H7 z" w4 k
24. 
    . K8 C0 d. }' a4 l# n4 G
25.     htim6.Instance = TIM6;
    , b! X( g/ \  P% L) }
26.     htim6.Init.Prescaler = Prescaler;
    * r% L# i+ r+ d& R7 j
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    6 G. q) E- q6 F+ w8 R; ^
28.     htim6.Init.Period = Period;
    
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    ! U! @* f' j, v1 j/ P
30. 
    3 U9 X% e. o6 ~. i" @, b% B
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
33. 
    
34.     HAL_TIM_Base_Init(&htim6);
    # D: y, `" v& p, W
35. 
    
36. }
    
37. 
    ' C+ I% h4 B) d4 A* M9 y- {
38. 
    
39. void UART_GPIO_Init(void)
    
40. {
    
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    + t, `: j6 H, R2 ]0 Z
42. 
    . |$ x- K: Q# M4 s: M' l% N
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
44. 
    ! j& Y) g( _  X3 Z
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    : M! i3 e$ Y. ~) l; E
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    6 T# n7 s; r% t" l0 w- f: W- C
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    0 c' w  S8 Q- o) @8 B/ D0 {) w
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    5 j+ K; P, f9 S# P1 w6 ]) \+ l
49.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    
50. 
    
51.     GPIO_InitStruct.Pin = COM_RX_Pin;
    ! M1 U0 B: v$ b: p4 a9 j/ {, z
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    3 R" H$ z$ s2 J
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    ) E( O8 j+ a' l5 T$ A8 L( R
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    " {5 r1 A  z% B' A) X8 j
55. 
    ) Y. V$ e3 `, `# m! G) q/ Z
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    7 M" E- h0 k' z
58. 
    
59. }
    
60. 
    
61. 
    
62. /*******************************************************************************
    
63. * @FunctionName   : UART_Init.
    % g9 X' ^$ z) ?
64. * @Description    : 模拟串口结构体初始化.
    $ x, u9 H$ X0 J# {) N8 N" p( `, |+ |
65. * @Input          : None.
    
66. * @Output         : None.
    
67. * @Return         : None.
    
68. * @Author&Data    : MrShuCai  2019.4.11.
    4 O+ U" z! F: u
69. *******************************************************************************/
    & O' P! Q. c5 R) c
70. void UART_Init(void)
    
71. {
    ) t4 g/ m2 ?9 R* p7 O& }* w- Q
72.     gsUARTBuff.CheckType = NONE;
      N$ ^! S" I4 N. Q1 _- L* O
73.     gsUARTBuff.UartMaxLength = Uartlength;
    
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
75.     UART_GPIO_Init();
    
76. 
    
77.     if(BaudRate == 1200)
    
78.     {
    
79.         Prescaler = 15;
    - ?4 W3 b# P7 e: N2 b
80.         Period = 623;
    
81.     }
    6 N  w* f3 ^6 u0 W9 K  _6 b
82.     else if(BaudRate == 2400)
    
83.     {
    
84.         Prescaler = 15;
    - t: W0 d* D" b6 y
85.         Period = 207;
    # e2 H4 x% l0 K( H2 ~
86.     }
    $ [9 v) U! V+ x% F4 w! f( y9 u
87.     else if(BaudRate == 4800)
    
88.     {
    
89. //        Prescaler = 15;
      B' R/ X1 G. U3 A3 v" v+ c
90. //        Period = 50;  //9600
    ; a7 E' h) C, u4 b- `2 e2 X
91.              Prescaler = 15;
    
92.              Period = 103;
    # V- k. O) p8 e+ |* P, T
93.     }
    
94. 
    : T/ f; e9 m+ w6 L$ R8 V
95.     MX_TIM6_Init();
    3 ]9 l1 c* v& ~
96. }
    . n6 }6 `' U$ `  C3 }8 I" t
97. 
    ! `, Y, |0 M# g, m
98. 
    
99. /*******************************************************************************
    0 F; e1 N$ ?1 {8 {( H
100. * @FunctionName   : UART_Send_Data.
     * T: o# j4 q# Q- q
101. * @Description    : 模拟串口发送数据接口.
     
102. * @Input          : None.
     
103. * @Output         : None.
     ! _9 h* O6 T% m
104. * @Return         : None.
     2 t; c$ k) U; D, t& g/ n' u7 I9 v
105. * @Author&Data    : MrShuCai  2019.4.11.
     
106. *******************************************************************************/
     . h  G9 ], q/ p( f0 ~6 c  g1 K
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     . q4 A$ ^$ P$ X+ y% Y$ a- R
108. {
     $ t# k, |: |  e7 \2 P' k% N+ C9 D# t! b
109.     gsUARTBuff.Sendlength = size;
     
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     / I! ]/ u1 O: Z/ {) w8 g4 a; \/ H4 R
111.     gsUARTBuff.TxEn = 1;
     
112.     gsUARTBuff.RxEn = 0;
     0 y5 g! l0 F9 g! Z% g) Q! X
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
114.     HAL_TIM_Base_Start_IT(&htim6);
     4 S) V# H0 a6 o
115. }
     
116. 
     5 ~/ q5 d: l( B. v1 v2 z% V
117. 
     + ^! `$ t/ O* ~) ^$ T
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     2 n  U/ v9 J0 }: [
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     ' W% U! i; |9 J3 q, c( _  I
121. * @Input          : None.
     ! B# l* ]; e1 R' C" j/ G
122. * @Output         : None.
     
123. * @Return         : None.
     * E7 E( o( |5 Q' C) C+ ^
124. * @Author&Data    : MrShuCai  2019.4.11.
     1 y, S% F, f7 H9 l; l7 `/ O
125. *******************************************************************************/
     
126. void EXTI4_15_IRQHandler(void)
     6 Q+ o$ Y) z0 x( `
127. {
       S- T7 L/ Y9 P2 R0 d; S5 M/ z
128. 
     
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
130.     {
     
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
132. 
     
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
134.         {
     
135.             gsUARTBuff.RxEn = 1;
       J4 h7 S4 R+ w8 j2 u! o/ e
136.             ucRecvData = 0;
     , P0 g# g9 v' w8 i8 Y& n- F+ R
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     
140.     }
     - p" m9 K. N9 h8 g) U4 |; V  ^
141. }
     6 N  \6 W& H9 T& A( h3 |/ I" G
142. 
     9 I; l+ h/ h& J
143. /*******************************************************************************
     
144. * @FunctionName   : TIM6_IRQHandler.
     " Z9 [: h9 l! o& u
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     
146. * @Input          : None.
     
147. * @Output         : None.
     % @" `* r% X/ T) G: b
148. * @Return         : None.
     
149. * @Author&Data    : MrShuCai  2019.4.11.
     & S) s+ S/ G7 C+ m. v  _3 U7 ~" j! s! G
150. *******************************************************************************/
     1 a9 _0 b: m! U2 O- J2 k
151. void TIM6_IRQHandler(void)
     % k! S/ c! s& h$ V8 S
152. {
       _  \- j6 R1 U  d6 C( Y2 [/ I9 \8 R1 n
153.     HAL_TIM_IRQHandler(&htim6);
     , G5 f2 k4 r7 {3 k5 ^
154. 
     
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     
156.     {
     2 M& s( b' V' k" r3 m, H
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);
     4 `) q4 D4 ^) E) V
162. 
     : v& e" Q5 Q6 P1 \
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     
164.             {
     
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
166.                 ucAcquCx = 0;
     3 ], R) [8 m$ J1 n3 [$ o
167.                 ucSendBitCx = 0;
     
168.             }
       l9 o! Q& a3 v4 H) k2 W8 D5 k  Y
169.         }
     
170.         break;
     
171. 
     6 E0 g3 ~9 {& v- a& B
172.         case COM_DATA_BIT_DEAL :
     
173.         {
     
174. 
     4 F/ E$ M/ R" ~% ]- i  d9 J
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     7 G- g4 O+ W. c& N. R& a
176. 
     + A2 t2 J' {! n- q6 Y! d
177.             if(++ ucAcquCx >= 6)
     
178.             {
     % {3 P" w) Z. k8 J/ n" F( }
179.                 ucAcquCx = 0;
     
180.                            
     
181.                 ucSendBitCx ++;
     0 j. M0 k+ Q; f* ~
182. 
     
183.                 if(ucSendBitCx >= 8)
     
184.                 {
     % x) x, G3 P8 |% w
185.                     if(gsUARTBuff.CheckType == NONE)
     ( ~4 X9 N. j( R% p& V" }
186.                     {
     
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     # J, r; T9 q& d1 D9 m. y
188.                     }
     
189.                     else
     6 `# k8 R* |$ S; l% y
190.                     {
     : R( E5 ?3 {3 j6 y& `- @6 d
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     4 X5 H; h6 `9 s3 Z6 k/ |# `- A
192.                     }
       c5 C+ a0 e2 e8 A- q/ n# Q
193.                 }
     % }" D- s0 N- S0 o$ k
194.             }
     . N: f8 m) Q" r3 H& T( ]2 B
195.         }
     8 _4 a+ v/ O% X% [( @- b
196.         break;
     
197. 
     
198.         case COM_CHECK_BIT_DEAL :
     + G' [5 o2 e8 o
199.         {
     
200. 
     
201.         }
     + J* Q% Q% W6 D9 Q  R
202.         break;
     ' S5 Y/ i& Y8 R% x* X
203. 
     
204.         case COM_STOP_BIT_DEAL :
     1 U8 b- a* Z  U" ?% B2 n7 G* c* X$ H
205.         {
     
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     " k" o: O( v! `/ N* c3 G
207. 
     + w: S- H, g4 q) G* _3 k
208.             if(++ ucAcquCx == 7)
     
209.             {
     + {6 v. M- Z8 b
210.                 ucAcquCx = 0;
     
211.                 ucSendBitCx = 0;
     
212. 
     
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     # {/ m7 M% y( U4 P5 A  c" u% X
214.                 {
     / I' C( p1 f% b- x: `) ]
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ( X$ F5 T% S' a4 E* w8 _
216.                     ucSendLengCx ++;
     
217.                 }
     ' m: |  Z7 [, F" Z
218.                 else
     + D, Q( x' W3 l1 _( y4 I3 w
219.                 {
     
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     5 x6 R7 m' w. m7 R0 @4 R
222.                     gsUARTBuff.TxEn = 0;
     
223.                     gsUARTBuff.RxEn = 1;
     
224. 
     4 e# M1 ~/ f" ~+ K0 U/ T0 V
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     
226.                     TIM6->CNT = 0;
     
227.                 }
     " F, Z- ^. y7 i7 f
228.             }
     6 d# M) U' G% L8 L6 V  f8 m9 S/ C
229.         }
       m5 Y  F& a% F/ h5 i
230.         break;
     
231. 
     
232.         default:
     
233.             break;
     1 o8 d: @7 B, b+ t9 W
234. 
     8 T  p1 C" B. I0 N4 x6 F
235.         }
     # P5 d: G) ?7 {2 a9 F$ Y
236.     }
     7 I- J! q- N, ]/ k$ ^! @4 @
237. 
     
238. 
     : F1 T* I4 m$ l
239.     if(gsUARTBuff.RxEn == 1)
     
240.     {
     
241.         switch(gsUARTBuff.UartStat)
     
242.         {
     
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     : v/ k3 [: A( |8 E
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     $ O6 {. ?( G; T7 U8 H8 W$ c( V
247. 
     
248.             if(    ucAcquCx == 0)
     3 Y1 K! r7 j0 ?) V/ e
249.             {
     
250.                 ucAcquCx = 1;
     ! X' d  B2 s! b% b0 W: e
251.                 return ;
     
252.             }
     3 M+ d. Y, s- I: l, Z
253. 
     
254.             if(ucRecvLastBit == ucRecvNowBit)
     4 P9 `9 Y$ Z' [6 ], \
255.             {
     
256.                 ucRecvTrueCx ++;
     9 S* y, T5 B: R5 t% {- {) ?1 a
257.             }
     5 A8 T" o' _6 i: J* J% ~
258. 
     
259.             if(++ ucAcquCx >= 5)
     9 K2 U8 U- x* V: W+ O* o8 p
260.             {
     * g' @! I" ?7 N' b: Q: A& b
261.                 if(ucRecvTrueCx >= 2)
       q1 i2 P; `# U
262.                 {
       g& P" Q/ u" \4 i3 D4 x
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     + n7 L, W6 ?# o1 k& F8 h' z/ [
264.                     ucAcquCx = 0;
     ; i6 e0 j2 d# J
265.                     ucRecvTrueCx = 0;
     : M: W2 g3 f8 i6 p4 _: q6 Z$ f& s
266.                 }
     1 E8 Y* ^7 x4 J( H
267.                 else
     2 a; T1 {- s2 r* a1 ]- \
268.                 {
     * e$ {7 Q+ D" Z5 S3 @
269.                     ucAcquCx = 0;
     3 U+ O6 t0 x3 I# F
270.                     ucRecvTrueCx = 0;
     " I& `2 u% ~/ h! h* C
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
272.                 }
     6 {8 @" J! V6 Y8 G: q8 U: l+ V
273.             }
     ( @& T/ X6 F! L. d
274.         }
     
275.         break;
     
276. 
     # I; N/ g& n5 j! @5 Z
277.         case COM_DATA_BIT_DEAL :                         //数据位
     
278.         {
     $ u/ |+ h; w8 V5 [% S3 I" s2 R
279. 
     # ^! e5 f. L5 S8 f3 {7 _% T9 d
280.             ucRecvLastBit = ucRecvNowBit;
     
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     
283.             if(0 == ucAcquCx)
     % @; j. O9 V$ q6 y! e
284.             {
     
285.                 ucAcquCx = 1;
     
286.                 return;
     
287.             }
     
288. 
     ! T; r/ ?/ O  L& I: h% `
289.             if(ucRecvNowBit == ucRecvLastBit)
     
290.             {
     ) S' _9 Z  b% D0 P( a/ F
291.                 ucRecvTrueCx ++;
     $ y: s7 g6 l4 ]4 Z8 I* c: Q
292.             }
     
293. 
     6 y! h' e  \8 R& Y7 P/ y
294. 
     
295.             if(++ ucAcquCx >= 6)
     9 {1 m; i  q9 a0 y9 n
296.             {
     5 _1 j, v$ r& T1 ^# s; O( ^% r
297.                 ucAcquCx = 0;
     , M5 ]" K9 t) a# f$ Z4 j; \' ]
298. 
     1 o* z2 \1 W9 ~
299.                 if(ucRecvTrueCx >= 2)
     
300.                 {
     
301.                     if(ucRecvLastBit == 1)
     
302.                     {
     1 {1 z& u7 k! }* h  |$ i
303.                         ucRecvData |= (1 << ucRecvBitCx);
     3 i% V& @5 a7 L: _! l. |( P+ \
304.                     }
     3 N) q3 e- a5 [1 \+ r
305.                     else
     
306.                     {
     , y, f2 i/ w6 X/ \' _# u
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     
308.                     }
     
309. 
     , ^$ m# N, f0 A* W
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     
313. 
     0 s7 I7 b+ B; ?2 o5 u
314.                         if(gsUARTBuff.CheckType == NONE)
     
315.                         {
     , E& N/ g8 M# L6 ~. E6 }7 J+ O
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
317.                         }
     
318.                         else
     * t6 Y* W* l( c; C# T
319.                         {
     4 y8 S2 N% e  S- i! o+ ^
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     ' r' w1 I. J0 L+ `3 U
321.                         }
     
322.                     }
     6 j/ r8 }% _: q( p5 U$ N# `- s5 E
323.                     else
     
324.                     {
     
325.                         ucRecvBitCx ++;
     7 N7 X3 L) R5 ^' z9 p6 G
326.                     }
     ; X' W7 r  Q6 z1 j( ?
327.                 }
     - ?9 y; p$ T$ D& b  t, w
328.                 else
     ( |' S; `$ Y5 R+ w
329.                 {
     ) e0 l8 S5 H; D1 i. p, h
330.                     ucAcquCx = 0;
     5 ?9 e" @/ e% I# n, ?, a
331.                     ucRecvTrueCx = 0;
     
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     ' k3 n+ Z; ]9 s" n
333.                 }
     * J9 y  D9 T, b! X! _+ I
334.             }
     
335.         }
     # G$ w0 _7 f0 _' J% s. i/ w
336.         break;
     " R2 `/ p2 R+ l. j5 X" y1 W& X* }
337. 
     0 [; y+ _" ^8 k) z6 L
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     : j& j3 v" s- x- L; j
339.         {
       x: U5 W) r9 e5 {4 G
340. 
     
341.         }
     9 b0 w4 K% j3 Z8 q) t* i
342.         break;
     
343. 
     $ z( P* q$ {2 @5 v4 E& q
344.         case COM_STOP_BIT_DEAL :                         //停止位
     ! q8 k' n) i# p7 x% n2 m6 j
345.         {
     
346. 
     
347.             ucRecvLastBit = ucRecvNowBit;
     + j* p  F- }6 C- X. c5 Z
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
349. 
     
350.             if(0 == ucAcquCx)
     # l! x; `; z. l! r
351.             {
     
352.                 ucAcquCx = 1;
     5 F2 x+ B* p6 o: _. ~8 U
353.                 return;
     
354.             }
     
355. 
       p. ?' ^( \: |- C# \0 M6 U
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     ) S/ L3 q) R# ^& d3 F, J5 b
357.             {
     ! L: Y& J2 [( e  K# e3 \+ ^
358.                 ucRecvTrueCx ++;
     
359.             }
     
360. 
     
361. 
     
362.             if( ++ ucAcquCx >= 6)
     " z1 K4 u: w7 T6 q% U
363.             {
     
364.                 ucAcquCx = 0;
     ! C6 H/ @* M3 c6 y& s: l+ X: I
365. 
     
366.                 if(ucRecvTrueCx >= 2)
     
367.                 {
       w) f/ N, N& O1 s
368.                                       ucRecvTrueCx = 0;
     ' {: [) N1 j  W& O+ i& ~: h) e
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                     {
     
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                         gsUARTBuff.Recvlength ++;
     2 w1 O$ g2 \+ x5 f; A
373.                     }
     
374. 
     
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     8 D7 ^* S) n: v- E# f, Y3 I
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     
377.                     TIM6->CNT = 0;
     
378.                 }
     
379.                 else
     
380.                 {
     8 [) D" G2 T9 J
381.                     ucRecvTrueCx = 0;
     
382.                 }
     
383.             }
     6 X1 T6 H2 a* A) I
384.         }
     
385.         break;
     ! P$ X7 I3 v4 d' \
386. 
     : M( b6 _- Y7 ^$ P4 r- L3 K# f: m
387.         default:
     $ H# m5 D  P5 R5 n. i3 Y% p
388.             break;
     
389. 
     
390.         }
     8 {. x/ q5 n: ]; Q
391.     }
     
392. 
     . @7 R: ?! l! O
393. }

复制代码

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

4、 最优实现

5 C+ ?# R0 I: I( ~& q0 G

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

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

1. #include "UartSet.h"
   
2. #include "string.h"
   
3. 
   6 `" K2 q4 Q# K! g0 i2 U6 k
4. typedef enum
   
5. {
   $ U4 [% {. r) t3 v: ?
6.     TimeRecvStartStep1 = 0,
   4 S+ |0 w1 A( s) E! e  A
7.     TimeRecvStep2 = 1,
   ( f7 ?& B! g0 U9 m7 _% O' c
8.     TimeRecvStep3 = 2,
   & l9 C/ R. Y/ Q/ q) G
9.     TimeRecvStep1 = 3,
   
10.     TimeSendStep = 4,
    5 ?" X$ R$ g" i) P5 z7 \! d
11. 
    
12. } TimeStep;
    ) J- T4 ^' N! o% d
13. 
    
14. uint16_t TimeSet[5];
    
15. 
    ! N6 l8 t% y9 q
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
    8 w4 ^7 S* D8 j" L
19.     {149, 29, 29, 251, 311  },   //9600
      t3 Z* s; a& }: b8 ^0 _2 N
20.     {0, 0, 0, 0, 0    },         //预留
    
21. };
    ' i9 e; O. o3 @' j, K% l
22. 
    ) Z* V4 R! N$ ^- ^. o# g. X, C) B+ ^
23. UART gsUARTBuff;                //定义串口
    2 h* ^) K% J  P- p( U
24. 
    $ s  y$ [0 I5 Z  g/ }: a% N, q) x
25. uint8_t ucRecvData = 0;         //每次接收的字节
    7 T4 e! T0 h0 ^# H
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    
28. uint8_t ucSendBitCx = 0;        //发送位计数
    
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    
30. 
    1 n7 x1 y7 A, L# a& Q
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    * W* @8 f) h  {9 u! \8 I# k2 V
32. 
    
33. 
    3 I2 [: r, M$ C9 }0 Y8 I
34. TIM_HandleTypeDef htim6;
    2 F# v( u$ ^4 I) C" ~% h
35. 
    
36. void MX_TIM6_Init(void)
    + C- T, m0 b$ V( m7 ?
37. {
    
38. 
    4 T! s4 @" _0 q/ w8 H+ I; w, N
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    7 h1 X# y% n$ h' n# p
40. 
    
41.     htim6.Instance = TIM6;
    " A- i* \. ?5 ^- r/ O/ Q
42.     htim6.Init.Prescaler = 15;
    ! V' H" w, C$ ^3 _( {5 a
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    $ J. {  V) ?1 w* i) `
46. 
    . {3 Z7 D. n; O/ ]& ]
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    , v) f$ n$ Z( r, e& E  v3 M
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    0 d, b+ f' d' z+ `4 B5 l! @
49. 
    
50.     HAL_TIM_Base_Init(&htim6);
    
51. 
    
52. }
    
53. 
    ; |( x  D# l( B
54. 
    
55. void UART_GPIO_Init(void)
    
56. {
    2 H0 X3 `6 T& c3 M2 d
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    " [9 ?& }& m& X( G# R8 j+ P
58. 
    , j& k: I5 t& c) M2 t
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
60. 
    9 ]( x5 x. B; f5 q& V% |% f
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    / T5 e0 o. B$ D4 }( V
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    " P" |2 v0 ]: M7 \$ x# {
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    : w3 L2 j( F; P) p: ^3 Y0 Z8 I
66. 
    
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    ; \9 P2 ?. Q! s* n( e
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    ' ]# t. m0 J5 t, \: E
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
71. 
    
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
74. 
    : F# [0 g. ]" o: f5 ?
75. }
    ) t5 h! C  `; _+ A
76. 
    % q, D5 n, |* E( H8 V4 I9 s; x1 l
77. 
    6 B3 r$ B2 q) h2 Q+ Q
78. /*******************************************************************************
    % s& }- D: b3 L! \+ {0 k' K
79. * @FunctionName   : UART_Init.
    
80. * @Description    : 模拟串口结构体初始化.
    : F1 P+ {0 E; l# T3 V4 W
81. * @Input          : None.
    
82. * @Output         : None.
    + n: I: j" l2 a/ K
83. * @Return         : None.
    7 `- |1 J, x. s: J# ?
84. * @Author&Data    : MrShuCai  2019.4.11.
    
85. *******************************************************************************/
    & S* h) T; C- i- b5 [- c* C5 `1 C
86. void UART_Init(void)
    
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    
89.     gsUARTBuff.UartMaxLength = Uartlength;
    
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    7 n6 U* O8 Z& |1 Z0 l. O
91.     UART_GPIO_Init();
    . d& ^, P$ J  F0 F( @
92. 
    
93.     if(BaudRate == 1200)
    
94.     {
    8 B) {& i; L" T6 H, T
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    + C8 @( [) {. o1 C& {
96.     }
    2 y( D( f( k0 h6 s- y
97.     else if(BaudRate == 2400)
    
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    
100.     }
     5 V0 C; k8 v! a# H2 A: v
101.     else if(BaudRate == 4800)
     
102.     {
     5 W( n7 W1 S: D: ?( j
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     
104.     }
     + G" [/ v+ m8 C! v. j' n
105.     else if(BaudRate == 9600)
     5 Z. [* l' ]8 n$ N' W8 K: R% _
106.     {
     
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     ) c- U. [4 ?5 @9 D7 Z5 X
108.     }
     
109.     else
     / Y% V6 X  x4 I" ?4 K
110.     {
     3 G, q8 j( o. G; B1 t5 c; ]$ ^
111. 
     * [# b! S+ l1 i% [1 N! z
112.     }
     
113. 
     & f) _$ {3 @- L) h) t9 ~$ _9 E, k
114.     MX_TIM6_Init();
     8 p+ n) K. \" n6 [5 H; _1 u; o
115. }
     
116. 
     
117. 
     " W' n6 I; |2 Y1 @  f
118. /*******************************************************************************
     
119. * @FunctionName   : UART_Send_Data.
     3 f# i' Z/ W' l- N* C0 n+ Z' g
120. * @Description    : 模拟串口发送数据接口.
     
121. * @Input          : None.
       p2 u! n: r2 A/ O8 m
122. * @Output         : None.
     
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     + `3 ~& @& |! X0 t
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     
127. {
     
128.     gsUARTBuff.Sendlength = size;
     # A$ T. S7 H# t3 ^* @/ g2 Q
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     6 X( L! T5 @3 ]6 \
130.    
     
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
132.         {
     
133.             gsUARTBuff.TxEn = 1;
     
134.             gsUARTBuff.RxEn = 0;
     
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     0 d/ ^8 w# t& S$ x& p) s! D
136. 
     
137.             TIM6->ARR = TimeSet[TimeSendStep];
     
138.             TIM6->EGR = TIM_EGR_UG;
     
139. 
     4 Q$ U9 n8 P9 b
140.             HAL_TIM_Base_Start_IT(&htim6);
     ) w5 [4 z/ f2 h
141.         }
     2 c7 g; x- Z# X
142.       
     ( r8 R4 j1 }8 u$ c/ U1 U3 S! m
143. }
     
144. 
     
145. 
     7 e  j4 Y* r; V
146. /*******************************************************************************
     + O9 _1 d% |" b8 s
147. * @FunctionName   : EXTI4_15_IRQHandler.
     
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     
149. * @Input          : None.
     0 v4 d# Y# H. l# `6 o. X
150. * @Output         : None.
     
151. * @Return         : None.
     * ]$ G3 }9 d9 Z7 }$ g  n; l, f  }
152. * @Author&Data    : MrShuCai  2019.4.11.
       l9 ]6 z! a- p+ d
153. *******************************************************************************/
       \& J3 r, L; ~9 B) D
154. void EXTI4_15_IRQHandler(void)
     
155. {
     
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     
157.     {
     
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
159. 
     9 e- F: }$ `0 G  H# o' t- d
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
161.         {
     
162.             gsUARTBuff.RxEn = 1;
     . l# b* u9 }. f) R3 b
163.             ucRecvData = 0;
     
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     6 t% E5 O. H1 L* y) u
165. 
     5 j2 Q9 ~+ Q) w8 p1 w
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     6 O, Q) k! D" {. f8 x; q
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     
168.                       EXTI->IMR &= ~(0x10);
     $ p' _/ Q& g, G" Y1 ^9 A( l
169.                       EXTI->EMR &= ~(0x10);
     5 I0 d+ ^, d) O& ^$ c/ A/ Q+ Y
170.             HAL_TIM_Base_Start_IT(&htim6);
     1 o6 T$ r  E' A
171.         }
     
172.     }
     2 X6 H7 T- ]: L4 ~. N+ P8 R& d( H& x
173. 
     
174. }
     ! E' t! g7 S$ z0 l) m  p+ T) a
175. 
     ' }) N6 E9 @) P* w+ U' n
176. 
     
177. /*******************************************************************************
     
178. * @FunctionName   : BitValueChk.
     
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     
180. * @Input          : n 采集记录的位值.
     
181. * @Output         : BitValue.
     3 o# r% i( @9 a& y7 u
182. * @Return         : BitValue.
     4 }; O0 I9 ?2 D4 y$ D
183. * @Author&Data    : MrShuCai  2019.5.1.
     9 p# k1 o: p) C' m0 e. b
184. *******************************************************************************/
     8 e5 e. {' G( D# Y
185. uint8_t BitValueChk(uint8_t n)
     
186. {
     5 I1 e9 T1 b' p& `0 O
187.     uint8_t BitValCx = 0;
     
188. 
     
189.     for(BitValCx = 0; n; n >>= 1)
     
190.     {
     1 J3 S9 M; m& Z6 c( S4 v* X  [( y
191.         BitValCx += n & 0x01;
     % U6 G+ P) Z7 Z0 M% E  v
192.     }
     - N( |- w2 r; Q- {
193. 
     6 G+ R. I8 ^% X. f7 Z/ D
194.     return (BitValCx < 2) ? (0) : (1);
     + _' y; B# y  m* @' r
195. 
     
196. }
     
197. 
     4 _- z$ `9 x. \9 u
198. /*******************************************************************************
     + g# d, d) i# L9 a
199. * @FunctionName   : TIM6_IRQHandler.
     1 `# }: r/ j" G$ N- a- @
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     7 {/ Y1 Y9 X' e/ ]! |2 ]/ N
201. * @Input          : None.
     8 \( G% ]1 K$ ]0 I6 M6 ]1 v( m
202. * @Output         : None.
     ( L1 y3 Y6 m3 r; e5 R
203. * @Return         : None.
     
204. * @Author&Data    : MrShuCai  2019.4.11.
     
205. *******************************************************************************/
     
206. void TIM6_IRQHandler(void)
     + d5 B% r" H+ Q$ d2 O
207. {
     
208. 
     ! v, C/ u$ {+ c8 M
209.     HAL_TIM_IRQHandler(&htim6);
     
210. 
     
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     
214.         {
     
215.         case COM_START_BIT_DEAL :
     
216.         {
     
217.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     
218.             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     ' S7 q" u5 v- z8 o
219.             ucSendBitCx = 0;
     
220.         }
     
221.         break;
     
222. 
     
223.         case COM_DATA_BIT_DEAL :
     4 w% j7 b( L% Q, G: m& \
224.         {
     0 D, f: x  {: T3 b/ y
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     
226. 
     
227.             ucSendBitCx ++;
     9 R: s8 H& S5 G' [5 M/ X2 l
228. 
     6 b5 c9 l2 X. e( ?' f& I+ Q
229.             if(ucSendBitCx >= 8)
     
230.             {
     
231.                 if(gsUARTBuff.CheckType == NONE)
     ! d- M- m) A; H
232.                 {
     
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     3 L' S& y3 x3 p( J- L' ]
234.                 }
     . r* m" ?$ i3 `2 k. Q& F
235.                 else
     
236.                 {
     
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     * m" Q1 I# ?# D: V" R# t! F5 F
238.                 }
     
239.             }
     
240. 
       i* r7 N; M; a( _- Q/ Y
241.         }
     
242.         break;
     
243. 
     
244.         case COM_CHECK_BIT_DEAL :
     ' Z5 k; e4 A7 p/ t- `8 \
245.         {
     2 `  U5 E' |; b" ~8 J
246. 
     
247.         }
     , \' P) H8 L8 s0 U. K
248.         break;
     
249. 
     
250.         case COM_STOP_BIT_DEAL :
     & X8 L+ q, ]" H; Y$ d
251.         {
     
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
253. 
     
254.             ucSendBitCx = 0;
     
255. 
     
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
257.             {
     6 v8 u3 j  L4 Z( O% f
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     
260.             }
     3 K7 e0 e" O9 q3 `
261.             else
     : x0 f# x& T6 {4 h$ @- f
262.             {
     
263.                 ucSendLengCx = 0;
     ) q- t  f9 E' g1 o. O5 i
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
265.                 gsUARTBuff.TxEn = 0;
     , D5 O+ \. N# [4 x, J+ |+ r. O
266.                 gsUARTBuff.RxEn = 1;
     + W2 o: C0 q% Q. }  S
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     
268.                               EXTI->IMR |= 0x10;
     2 Q8 g5 y% S8 Z$ `) L. w- F8 c) S
269.                           EXTI->EMR |= 0x10;
     
270.                 TIM6 ->CNT = 0;
     # R) K6 L; Z+ t  E
271.             }
     0 }5 Z7 D2 `: g1 i& g& x
272. 
     
273.         }
     9 m+ ]" n& |6 m
274.         break;
     ' ~& L" Y3 ~. s( H2 s
275. 
     * s- M" k7 E4 j  Q4 R  Z) ~* f1 D
276.         default:
     2 p: g' G, i# y2 ]
277.             break;
     - j  g+ k  ^' t$ _& ]
278. 
     
279.         }
     
280.     }
     " x2 ^/ W; V6 F0 |3 c
281. 
     
282. 
     
283.     if(gsUARTBuff.RxEn == 1)
     ! |$ O7 P" B! K: e( W; B% j
284.     {
     
285.         switch(gsUARTBuff.UartStat)
     
286.         {
     
287.                     case COM_START_BIT_DEAL :
     ; _; ~! R5 l, G$ [+ {2 D. J: [
288.                     {
     
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     7 S4 [$ L7 {! J( M
290. 
     
291.                             if(++ ucAcquCx >= 3)
     
292.                             {
     
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     
294.                                     {
     
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     7 ?# ]5 A0 ^! f( D( T2 o: A2 t
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     $ R- H3 H: g7 ~( s+ v  c# d
297.                                     }
     # A+ _2 b$ u) B
298.                                     else
     
299.                                     {
     
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
301.                                     }
     
302.                                     
     
303.                                     ucRecvBitBuff = 0;
     
304.                                     ucAcquCx = 0;
     $ }+ z9 K- \, |
305.                             }
     2 j5 z3 r- H# k
306.                             else
     
307.                             {
     1 H* u3 R6 ~$ I3 Q
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     5 q) O8 H! t& r( B* c, o' N
309.                             }
     * l8 v$ d) S9 S" |1 C9 v2 }/ A5 e
310. 
     1 b# p" v6 k( Z; g
311. 
     2 U& o- W8 q( P
312.                     }
     ! f* L+ i& h- L3 |9 ~  e
313.                     break;
     : A  I1 f% h2 k: n0 t# z: l' g
314. 
     . X; ^- x+ C6 u; w$ i) M5 N. v
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     6 \3 z! X% }0 [7 l; S2 F
316.                     {
     4 a) u! E- h0 w
317. 
     
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
319. 
     
320.                             if(++ ucAcquCx >= 3)
     1 Q! q4 ?0 Z. w* C* t5 q' ^7 s
321.                             {
     
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     
325.                                     {
     3 p0 k& C" I+ O1 H' h  W& i
326.                                             ucRecvBitCx = 0;
     0 d7 I! x" C: a5 X0 B
327. 
     ! b7 Q0 S% v9 C! B& Y8 X% K
328.                                             if(gsUARTBuff.CheckType == NONE)
     
329.                                             {
     & Y7 [$ M" `# _. [/ M6 n" K
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
331.                                             }
     
332.                                             else
     4 G! d- \9 {+ g2 w, Q' \
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     9 R, ]$ L3 Q" ?+ I/ i
335.                                             }
     / s( ^4 q" j; X  I, i
336.                                     }
     
337.                                     else
     0 |; U( V) K9 ^+ S; q
338.                                     {
     ; q1 F0 R2 P4 {- F1 F4 A
339.                                             ucRecvBitCx ++;
     
340.                                     }
     
341. 
     
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
343. 
     0 U* V; O6 f, ^; h1 W5 }
344.                                     ucAcquCx = 0;
     
345.                                     ucRecvBitBuff = 0;
     
346.                             }
     
347.                             else
     6 d% V0 h, t) N1 v
348.                             {
     " S$ ?7 K: L: }: B
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
350.                             }
     
351.                     }
     % Z6 X. q) `- a2 v2 F$ a5 F2 A$ X% t
352.                     break;
     
353. 
     & @" Q5 }/ {8 Y+ K8 F) z
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     
355.                     {
     5 L7 C$ g4 t; C9 R
356. 
     
357.                     }
     
358.                     break;
     
359. 
     
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     ) O8 F7 c  g) W. {
361.                     {
     : o, ?9 k: K  P
362. 
     
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     * F* d, b- Y3 H/ m8 j
364. 
     9 K9 @$ h1 J; n
365.                             if( ++ ucAcquCx >= 3)
     
366.                             {
     / i, r/ f* d- @% _. }
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     % R/ j" _! |% L# x& a7 N2 [
368.                                     {
     
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                                             {
     
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                                                     gsUARTBuff.Recvlength ++;
     ; _% v2 p- ]" I% u( |- o- a
373.                                             }
     % U, Q: I8 I) l0 K! o
374. 
     
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     ) B" Q3 D- g8 N2 r
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     
377.                                             
     / a% x4 A4 P, d
378.                                             EXTI->IMR |= 0x10;
     + v+ h; n: x3 s  O: [  M* c
379.                                             EXTI->EMR |= 0x10;
     
380.                                             TIM6->CNT = 0;
     ' G8 S2 P4 G3 j6 D2 k9 [; A) E
381.                                     }
     4 f1 V. X$ B, U' V- W/ O
382.                                     else
     1 i0 v! q; f# p  n( s5 `. B6 J# u
383.                                     {
     
384.                                             ucAcquCx = 0;
     ' E5 L, W1 `9 h7 p+ b% o" x. B4 A
385.                                     }
     
386.                                     
     
387.                                     ucRecvBitBuff = 0;
     
388.                                     ucAcquCx = 0;
     
389.                             }
     " x1 z5 E$ f7 y$ i1 j" M
390.                             else
     
391.                             {
     - G- g0 U6 `: Z9 ]5 Y/ t
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
393.                             }
     3 f6 Z" V* Y! h3 j4 F2 [
394.                     }
     + f$ P! |3 e! J2 E6 p# Z' l$ {
395.                     break;
     . }  `6 {0 }  k- E4 H' J/ X2 E
396. 
     
397.                     default:
     
398.                             break;
     + c# C# v/ V7 w' r9 a
399.                     }
     8 E, m# v2 a: o3 ]) i; Q
400.     }
     : f' |9 o3 s- |4 D7 E  M
401. }

复制代码

% A( v3 u) v+ U  {2 [8 P

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

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