一、设计用途：

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

二、硬件电路：

7 A& q# V# i/ `& p8 P# X7 q

: C1 P% D# M8 p' F
7 p# d: V' v% y, T* p

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

1 r4 P' I2 c  C( l$ T8 C
. M% h4 a" k! c; c; ^

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

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

" v( o- s7 f6 o; ?

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

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

硬件串口的噪声处理：

1 p5 m( ~- b7 W- `# B$ H' N

0 O# B% a: {% u5 i

# T$ {4 |1 D" K4 d( z3 S9 l) w1 W; u

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

7 K6 N8 o6 a1 m2 j

3、 实现方式选择

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

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

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

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

自写第一种实现方式：

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

# ^$ q. h0 k0 j% w# j+ K! p, d% }

1. #include "UartSet.h"
   - c' \; h0 `( C; @6 m8 r; I# |
2. #include "string.h"
   
3. 
   
4. uint8_t ucRecvData = 0;         //每次接收的字节
   
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   ; ~8 k4 l1 C% l0 l( r
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   - @7 I! x4 c. V
7. uint8_t ucSendBitCx = 0;        //发送位计数
   
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   . N9 x: C0 K9 s0 q9 b
9. 
   
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    9 Z1 R) W) t5 H1 l* E
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    + @% o/ E4 M/ {
13. 
    
14. uint32_t Prescaler = 0;
    
15. uint32_t Period = 0;
    
16. UART gsUARTBuff;               //定义串口
    
17. 
    
18. TIM_HandleTypeDef htim6;
    
19. 
    0 T' }2 r1 w1 @: r7 E
20. void MX_TIM6_Init(void)
    4 c+ P0 p9 A" w* o; A
21. {
    
22. 
    
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    
24. 
    2 m5 v( x) {4 ^  L: L
25.     htim6.Instance = TIM6;
    
26.     htim6.Init.Prescaler = Prescaler;
    " i: G; j# r2 o! ~
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    9 w0 Y$ B. ~7 ~( j* [+ u
28.     htim6.Init.Period = Period;
    ! S3 O4 y( K8 |8 B, a) F1 _4 ^4 Z
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    2 ^  Y- N- X$ A  T/ P
30. 
    
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    4 I% i( w$ o8 p1 ?* T7 o  j- ]
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
33. 
    5 U9 e& @/ V  ~
34.     HAL_TIM_Base_Init(&htim6);
    # w4 i% S4 d7 o( t  I
35. 
    & n- N& v' r+ _1 b" {' h
36. }
    8 o+ g2 S( t/ E/ U1 I* {! j
37. 
    
38. 
    6 a2 b# T( h5 v
39. void UART_GPIO_Init(void)
    
40. {
    ) x# f9 m+ Z: l; z; c7 _
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
42. 
    
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    - s3 `3 r/ N- \# K3 D7 m! O. \* l1 \
44. 
    
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    . K8 B1 j7 a" D6 Q* b$ ?) Z
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    # B* d' v1 T' R3 J6 b1 G
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    # Q+ U( r) N! I, H, _; P1 N) R
49.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    7 D) |4 W1 K* v2 b; o2 I
50. 
    
51.     GPIO_InitStruct.Pin = COM_RX_Pin;
    ) s$ E7 l: S8 x0 C
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    4 M3 F: U7 v+ Q2 b3 F5 l
55. 
    
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    / c3 ]& C$ A: Y" F8 q
58. 
    
59. }
    9 c+ o# b- @- |3 a" _
60. 
    
61. 
    
62. /*******************************************************************************
    
63. * @FunctionName   : UART_Init.
    7 d5 X$ l$ s  |
64. * @Description    : 模拟串口结构体初始化.
    
65. * @Input          : None.
    7 g! S/ a' B. v, x
66. * @Output         : None.
    
67. * @Return         : None.
    1 x3 Y" r' m7 Y  b
68. * @Author&Data    : MrShuCai  2019.4.11.
    
69. *******************************************************************************/
    4 x4 o+ O7 f# R
70. void UART_Init(void)
    ; ~+ x# a  L8 k- K% K* Y
71. {
    : S' W# t' H2 u  M. O0 H
72.     gsUARTBuff.CheckType = NONE;
    
73.     gsUARTBuff.UartMaxLength = Uartlength;
    ! S/ q. m. O; M+ a# R
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    6 p2 ~8 \2 L0 c
75.     UART_GPIO_Init();
    : V4 L& O  z+ ^
76. 
    2 X) G7 S* i; v
77.     if(BaudRate == 1200)
    
78.     {
    
79.         Prescaler = 15;
    
80.         Period = 623;
    & Q7 @: S% h: ]8 \
81.     }
      b6 J8 Q7 k9 M* H
82.     else if(BaudRate == 2400)
    8 ^" L# B- m  ~" u
83.     {
    
84.         Prescaler = 15;
    
85.         Period = 207;
    
86.     }
    
87.     else if(BaudRate == 4800)
    ' s0 N. ?7 L3 o9 }7 `8 @; m: W
88.     {
    
89. //        Prescaler = 15;
    ; X8 B& t; _% U" E5 Z, O
90. //        Period = 50;  //9600
    
91.              Prescaler = 15;
    / u& k& F, _, r
92.              Period = 103;
    
93.     }
    5 D* W1 Z, d3 C; {
94. 
    5 w6 |- Y: w8 ~
95.     MX_TIM6_Init();
    9 s+ D# q* w, c
96. }
    
97. 
    
98. 
    
99. /*******************************************************************************
    3 L1 Q: y2 x; C4 }) T4 `
100. * @FunctionName   : UART_Send_Data.
     ' [' g( j/ U6 N
101. * @Description    : 模拟串口发送数据接口.
     + }' j6 e1 \$ O  f
102. * @Input          : None.
     
103. * @Output         : None.
     ) D% Y) ]* ?0 M$ x
104. * @Return         : None.
     $ M" w7 z) [( P9 {
105. * @Author&Data    : MrShuCai  2019.4.11.
     
106. *******************************************************************************/
     ( b( _, H, w7 q" L1 B3 }, Z
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     
108. {
     ' c" S7 |9 L- H- O4 L) o2 U2 P
109.     gsUARTBuff.Sendlength = size;
     ( M5 P9 C0 d! i1 v& {8 N8 @8 `3 f
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
111.     gsUARTBuff.TxEn = 1;
     
112.     gsUARTBuff.RxEn = 0;
     
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     4 W' Y; k% s0 b9 ?& a
114.     HAL_TIM_Base_Start_IT(&htim6);
     
115. }
     * x, L- ?0 Z* v
116. 
     
117. 
     ( X/ i4 A* d, X0 X
118. /*******************************************************************************
     7 q$ w2 v# T3 M- g9 L
119. * @FunctionName   : EXTI4_15_IRQHandler.
     
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     
121. * @Input          : None.
     8 m, ^5 a# B! Q5 D2 m
122. * @Output         : None.
     / r3 }/ D0 ~3 Y  i/ [  L! \
123. * @Return         : None.
     / }% H! Q  Y, g# F; c* P
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     / l, C* D  l: ]2 S! _
126. void EXTI4_15_IRQHandler(void)
     
127. {
     
128. 
     6 C" r5 ]/ V; _  f$ [0 I- @
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     ; O- b; G9 X3 K7 Y4 O4 {
130.     {
     " A' Q$ p  d# l  w( P1 z* X* w
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     8 y8 V+ H# z" K: q1 X# E" u
132. 
     * j2 S$ ?5 E' P7 b
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
134.         {
     ( n! U+ ]% m3 e' m$ N6 H
135.             gsUARTBuff.RxEn = 1;
     
136.             ucRecvData = 0;
     2 a+ b, @" d4 T# P
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     7 G% {" |( }5 p- c' B5 ^! m
140.     }
     5 g3 o9 Z3 U7 l* n7 p4 j
141. }
     ( ?/ r+ Y  I1 O) F9 l% K
142. 
     1 a) p% }* k4 c/ ^/ {, Y2 c
143. /*******************************************************************************
     
144. * @FunctionName   : TIM6_IRQHandler.
     
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     
146. * @Input          : None.
     
147. * @Output         : None.
     
148. * @Return         : None.
     $ H5 d0 V! C, s( U+ y0 Y1 G9 r
149. * @Author&Data    : MrShuCai  2019.4.11.
     
150. *******************************************************************************/
     
151. void TIM6_IRQHandler(void)
     % b- e  t6 ?9 d- v7 y9 j
152. {
     & I( ]2 r3 `. P  B" e2 H
153.     HAL_TIM_IRQHandler(&htim6);
     
154. 
     8 [, t, O& I, R- M: X" t
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     
156.     {
     ( h( U+ ^4 x1 Q9 Z4 ]/ J
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     % q  ~0 h+ `! M4 z
158.         {
     6 W3 y, z% b" g# M1 L0 _
159.         case COM_START_BIT_DEAL :
     
160.         {
     
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     ( K" e+ b( v9 u! u0 y7 `/ q5 ~# y
162. 
     : `' k& ]' g& w: a# P2 z; b
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     ( d2 A  r; Z+ e% b/ z. R; w
164.             {
     4 k1 P# F: [# F: v  h% b* F; {  P* F1 o
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
166.                 ucAcquCx = 0;
     
167.                 ucSendBitCx = 0;
     : d* N( C9 _( ]: u5 R# t. ]# A
168.             }
     
169.         }
     6 `' `4 F, F& d
170.         break;
     / y0 N6 Q% f2 Z% M# H: s4 Z
171. 
     
172.         case COM_DATA_BIT_DEAL :
     
173.         {
     
174. 
     8 ?# K5 x* A+ x/ h
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;
     $ X+ b4 C7 t  i. r3 g6 x6 i' g3 w
180.                            
       _7 T) ]! {! D0 {0 [  p- C
181.                 ucSendBitCx ++;
     
182. 
     
183.                 if(ucSendBitCx >= 8)
     
184.                 {
       d' J$ @$ @7 h
185.                     if(gsUARTBuff.CheckType == NONE)
     
186.                     {
     7 n, m& F4 e$ `/ i
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
188.                     }
     ! O! f  M0 R. x, \& K% ~4 L4 ~" y
189.                     else
     
190.                     {
     
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     6 t8 ?8 f. F9 `9 m
192.                     }
     6 t9 U% Z9 X4 s5 k' w" m
193.                 }
     - q6 ~2 |+ g; I0 d9 U
194.             }
     6 i2 f" I" O0 E$ }5 d( l5 C+ z6 _
195.         }
     
196.         break;
     
197. 
     ! [+ @4 E# p; {
198.         case COM_CHECK_BIT_DEAL :
       H5 f: ?% Y) |0 w& \) O
199.         {
     
200. 
     . y+ I( E8 h% x! p6 u$ W
201.         }
     9 R' J, [6 C( P5 L" ]
202.         break;
     
203. 
     - f4 r0 z% C6 x& `) X0 y7 O6 y
204.         case COM_STOP_BIT_DEAL :
     : [1 Q. p' {* |  @& N4 y
205.         {
     
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     . _  @3 X  S5 x$ Q# u6 U3 H
207. 
     
208.             if(++ ucAcquCx == 7)
     
209.             {
     
210.                 ucAcquCx = 0;
     
211.                 ucSendBitCx = 0;
     
212. 
     ; ~* E9 [' N! Z' ?- l
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     1 L6 e  h5 b3 R) A& U
214.                 {
     
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ) ~% T) n( Y( G6 \8 O" n
216.                     ucSendLengCx ++;
     ' h9 s# Z# ~+ M0 J
217.                 }
     6 a. r/ z4 H& _! I5 J
218.                 else
     - k6 ]; e2 |% m& H) g2 l! m
219.                 {
     , P: r$ q, n! n1 g& l9 s
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
222.                     gsUARTBuff.TxEn = 0;
     
223.                     gsUARTBuff.RxEn = 1;
     , c9 i1 l7 f7 T9 t) e+ j# W9 ]
224. 
     + B+ f/ ]# Y$ k8 `: ?+ S: c8 d
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     , J: ^2 [1 B# `; u2 k
226.                     TIM6->CNT = 0;
     
227.                 }
     
228.             }
     
229.         }
     
230.         break;
     
231. 
     
232.         default:
     0 w6 n+ ~% X8 [8 S/ N' c( j8 X
233.             break;
     + X* V/ \( r7 m  q( }
234. 
     $ Z: m* X* {7 s) |
235.         }
     
236.     }
     3 l% u. x3 ]+ h  t/ E" E: D
237. 
     + w, e2 r) C, t* j
238. 
     & R8 o4 b% s2 C5 H5 l8 _
239.     if(gsUARTBuff.RxEn == 1)
     . l6 T$ c" }/ r4 C( L. C5 s: [
240.     {
     ! p2 b0 d7 h2 x% y$ Z, o
241.         switch(gsUARTBuff.UartStat)
     ; C. K) y+ T% {# w
242.         {
       {5 g7 X' N) A5 y- ?
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     
244.         {
     & W5 O( H7 x) e6 e4 k) d) V
245.             ucRecvLastBit = ucRecvNowBit;
     ; m2 @" o/ m5 e5 r4 P6 q9 d) d
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
247. 
     
248.             if(    ucAcquCx == 0)
     
249.             {
     7 }3 {- t! g7 y8 p# k
250.                 ucAcquCx = 1;
     ( U9 t+ Y4 r+ s( r( {5 N
251.                 return ;
     
252.             }
     - o2 q) B# o$ x8 x: b+ ~4 D% w
253. 
     / s0 w# S& E( R& P0 |1 B  M( a% N
254.             if(ucRecvLastBit == ucRecvNowBit)
     
255.             {
     ( k6 S3 k2 Y6 b. ~- C8 e
256.                 ucRecvTrueCx ++;
       m- F$ D  @& g( {# b4 j
257.             }
     / A, X; o4 u4 F9 L
258. 
     
259.             if(++ ucAcquCx >= 5)
     
260.             {
     , Q8 a* j4 v5 S8 U, v& t& g
261.                 if(ucRecvTrueCx >= 2)
     2 X0 O1 r; d! M5 t: t2 U
262.                 {
     1 d- C) c$ e# S! Y5 C" Z4 }
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     ! L1 k/ K; Y" n+ W' [8 Y. B7 Z
264.                     ucAcquCx = 0;
     
265.                     ucRecvTrueCx = 0;
     6 ^& z( R# u" }$ m
266.                 }
     " a) o- M7 Z/ a! B
267.                 else
     
268.                 {
     
269.                     ucAcquCx = 0;
     
270.                     ucRecvTrueCx = 0;
     
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
272.                 }
     8 Y1 W  \" f; \' u+ I6 g! \5 E
273.             }
     
274.         }
     
275.         break;
     
276. 
     
277.         case COM_DATA_BIT_DEAL :                         //数据位
     ' E# o6 R6 G* f; a: ~, E
278.         {
     # F; B) K- h" d9 ~  H5 E
279. 
     # l4 @; b0 B8 g; s
280.             ucRecvLastBit = ucRecvNowBit;
     
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
282. 
     1 E- f) ?& N0 a( h$ W3 ?, i% n+ \
283.             if(0 == ucAcquCx)
     9 g8 g# M+ }8 W' ~& r6 a3 s$ o7 |
284.             {
     
285.                 ucAcquCx = 1;
     1 B( [& I: ^2 M# F: r
286.                 return;
     
287.             }
     2 v8 k) ]9 D! |' ^% E' ~
288. 
     7 q* ?. c, M$ x6 l4 ]
289.             if(ucRecvNowBit == ucRecvLastBit)
     8 h- T0 o; K# Q: ~7 x+ u$ \
290.             {
     $ B% K  [- \. S" x
291.                 ucRecvTrueCx ++;
     
292.             }
     " r! |, H( ?& }! N+ [' T
293. 
     
294. 
     
295.             if(++ ucAcquCx >= 6)
     9 W" e1 b4 Z/ L3 F3 l# u% J, e, r
296.             {
     
297.                 ucAcquCx = 0;
     + v- p+ ]$ w; E0 E0 @; P  [" g5 o
298. 
     - Q! |( J( H! N4 g3 J  R
299.                 if(ucRecvTrueCx >= 2)
     3 c# g; q  H" @- w- l( r" M7 ~
300.                 {
     5 a4 B7 C  `" w- r$ T* w& E7 K  _
301.                     if(ucRecvLastBit == 1)
       H' ]" c5 |" y; y$ S: l, R6 z
302.                     {
     
303.                         ucRecvData |= (1 << ucRecvBitCx);
     ; r3 {, T8 A0 j
304.                     }
     7 K, `" _, m6 Z; Y+ ^  ]) f
305.                     else
     " t5 |, y1 l" k0 a
306.                     {
     
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     ! c5 l0 C1 d5 k+ s& }* U
308.                     }
     
309. 
     & p% E% C9 L- s* d5 ~
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     4 o" t& {! Y3 s6 H' ?
313. 
     
314.                         if(gsUARTBuff.CheckType == NONE)
     
315.                         {
     2 r( C; ?' W4 d; ^3 P0 a. y
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     4 x% _. }, E5 @& O! Y+ B8 o% t8 B
317.                         }
     8 H0 Z* ^! s0 Y3 Y, g6 S; H
318.                         else
     ' D+ N3 T5 f/ b# v; Z0 D* ], f* f8 ^
319.                         {
     ) p  o5 r3 B# s' w" W
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     3 h6 e) {! l5 t0 x, r" U* E
321.                         }
     
322.                     }
     
323.                     else
       `; T! D) a/ ?8 Z5 F
324.                     {
     
325.                         ucRecvBitCx ++;
     
326.                     }
     + f1 A7 K. K6 j+ f) H3 c! W% A8 u8 v
327.                 }
     
328.                 else
     3 }7 C' t$ o: ~
329.                 {
     , l! X8 l8 t- B; h' p6 q
330.                     ucAcquCx = 0;
     
331.                     ucRecvTrueCx = 0;
     
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
333.                 }
     
334.             }
     ! t& P6 o9 q8 ~1 Z
335.         }
     & s4 R" g; q) M
336.         break;
     
337. 
     
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     4 T  t# D2 E0 A" g6 K9 \
339.         {
     1 ~4 r" V, ~; X: h: x% T  b
340. 
     , d; _# g8 e3 }0 e
341.         }
     & R: X) y5 |- N7 K! o  Z
342.         break;
     
343. 
     
344.         case COM_STOP_BIT_DEAL :                         //停止位
     
345.         {
     
346. 
     
347.             ucRecvLastBit = ucRecvNowBit;
     ! S. Q6 H  l2 R: c1 ~, ]7 T1 B
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
349. 
     $ n* ]3 W1 k' d! R5 z: O
350.             if(0 == ucAcquCx)
     ' S- e1 T& I1 b9 l3 H9 C3 L
351.             {
     5 z2 V( \; e# T( ^/ k  V0 c9 [4 G
352.                 ucAcquCx = 1;
     
353.                 return;
     " W7 ^4 H# ]3 M; a
354.             }
     8 e. m# y- @! w- }. U
355. 
     
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     
357.             {
     ( |4 @* s- b0 S* d5 ^
358.                 ucRecvTrueCx ++;
     - T5 D/ s  @) S5 g0 p& Y* o* N
359.             }
     
360. 
       ~' a2 c1 W6 |0 ~- x# q2 G
361. 
     
362.             if( ++ ucAcquCx >= 6)
     
363.             {
     8 K/ y2 P+ Z2 p/ `# G3 k1 u
364.                 ucAcquCx = 0;
     
365. 
     
366.                 if(ucRecvTrueCx >= 2)
     * [6 ]  J/ y$ u+ X) f
367.                 {
     1 i: A! |) w- T' G$ `
368.                                       ucRecvTrueCx = 0;
     8 Z# [" D  R, t; J" J# Z& R
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     ) J: h# t- @9 j" Q! D* F
370.                     {
     
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     5 n2 y0 Y" |4 O" G- u
372.                         gsUARTBuff.Recvlength ++;
     5 P! h% |& O% ^$ w
373.                     }
     ! r& w) t3 H: K$ y% D' @/ x
374. 
     " C. u/ d' ?9 i1 J% h' a# V+ @
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     9 T' e+ }* }3 T( f1 d7 C% C1 }
377.                     TIM6->CNT = 0;
     ; Z8 B+ P5 n# O6 ]
378.                 }
     
379.                 else
     5 c: W) \" x+ ^# Z3 O
380.                 {
     
381.                     ucRecvTrueCx = 0;
     
382.                 }
     
383.             }
     # \9 Q( ]/ f! c0 d% b$ W
384.         }
     + w: c) X/ H3 ?3 i
385.         break;
     
386. 
     
387.         default:
     
388.             break;
     - ]& P+ G/ ]3 W  [* ^0 j8 e
389. 
     / X6 _2 J( ^0 J/ n6 s& a* E
390.         }
     6 L7 w: x: P3 B2 U* B( [8 N) u
391.     }
     * q' s9 C+ g. Z( @8 L+ S) s
392. 
     6 w( w5 A4 S8 J1 \( g, e- o5 A
393. }

复制代码

- X' k. H5 l* d. v0 \

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

4、 最优实现

# k4 L3 k/ j; G7 y& x( A5 g

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

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

1. #include "UartSet.h"
   % b( P+ E! A( \" l
2. #include "string.h"
   9 v# _9 a% h, z0 Q6 W" W5 [% R
3. 
   - [5 R3 y% }. r" \# G
4. typedef enum
   0 o4 A- n# e' Q  ~# J0 j/ X  J
5. {
     {* [; Q0 q8 n
6.     TimeRecvStartStep1 = 0,
   % \6 z% D$ v- |
7.     TimeRecvStep2 = 1,
   6 D' u6 y' _9 A, Y
8.     TimeRecvStep3 = 2,
   ' S! f. E# c/ i9 p, I& e4 u/ r
9.     TimeRecvStep1 = 3,
   3 k' N; L/ w5 g# I( K  z, ^* J
10.     TimeSendStep = 4,
    4 `) G8 z" T- U/ r( c
11. 
    0 g: V1 [  o1 y/ X% r, ]% F5 a. r
12. } TimeStep;
    " |0 M* Z5 c4 \; @
13. 
    
14. uint16_t TimeSet[5];
    
15. 
    
16. uint16_t TimeSetBuff[][5] = {{1199, 59, 59, 2378, 2498 }, //1200
    
17.     {539, 59, 59, 1128, 1247 },  //2400
    1 y% _3 J; t! H5 u
18.     {239, 59, 59, 503, 624  },   //4800
    
19.     {149, 29, 29, 251, 311  },   //9600
    - u; x1 E/ t+ ?# G5 w6 o/ K
20.     {0, 0, 0, 0, 0    },         //预留
    7 t, ~1 D6 a/ |, P1 u2 W
21. };
    . O- y( b/ h/ e3 k3 a
22. 
    / ]3 t& r  Q$ Q" P, O% {
23. UART gsUARTBuff;                //定义串口
    / K, }! w" y. l5 W- h& e
24. 
    4 f$ ]# S' b/ E. f$ Y2 ?9 n
25. uint8_t ucRecvData = 0;         //每次接收的字节
    
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    * w. b/ X. p4 C: f! W6 c
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    ) h4 e6 h5 u0 A6 W  \
28. uint8_t ucSendBitCx = 0;        //发送位计数
    - A4 V" y; l- ]2 g0 Y" E, v
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    7 o' F+ R" j$ }" c# X1 }
30. 
    & q9 r* T/ H; ?" i) G/ R) |( N+ ~! |
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    4 j2 C, Q/ B8 W
32. 
    
33. 
    
34. TIM_HandleTypeDef htim6;
    
35. 
    
36. void MX_TIM6_Init(void)
    - N4 h- R9 k, Z, s
37. {
    
38. 
    # F3 \0 K4 B  y+ c; F4 r
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    ( g. t! d* N7 M  b3 F$ s/ }. Q
40. 
    ; J! ~5 ?# }8 q
41.     htim6.Instance = TIM6;
    
42.     htim6.Init.Prescaler = 15;
    
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    * l8 U" p6 }6 J) @% J) ^, d
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    1 e% K! u8 R3 i
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    1 V6 n0 D! @+ _
46. 
    
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    4 ^9 s2 C% e5 `" k" x
49. 
    ! n% ~9 {/ b7 v1 q8 l7 ~. a
50.     HAL_TIM_Base_Init(&htim6);
    
51. 
    : o6 H) C# |3 M. G1 q4 G+ F& |; p
52. }
    / m0 b, V3 B6 j" p5 R
53. 
    ; k- K, O5 V( J$ S- u. j4 W4 K. X  i
54. 
    0 ^; a" k% I( S( e* C) P# g: Z
55. void UART_GPIO_Init(void)
    : y. @4 m4 E3 G6 H, D6 F
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    5 |1 }( }$ [( J5 D7 O+ X# ]
58. 
    . D: W+ R; m) ^
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
60. 
    
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    6 q3 D7 N6 a2 H7 x9 S4 J# O
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    3 j1 F& K0 d/ M2 A( g7 {1 Q
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    . ~! C# J6 J; n; m( @2 Y
66. 
    9 p  Z2 Z* j0 u
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    $ D) C* ^4 G6 g* w
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    $ b5 B! |2 D" K5 Q
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
71. 
    : f0 Z, ~  S! j  O
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    3 Z) b" v8 a& _
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
74. 
    
75. }
    
76. 
    
77. 
    
78. /*******************************************************************************
    
79. * @FunctionName   : UART_Init.
    6 [' d1 p) r4 w; ^
80. * @Description    : 模拟串口结构体初始化.
    
81. * @Input          : None.
    
82. * @Output         : None.
    
83. * @Return         : None.
    
84. * @Author&Data    : MrShuCai  2019.4.11.
    
85. *******************************************************************************/
    , F9 J: |5 L3 V% p+ [- \6 h
86. void UART_Init(void)
    1 F3 W+ x2 U/ [
87. {
    5 k! z# m( c. W5 S2 l
88.     gsUARTBuff.CheckType = NONE;
    : b+ v: G7 ]4 H/ O7 y1 O; m0 J
89.     gsUARTBuff.UartMaxLength = Uartlength;
    
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
91.     UART_GPIO_Init();
    0 _' a$ p& @! A6 e# ?* ?
92. 
    ; j! v! A# L# w6 E$ `! i
93.     if(BaudRate == 1200)
    6 o( ?2 W' B4 u$ ^
94.     {
    
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    & o# i' ]. L- i; J4 U) o: J
96.     }
    * P2 r& H3 q+ |! i6 n
97.     else if(BaudRate == 2400)
    
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    
100.     }
     
101.     else if(BaudRate == 4800)
     . E: ?2 W/ C2 x& X- l* z
102.     {
     
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     : s, _1 o2 _( ?5 g% Q% k' e" ^6 F
104.     }
     $ f2 H1 s1 o  }+ u9 q+ s
105.     else if(BaudRate == 9600)
     : y9 x7 Z- k5 _1 m( `% R
106.     {
     ' f3 l) t1 q5 x' t" `
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     ! O( P( C/ s  L) g  `- z
108.     }
     
109.     else
     # x; z4 e# ]: @* I5 z
110.     {
     ; I7 K7 n9 D5 W  @% X! B/ `
111. 
     
112.     }
     / ?" U' X* x) R" }. |/ R
113. 
     4 A& r% u' \6 M2 a9 U! e
114.     MX_TIM6_Init();
     
115. }
       {8 e4 z7 j+ Y; I* `
116. 
     6 s. I! [# Z# F" q9 w; a5 |
117. 
     . T! T+ u- i9 I  r  [$ I/ T0 Q; y! |! c
118. /*******************************************************************************
     8 Q: `, {: f' r, H$ Y
119. * @FunctionName   : UART_Send_Data.
     0 {+ y) Z/ t3 e3 T
120. * @Description    : 模拟串口发送数据接口.
     
121. * @Input          : None.
     8 `, Z! l) I5 y; P) e* @
122. * @Output         : None.
     
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     + c8 p% P; c! C+ c9 ?/ I  X- c7 N
125. *******************************************************************************/
     9 T1 l( k) w' B: c) ^
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     
127. {
     " C4 Q7 g8 o# |
128.     gsUARTBuff.Sendlength = size;
     / ]7 O! L7 }. `& i9 I& N  H' j
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     ( z0 z, n( J1 ]7 @5 L
130.    
     
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
132.         {
     / _  y3 i; Y! j. {& R8 f  g
133.             gsUARTBuff.TxEn = 1;
     ' R7 U2 l, ^; ]1 I+ ?) a
134.             gsUARTBuff.RxEn = 0;
     - A) v. \+ L- o6 Y) r% E
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     / ^4 O1 i* `9 \+ Z
136. 
     " p6 o# J% I% h- W/ d
137.             TIM6->ARR = TimeSet[TimeSendStep];
     
138.             TIM6->EGR = TIM_EGR_UG;
     8 P# C/ O, }; w) a% p5 N
139. 
     
140.             HAL_TIM_Base_Start_IT(&htim6);
     * N% d" q% Y. i) X
141.         }
     2 t/ q# B8 _# v4 X% G
142.       
     
143. }
     % c8 f3 _7 O0 `7 Z. S( Y, Q( g
144. 
     8 Q; M5 o& t( B3 C3 w- o1 K2 l
145. 
     ' Z" c  |4 I( i: M7 R8 \. ^
146. /*******************************************************************************
     
147. * @FunctionName   : EXTI4_15_IRQHandler.
     1 c. s0 ~3 @* \  W8 U' P
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     3 c& ]7 F) m# ^* ~: _
149. * @Input          : None.
     2 r) v+ }* }* s  \7 p' l
150. * @Output         : None.
     
151. * @Return         : None.
     
152. * @Author&Data    : MrShuCai  2019.4.11.
     # n+ f7 Z6 W3 f  t6 w
153. *******************************************************************************/
     9 Y6 S& B# `( h' d  @- l
154. void EXTI4_15_IRQHandler(void)
       [& i9 L* N. ]7 I2 g
155. {
     3 V9 r6 k7 T. Q
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     : l* {6 s# ~1 Z+ ~% m
157.     {
     
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
159. 
     
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
161.         {
     
162.             gsUARTBuff.RxEn = 1;
     
163.             ucRecvData = 0;
     
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     , x; f- W8 E' N; z$ v2 i( y$ A* Z
165. 
     
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     9 A$ X- D7 u3 S' W' a( f- L
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     
168.                       EXTI->IMR &= ~(0x10);
     ; `: l' ~' v9 `! p& H3 {9 `
169.                       EXTI->EMR &= ~(0x10);
     + o4 N3 P2 b# s' ~2 q( l& M
170.             HAL_TIM_Base_Start_IT(&htim6);
     
171.         }
     
172.     }
       _( o9 J4 u/ Y. {! ?5 v
173. 
     
174. }
     
175. 
     
176. 
     9 S! }0 N: X7 ?
177. /*******************************************************************************
     
178. * @FunctionName   : BitValueChk.
     , ?1 o. F4 ^  H. d# d. l! F
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     0 A/ l: Z: ~" S( J3 j9 O2 b
180. * @Input          : n 采集记录的位值.
     
181. * @Output         : BitValue.
     . X9 F& d$ }% d) }
182. * @Return         : BitValue.
     - t7 {; X3 F1 M& b4 w
183. * @Author&Data    : MrShuCai  2019.5.1.
     $ a2 A! w' B# S) j2 w
184. *******************************************************************************/
     
185. uint8_t BitValueChk(uint8_t n)
     
186. {
     0 q3 T, R+ E: |1 X: t* H
187.     uint8_t BitValCx = 0;
     7 `1 e5 b/ g  c4 o+ Q4 c
188. 
     
189.     for(BitValCx = 0; n; n >>= 1)
     % }: `. E: ?/ K* Z# k
190.     {
     ! G) Y4 Q3 r; E# h4 X9 u* M* T2 u
191.         BitValCx += n & 0x01;
       C  i9 c! l4 T" v  D4 h
192.     }
     
193. 
     
194.     return (BitValCx < 2) ? (0) : (1);
     8 B" R. b1 ^  B5 @# G: p( B; k9 P
195. 
     
196. }
     
197. 
     7 i) t- k2 [9 G
198. /*******************************************************************************
     $ S0 z, i' G. s. B4 H" b7 {
199. * @FunctionName   : TIM6_IRQHandler.
     8 m9 J2 B2 x3 {% o, y9 E
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     
201. * @Input          : None.
     2 s: }; F( o) U" n! L
202. * @Output         : None.
     
203. * @Return         : None.
     
204. * @Author&Data    : MrShuCai  2019.4.11.
     
205. *******************************************************************************/
     5 E- G2 G$ [; C; H3 k% Q
206. void TIM6_IRQHandler(void)
     2 I) w" I8 Y8 L0 r/ E& i
207. {
     
208. 
     
209.     HAL_TIM_IRQHandler(&htim6);
     3 I/ @0 E$ ?% R& X: v
210. 
     
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     * @! g/ |; D: \) _
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     $ J4 e; D/ \  L- o! l2 T
214.         {
     ; X9 b! N/ W' C( D8 }9 k
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;
     
219.             ucSendBitCx = 0;
     0 R6 s- x6 u: F9 ^/ D, v
220.         }
     7 V  o# n5 Y; f0 _( M/ p! Y
221.         break;
     2 L' t* d: j6 x, P) l) t) m9 h
222. 
     
223.         case COM_DATA_BIT_DEAL :
     % m# R7 S3 t0 a( e% H0 }
224.         {
     % ?9 Z& T/ U! g. K: T
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     
226. 
     
227.             ucSendBitCx ++;
     6 x6 r- A8 Z' v5 ?! _1 M& t" {
228. 
     & |5 E: b, _8 j1 R7 [
229.             if(ucSendBitCx >= 8)
     4 Y) [) x$ R" ]1 b% N/ Z9 M4 S3 R
230.             {
     
231.                 if(gsUARTBuff.CheckType == NONE)
     ; b% d, ?% X$ Q4 a* J2 F- N$ \
232.                 {
     
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     ) c% T# O' ?3 f# f4 T# n
234.                 }
     
235.                 else
     ( D9 a8 V  ?- w  C+ ~4 Z
236.                 {
     - q) ~- M9 W. l8 w
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
238.                 }
     / X' F7 m/ D! O' p" t
239.             }
     
240. 
     
241.         }
     # q" I  }( _8 u5 `# x9 P: A9 ~
242.         break;
     % _9 x6 i9 j* u( }% b7 ?
243. 
     
244.         case COM_CHECK_BIT_DEAL :
     6 i! K1 l. Y! I% E. n2 {6 p* {- g
245.         {
     ; S! I$ Z3 w8 ?7 b; b
246. 
     6 a+ X+ k$ s' T7 g; x: f% J; A
247.         }
     
248.         break;
     * M7 E! z/ A5 [
249. 
     ; k8 ?3 ?1 o. R, @' a' P
250.         case COM_STOP_BIT_DEAL :
     
251.         {
     
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
253. 
     ' g9 J' `; [6 N7 v0 b
254.             ucSendBitCx = 0;
     ; B" a$ b; I# E" z: A' d& G6 b. C) {
255. 
     
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     0 b# Q& R- s% `" Y$ d8 [7 J3 O: w
257.             {
     " K7 f; I) Y% S+ F8 g
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     
260.             }
     
261.             else
     
262.             {
     
263.                 ucSendLengCx = 0;
     ' \0 O% h! S3 s# b" A
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     7 W+ c! x; R3 d8 P
265.                 gsUARTBuff.TxEn = 0;
       U9 m& G, O4 _1 m* f  L- k
266.                 gsUARTBuff.RxEn = 1;
     
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     2 Y' w; @! L2 \' i8 p. [2 Q: ^
268.                               EXTI->IMR |= 0x10;
     7 _& N% X' I( c" n# u
269.                           EXTI->EMR |= 0x10;
     , m/ [9 }" T- b* n
270.                 TIM6 ->CNT = 0;
     
271.             }
     
272. 
     
273.         }
     
274.         break;
     + w, A8 z# b: P
275. 
     + l0 n, W- f$ ?7 x9 U5 ?
276.         default:
     
277.             break;
     3 G! g' C% U$ C4 P* l+ @: L
278. 
     + {4 j9 U+ Z. ^
279.         }
       S9 {$ `9 R! g
280.     }
     
281. 
     ' i* b/ F) {) \0 ], J
282. 
     6 q4 |% D; w0 C1 o9 u
283.     if(gsUARTBuff.RxEn == 1)
     
284.     {
     ) C8 p; ?2 _, B5 q# p9 ~
285.         switch(gsUARTBuff.UartStat)
     5 p' [) I7 i2 b, f
286.         {
     
287.                     case COM_START_BIT_DEAL :
     
288.                     {
     2 T, O, s  s1 X6 h/ u& j5 ]/ ]
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
       a. M6 C7 }  |+ t) O7 R
290. 
     6 L$ ]( P& R" g7 W. h
291.                             if(++ ucAcquCx >= 3)
     
292.                             {
     
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     . `; i) _+ h, W- C# J3 U
294.                                     {
     9 ^) S* {6 X" V/ `7 t+ b9 ^
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     
297.                                     }
     
298.                                     else
     
299.                                     {
     1 a$ `, ?9 T! h/ H' T
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
301.                                     }
     
302.                                     
     
303.                                     ucRecvBitBuff = 0;
     : C9 F0 `7 {% v6 R! ]
304.                                     ucAcquCx = 0;
     . Z& k. ^/ d9 M1 J' e& e* {. p6 _
305.                             }
     
306.                             else
     
307.                             {
     
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     / Y* E/ l# d* |8 w/ G. `8 L
309.                             }
     
310. 
     # C$ @6 E# a: c+ u" n5 K
311. 
     
312.                     }
     * c3 Y3 ~( h  g  [$ c8 l
313.                     break;
     
314. 
     0 O: o7 P1 A, ~
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     9 r$ g9 ^& F( K/ }4 E$ A
316.                     {
     4 I, x/ Y. X# J8 q( {
317. 
     ; Z/ A4 y5 h# O, k( [+ n% F
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
319. 
     
320.                             if(++ ucAcquCx >= 3)
     
321.                             {
     
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     & h( a8 z' b1 _4 K) O
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     
325.                                     {
     
326.                                             ucRecvBitCx = 0;
     ) @" h$ X- C, T$ k" s9 Y7 H
327. 
     , Q" E: h$ V# e9 f
328.                                             if(gsUARTBuff.CheckType == NONE)
     ! s4 l; A! W" F
329.                                             {
     % {" g# \5 f' ^" e
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
331.                                             }
     / z0 R% _! @* r: r
332.                                             else
     
333.                                             {
     . d+ h; H7 L! z7 R
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     ) b; q& Q6 n: \7 P
335.                                             }
     $ h# E* q; C% {; B. c
336.                                     }
     
337.                                     else
     
338.                                     {
     
339.                                             ucRecvBitCx ++;
     
340.                                     }
     
341. 
     2 v9 G6 B" `7 J. m7 D5 u6 _: i! O
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
343. 
     
344.                                     ucAcquCx = 0;
     
345.                                     ucRecvBitBuff = 0;
     $ r' P; F) z5 }5 }1 B
346.                             }
     4 U+ C# u3 I# P* {4 a
347.                             else
     
348.                             {
     
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
350.                             }
     
351.                     }
     # ?) m+ R  s. `
352.                     break;
     
353. 
     
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     
355.                     {
     3 q! {" K6 X8 g& [& a) @. L$ O5 f
356. 
     / B; d( V& j9 ~6 \7 Z$ _  p
357.                     }
     
358.                     break;
     
359. 
     # v4 n$ b. f& q+ j+ C5 T
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     ' I* [0 m. X5 _1 r7 S3 \/ v
361.                     {
     " C9 E& p, j$ [2 Z& ]+ G, I
362. 
     $ Z+ w& `  U+ p; z
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     
365.                             if( ++ ucAcquCx >= 3)
     7 j6 ?2 E3 W3 D  k4 L
366.                             {
     0 g6 [7 y+ U' z" z; S
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     
368.                                     {
     3 V( a: Q. o1 p
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     4 B! Z6 Q! x2 n' y$ X3 d$ o
370.                                             {
     
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     ( Q3 [; Q$ N5 P  l) t
372.                                                     gsUARTBuff.Recvlength ++;
     ) J- |6 @% s& R7 O/ a: c
373.                                             }
     6 Y3 w! Y5 A, k0 c2 H
374. 
     
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     ! K" v8 W9 ]. z5 Y, i7 f, O0 ~
377.                                             
     6 K/ `( l! l" c1 p
378.                                             EXTI->IMR |= 0x10;
     4 x: h# [, q+ }& h
379.                                             EXTI->EMR |= 0x10;
     
380.                                             TIM6->CNT = 0;
     
381.                                     }
     % n2 a  `) d0 A
382.                                     else
     5 o: n% ?( r1 H6 S4 Y3 B9 N2 M, y; E/ E
383.                                     {
     
384.                                             ucAcquCx = 0;
     
385.                                     }
     4 A- p$ ~: z" Y$ a8 I  T
386.                                     
     9 K9 X  C& r/ H( I! C0 v$ ~
387.                                     ucRecvBitBuff = 0;
     $ p: @+ ^# @, G2 A
388.                                     ucAcquCx = 0;
     4 \5 ^9 Q, {- A% e2 D$ ]. j
389.                             }
     
390.                             else
     
391.                             {
     5 X. n* l$ H+ ^9 G( l
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     $ w6 _3 Q$ i1 }5 s1 {
393.                             }
     
394.                     }
     3 x  H/ N+ k. \  e& i3 p7 ?, j
395.                     break;
     " h% [/ o+ L6 d" a" X5 d) J
396. 
     
397.                     default:
     2 S5 S9 i% v$ d9 b  }
398.                             break;
     ) @. {3 w1 Z0 C0 S/ q+ u
399.                     }
     
400.     }
     . ?3 N; Z9 G, Z# C' |! D) }+ N
401. }

复制代码

: m! `1 S; A1 Q% K  L

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

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