一、设计用途：

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

二、硬件电路：

2 G, |. G2 \5 A4 S% s3 ?

三、设计实现：

工具&软件：STM32F030R8    KEIL5    STM32CubeMX

1、 串口通信

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

+ E  b: [! b- `: X" f- u; _

' t. f" a7 Q- K

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

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

  r% p5 W7 n( q! g

- e8 l5 ]8 D$ o5 I2 r# y

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

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

硬件串口的噪声处理：

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

) A* X/ C/ y5 I0 Z" q& q) n

3、 实现方式选择

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

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

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

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

自写第一种实现方式：

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

1. #include "UartSet.h"
   ' J8 A& {5 o0 m, |# w2 _
2. #include "string.h"
   ; K. O8 E2 w2 w, F0 x' C  A8 f" l1 R
3. 
   
4. uint8_t ucRecvData = 0;         //每次接收的字节
   # D% ~7 g' \, W. {; ^7 x
5. uint8_t ucAcquCx = 0;           //三次滤波计数
   + s$ D5 G3 Q. ~8 t7 @5 T) T. R
6. uint8_t ucRecvBitCx = 0;        //接收位计数
   1 a& H' y$ T: E3 |
7. uint8_t ucSendBitCx = 0;        //发送位计数
   
8. uint8_t ucSendLengCx = 0;       //发送长度计数
   
9. 
   8 w  A1 C9 J$ J0 `0 M  w
10. uint8_t ucRecvLastBit = 0;     //上次接收位记录
    
11. uint8_t ucRecvNowBit = 0;      //当前位记录
    
12. uint8_t ucRecvTrueCx = 0;     //正确计数
    
13. 
    
14. uint32_t Prescaler = 0;
    
15. uint32_t Period = 0;
    9 u0 c5 U5 T* _1 d
16. UART gsUARTBuff;               //定义串口
    
17. 
    
18. TIM_HandleTypeDef htim6;
    & X' h& C- D/ d$ @" z" b" _2 x
19. 
    8 V/ k2 g1 P  Z* X
20. void MX_TIM6_Init(void)
    ! d" L8 u- a4 v3 {: n
21. {
    
22. 
    1 U8 `4 q- b$ E9 H$ @" W7 u
23.     __HAL_RCC_TIM6_CLK_ENABLE();
    : d+ ^1 A0 A0 W; N5 ]
24. 
    
25.     htim6.Instance = TIM6;
    4 ^; B2 a( @+ r' ^7 i
26.     htim6.Init.Prescaler = Prescaler;
    
27.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    + [2 B0 n! i& y+ d) `
28.     htim6.Init.Period = Period;
    
29.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    4 F5 W6 u5 h5 _+ c- e
30. 
    / F4 i0 z8 B) G8 ]- c& a+ F
31.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
32.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
33. 
    
34.     HAL_TIM_Base_Init(&htim6);
    $ Z+ X4 o8 P% t
35. 
    
36. }
    
37. 
    
38. 
    
39. void UART_GPIO_Init(void)
    / P1 i0 D: j" f5 M. J0 Y
40. {
    8 u0 H4 [4 u4 t" x# {
41.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
42. 
    6 J/ n! ^" |! r0 k: T1 U- ]
43.     __HAL_RCC_GPIOB_CLK_ENABLE();
    
44. 
    4 u; K% g* l, M: V/ S  H, M" P2 e
45.     GPIO_InitStruct.Pin = COM_TX_Pin;
    
46.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    2 W$ J3 ]; l- U
47.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    ' Y% k5 J) p. u- U1 ^
48.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
49.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    
50. 
    2 {# S. T' E9 `8 R
51.     GPIO_InitStruct.Pin = COM_RX_Pin;
    $ W- X! d  @/ m1 v
52.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
53.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    
54.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    
55. 
    - ^7 a- T& S7 q5 M
56.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    - n' k* K9 q2 \1 F
57.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    
58. 
    
59. }
    ( T/ m# @6 p/ B6 G+ w- C( z. p
60. 
    
61. 
    & ]6 |  g8 A3 A5 T
62. /*******************************************************************************
    
63. * @FunctionName   : UART_Init.
    
64. * @Description    : 模拟串口结构体初始化.
    
65. * @Input          : None.
    
66. * @Output         : None.
    ) k* e) ]4 l- s( H3 E$ S
67. * @Return         : None.
    . l7 T" e2 F4 j. P& r
68. * @Author&Data    : MrShuCai  2019.4.11.
    % g: _$ w9 s$ v9 H! m$ S
69. *******************************************************************************/
    
70. void UART_Init(void)
    1 l- w# c& G! Q& ?1 L$ E* p* n9 ^
71. {
    ) x0 W& V8 q9 m; P
72.     gsUARTBuff.CheckType = NONE;
    7 {' ^$ |: R6 }1 o1 I; P
73.     gsUARTBuff.UartMaxLength = Uartlength;
    . n8 T5 d. K! k& R/ [! w" t# _" m
74.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    ! \, l3 u$ D0 I8 }
75.     UART_GPIO_Init();
    2 M6 {  Y$ v- a" q: W+ z$ h
76. 
    
77.     if(BaudRate == 1200)
    # X1 S: p' ^) b; |, m% y
78.     {
    
79.         Prescaler = 15;
    
80.         Period = 623;
    
81.     }
    
82.     else if(BaudRate == 2400)
    , {! {5 Q% a" O- o1 m" E5 |: l/ C
83.     {
    " e& ?( x! [- L* N
84.         Prescaler = 15;
    " h" D5 z# L/ I7 x$ I
85.         Period = 207;
    ) g) P2 \4 j: ]$ U4 y+ {) H6 W- e
86.     }
    
87.     else if(BaudRate == 4800)
    
88.     {
    6 V* f" v! V# c) }) X$ J2 s
89. //        Prescaler = 15;
    
90. //        Period = 50;  //9600
    
91.              Prescaler = 15;
    " E5 U2 a( e& z1 C) w: d5 K7 D* \
92.              Period = 103;
    
93.     }
    
94. 
    
95.     MX_TIM6_Init();
    4 J+ f. B( v3 u% O( O. _
96. }
    
97. 
    
98. 
    6 [  p. L3 a  }9 L  Z* A+ W6 E2 c" N
99. /*******************************************************************************
    * S, q, Y6 T$ y) h
100. * @FunctionName   : UART_Send_Data.
     - V& f+ u, ]) D$ H! c4 x
101. * @Description    : 模拟串口发送数据接口.
     
102. * @Input          : None.
     * D# a- ?/ |: b' K' \
103. * @Output         : None.
     ( Y& X. p$ }( V% o; i# ]4 Q- I6 s
104. * @Return         : None.
     
105. * @Author&Data    : MrShuCai  2019.4.11.
     9 d7 |/ |1 w7 n( Z' \. q( T% W. y; S
106. *******************************************************************************/
     
107. void UART_Send_Data(uint8_t * data, uint8_t size)
     
108. {
     
109.     gsUARTBuff.Sendlength = size;
     
110.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     
111.     gsUARTBuff.TxEn = 1;
     , h: y  a2 o; v7 K, J
112.     gsUARTBuff.RxEn = 0;
     ) i$ Z% p0 n& Z0 R! {$ a
113.     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
114.     HAL_TIM_Base_Start_IT(&htim6);
     ' E% J9 ~. S6 m5 Q4 D
115. }
     7 g, \% r# t& F& D0 L
116. 
     
117. 
     2 N2 B" G) n$ o' k5 B7 u2 _
118. /*******************************************************************************
     
119. * @FunctionName   : EXTI4_15_IRQHandler.
     5 b& B- _! W. a0 N& _; X3 Z7 K4 z
120. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     6 i" l: Q6 Q9 V3 x5 ]
121. * @Input          : None.
     2 N* t" ^( S  y! x. b3 i+ H- |
122. * @Output         : None.
     
123. * @Return         : None.
     
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     . ^1 b% D# m* J; d1 {" c' Y
126. void EXTI4_15_IRQHandler(void)
     
127. {
     
128. 
     
129.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     * z$ H8 O3 L3 S6 E
130.     {
     
131.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     
132. 
     
133.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
134.         {
     
135.             gsUARTBuff.RxEn = 1;
     1 q' @% S" N; r) z
136.             ucRecvData = 0;
     6 ]* a, D% F* s) M! [* S
137.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     9 S  _- g+ B, ~' A( G! t" E1 r
138.             HAL_TIM_Base_Start_IT(&htim6);
     
139.         }
     
140.     }
     
141. }
     
142. 
     
143. /*******************************************************************************
     8 y9 f+ \7 X" C+ F% j
144. * @FunctionName   : TIM6_IRQHandler.
     
145. * @Description    : 中断处理函数，包括发送和接收两部分.
     0 V: \# j8 C6 N* `% j" X3 j3 _
146. * @Input          : None.
     
147. * @Output         : None.
     
148. * @Return         : None.
     
149. * @Author&Data    : MrShuCai  2019.4.11.
     
150. *******************************************************************************/
     4 L9 ^/ f0 i% R9 x7 j7 t5 J) f
151. void TIM6_IRQHandler(void)
     ) t, N5 }$ [8 Z; z4 H
152. {
     
153.     HAL_TIM_IRQHandler(&htim6);
     
154. 
     8 G- t8 ~- R2 P5 `
155.     if(gsUARTBuff.TxEn == 1)       /*数据发送，发送优先，无发送后才进入接收状态*/
     
156.     {
     , e, ~; m$ `8 N+ U
157.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     & m, K: B3 \% u  x: x9 _% F
158.         {
     
159.         case COM_START_BIT_DEAL :
     4 t- Z2 ~- }2 P) X- G, l0 o2 F2 V1 z
160.         {
     - p, c1 N* x6 |+ |
161.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     4 L1 D# g% V# A# y  J
162. 
       G( D$ w% X+ \
163.             if(++ ucAcquCx == 6)    /*由于发送时在立即拉低就进入判断，且自加，所以需要加到4，实际延时3个周期*/
     
164.             {
     
165.                 gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
       \0 I! R: t# q' O- C! e# z
166.                 ucAcquCx = 0;
     
167.                 ucSendBitCx = 0;
     
168.             }
     
169.         }
     " v6 n  h( a, u7 d6 C- T' J% U0 f
170.         break;
     
171. 
     
172.         case COM_DATA_BIT_DEAL :
     
173.         {
     0 y. \* K. e$ B6 }5 Z' D+ k  Y
174. 
     
175.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     
176. 
     ' r" Q4 N) M0 [$ K1 v3 X
177.             if(++ ucAcquCx >= 6)
     7 e" J3 l7 d  h3 I6 k" Q
178.             {
     
179.                 ucAcquCx = 0;
     
180.                            
     
181.                 ucSendBitCx ++;
     
182. 
     9 R& M; v! V; a2 t# \  |
183.                 if(ucSendBitCx >= 8)
     7 @% S; {8 A9 E$ S* d0 {
184.                 {
     
185.                     if(gsUARTBuff.CheckType == NONE)
     3 G+ X/ Q, v& Q* \  ^
186.                     {
     5 X9 v: K) \5 h) f, P# W
187.                         gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
188.                     }
     0 B! [3 G* e: M, |
189.                     else
     
190.                     {
     
191.                         gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     3 j$ L7 u4 K" k* T1 ~
192.                     }
     
193.                 }
     2 U/ v/ S% y; ?; O
194.             }
     + D3 ^0 M- o" E, }6 d; _1 S( Q3 u
195.         }
     
196.         break;
     
197. 
     8 O7 |4 U* c, ]# a1 k" W
198.         case COM_CHECK_BIT_DEAL :
     
199.         {
     
200. 
     4 g+ I3 {. R) w( C. [% k
201.         }
     * Y7 N' v* \3 _8 Y5 D0 @
202.         break;
     / N/ b6 C$ j9 Q1 B6 u5 ~" ?6 B. U
203. 
     
204.         case COM_STOP_BIT_DEAL :
       m. v0 O: I' T1 F9 H
205.         {
     1 p5 K6 C. D! a5 b  W( _/ u
206.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     
207. 
     1 H$ A- p$ u4 F
208.             if(++ ucAcquCx == 7)
     & x, f) r/ M. O4 W$ `
209.             {
     7 l9 G. o. f5 G5 U4 w
210.                 ucAcquCx = 0;
     
211.                 ucSendBitCx = 0;
     9 y# P# X3 N3 d, ^: {
212. 
     
213.                 if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     5 L) N' S; v* X+ T
214.                 {
     
215.                     gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     + d& r% r1 G/ W. ]5 s  N# h6 M7 s
216.                     ucSendLengCx ++;
     
217.                 }
     
218.                 else
     % r6 @( l/ U( ~9 I
219.                 {
     
220.                     ucSendLengCx = 0;
     
221.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
222.                     gsUARTBuff.TxEn = 0;
     
223.                     gsUARTBuff.RxEn = 1;
     
224. 
     
225.                     HAL_TIM_Base_Stop_IT(&htim6);
     
226.                     TIM6->CNT = 0;
     ! v* P5 n8 k5 ]. f' H+ l
227.                 }
     
228.             }
     
229.         }
     
230.         break;
     
231. 
     5 d- k# e+ p. N( i( R6 N
232.         default:
     
233.             break;
     8 W9 e+ x$ R( A" T  a
234. 
     
235.         }
     + c5 z. }2 \- c$ c. Q+ U
236.     }
     
237. 
     
238. 
     
239.     if(gsUARTBuff.RxEn == 1)
     ; e7 t2 i1 k! A; V6 H% F% F
240.     {
     
241.         switch(gsUARTBuff.UartStat)
     * \5 V$ U6 Z" |- h6 R; R
242.         {
     , ], R" y1 a/ o: K
243.         case COM_START_BIT_DEAL :                         //起始位 必须连续三次采集正确才认可
     
244.         {
     
245.             ucRecvLastBit = ucRecvNowBit;
     ) c3 V& D& _% K! e$ }
246.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     " x1 a/ |; C0 D; }) E1 j' `0 k. [
247. 
     $ d1 L" o' A1 a- v& g7 T+ [
248.             if(    ucAcquCx == 0)
     
249.             {
     
250.                 ucAcquCx = 1;
     
251.                 return ;
     ' a1 J& Y; r+ _. C  B- \
252.             }
     
253. 
     
254.             if(ucRecvLastBit == ucRecvNowBit)
     
255.             {
     
256.                 ucRecvTrueCx ++;
     ! q2 @5 q9 P9 X
257.             }
     
258. 
     8 Y0 v* `) D3 s! G, I7 V! t" e' }- J
259.             if(++ ucAcquCx >= 5)
     
260.             {
     
261.                 if(ucRecvTrueCx >= 2)
     - o# I$ K; e3 s9 V7 b6 _- H  `
262.                 {
     
263.                     gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
264.                     ucAcquCx = 0;
     7 K( b. C; `0 P4 N1 t: Y
265.                     ucRecvTrueCx = 0;
     
266.                 }
     
267.                 else
     9 g! n0 E1 M5 R, k, w& d' ]
268.                 {
     
269.                     ucAcquCx = 0;
     
270.                     ucRecvTrueCx = 0;
     
271.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
272.                 }
     7 p' D2 @2 }9 s. m! s! ^: e6 k
273.             }
     
274.         }
     
275.         break;
     / ]2 C1 B. f; F  }
276. 
     9 G) t( L4 l7 P/ m) _
277.         case COM_DATA_BIT_DEAL :                         //数据位
     
278.         {
     
279. 
     
280.             ucRecvLastBit = ucRecvNowBit;
     
281.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     1 s( C# _" p6 U  t; f  |
282. 
     
283.             if(0 == ucAcquCx)
     
284.             {
     
285.                 ucAcquCx = 1;
     6 h* u, }( g+ n2 H
286.                 return;
     ! a* I. d# |3 T* F
287.             }
     $ q' O8 x6 I$ W
288. 
     9 X6 J) G6 [9 l/ N/ P' i1 A  y9 b8 g
289.             if(ucRecvNowBit == ucRecvLastBit)
       g7 y5 J' j. R2 H
290.             {
     
291.                 ucRecvTrueCx ++;
     6 n4 X% \" J8 |( M
292.             }
     7 ~, `) a3 A8 r) _3 L& X
293. 
     ! M. A3 b- y& Q' m/ W$ O
294. 
     : |& w+ u: g/ |4 |2 o
295.             if(++ ucAcquCx >= 6)
     / b- J# ~2 b0 O; _2 I0 n) i0 P
296.             {
     ! M1 E6 K& B( b. {6 w' ^
297.                 ucAcquCx = 0;
     ( n- [# k8 ]2 Y4 y
298. 
     & N4 T! V3 U% O1 s$ ^0 R; x: |: W
299.                 if(ucRecvTrueCx >= 2)
     ! ?& ?  |: t* p( W$ B$ y6 O/ m3 y
300.                 {
     
301.                     if(ucRecvLastBit == 1)
     
302.                     {
     6 I9 x4 z, t/ T+ L$ T
303.                         ucRecvData |= (1 << ucRecvBitCx);
     
304.                     }
     
305.                     else
     ( _+ {5 ~* d5 }" I% ^3 ?/ D: v4 H
306.                     {
     * w  N, H3 x1 a$ y
307.                         ucRecvData &= ~(1 << ucRecvBitCx);
     0 y+ W! `) u& P# k
308.                     }
     8 g4 s; @& U. w4 Q3 s8 m  b3 O
309. 
     
310.                     if(ucRecvBitCx >= 7)
     
311.                     {
     
312.                         ucRecvBitCx = 0;
     & ^8 Z  T8 G2 d& w$ o& o3 {
313. 
     
314.                         if(gsUARTBuff.CheckType == NONE)
     
315.                         {
     & c9 p+ L  k" Z
316.                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     - Z7 _% O# y! ?0 G" b
317.                         }
     ; U/ u$ o) a6 a
318.                         else
     
319.                         {
     - W) T) A3 \, N
320.                             gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     
321.                         }
     
322.                     }
     
323.                     else
     
324.                     {
     
325.                         ucRecvBitCx ++;
     
326.                     }
     
327.                 }
     
328.                 else
       Q6 j% b5 v+ {7 r# w0 N$ e4 ?& f/ M
329.                 {
     " F, a, k3 e( K% ^9 w
330.                     ucAcquCx = 0;
     : W: j. @& h0 I5 W' R5 j
331.                     ucRecvTrueCx = 0;
     
332.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     : G/ |% g3 S. I
333.                 }
     1 n- G: m* D; B6 {5 n
334.             }
     % K& `4 j1 H# @$ z
335.         }
     
336.         break;
     
337. 
     
338.         case COM_CHECK_BIT_DEAL :                         //校验位
     . Q2 T' X# h. Q
339.         {
     
340. 
     
341.         }
     , @3 u+ ~: v& B
342.         break;
     
343. 
     1 V* ?7 p* Y6 |+ Q
344.         case COM_STOP_BIT_DEAL :                         //停止位
     9 h2 M& X, e3 U0 P! }5 W3 j
345.         {
     
346. 
     / y$ V) a4 s; m1 c- e+ d. ]
347.             ucRecvLastBit = ucRecvNowBit;
     
348.             ucRecvNowBit = HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin);
     
349. 
     
350.             if(0 == ucAcquCx)
     
351.             {
     2 n# k$ Z; E8 s/ r; ~& p
352.                 ucAcquCx = 1;
     
353.                 return;
     
354.             }
     
355. 
     
356.             if(ucRecvNowBit == ucRecvLastBit && ucRecvNowBit == 1)
     
357.             {
     
358.                 ucRecvTrueCx ++;
     
359.             }
     
360. 
     * f' c1 m& X* {7 _
361. 
     4 H8 O8 X7 l/ Z9 M3 y
362.             if( ++ ucAcquCx >= 6)
     
363.             {
     / J& T) r* h4 d! K( @
364.                 ucAcquCx = 0;
     5 a5 g9 O  a  I
365. 
     / W9 q4 M, z" c& ]8 e
366.                 if(ucRecvTrueCx >= 2)
     6 T" w" P( I; y
367.                 {
     - u$ J4 K: g" L5 _# j7 w
368.                                       ucRecvTrueCx = 0;
     * D" J( X5 E+ a0 U8 {2 R& M
369.                     if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     
370.                     {
     
371.                         gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                         gsUARTBuff.Recvlength ++;
     4 A  P( ?( D' u% C6 ^. R0 [
373.                     }
     
374. 
     
375.                     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     
376.                     HAL_TIM_Base_Stop_IT(&htim6);
     + r0 c9 y6 |5 Y
377.                     TIM6->CNT = 0;
     
378.                 }
       l" `. k2 i! H( P7 x& o3 ?
379.                 else
     
380.                 {
     7 l. v3 t) b1 e8 t0 C% ^) ]8 f
381.                     ucRecvTrueCx = 0;
     
382.                 }
     
383.             }
     ; f' ?/ H' [$ W$ |1 r; e/ M
384.         }
     
385.         break;
     
386. 
     ( F  ^/ ]# y  {: y! e- W
387.         default:
     
388.             break;
     3 r7 n: o5 H& ~
389. 
     " Z5 j7 Y1 P9 s$ d1 {
390.         }
     
391.     }
     + o- d5 U1 }5 u& G4 o( `1 v
392. 
     
393. }

复制代码

0 B( b+ a4 |, @7 A( `% N

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

1 _; _- j) M" r3 Z" a  d1 a

4、 最优实现

7 O+ N& w+ h3 N

$ ?% h8 b3 Y/ S' g+ H8 B8 b: d

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

比如在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. 
   ) X3 R: C0 g4 m
4. typedef enum
   
5. {
   
6.     TimeRecvStartStep1 = 0,
   * i* C$ m  M3 a% Y1 o
7.     TimeRecvStep2 = 1,
   - c; L5 {' k5 n5 H8 e0 h
8.     TimeRecvStep3 = 2,
   / [  W- u+ g( \
9.     TimeRecvStep1 = 3,
   7 v. y; o, C! c( |" `/ V
10.     TimeSendStep = 4,
    
11. 
    
12. } TimeStep;
    
13. 
    0 v( o4 v  g8 s$ i: P, h4 C3 y$ v" S
14. uint16_t TimeSet[5];
    1 u$ Z$ ~0 ^/ U$ ^! H
15. 
    + n; ~4 L. V* a% Q  j# ]
16. uint16_t TimeSetBuff[][5] = {{1199, 59, 59, 2378, 2498 }, //1200
    / C1 X4 V# e% ~& L0 p( @3 @. ?$ u
17.     {539, 59, 59, 1128, 1247 },  //2400
    
18.     {239, 59, 59, 503, 624  },   //4800
    
19.     {149, 29, 29, 251, 311  },   //9600
    ! `% M4 A3 c6 p" |
20.     {0, 0, 0, 0, 0    },         //预留
    
21. };
    
22. 
    4 D& \9 ]/ I7 O6 J8 s6 ?" G
23. UART gsUARTBuff;                //定义串口
    
24. 
    
25. uint8_t ucRecvData = 0;         //每次接收的字节
    , z$ v7 e- }8 a- _# Y2 M
26. uint8_t ucAcquCx = 0;           //三次滤波计数
    
27. uint8_t ucRecvBitCx = 0;        //接收位计数
    $ o2 \# Y9 e* V" X
28. uint8_t ucSendBitCx = 0;        //发送位计数
    
29. uint8_t ucSendLengCx = 0;       //发送长度计数
    
30. 
    
31. uint8_t ucRecvBitBuff = 0;       //采集位保存
    
32. 
    
33. 
    0 q6 M2 E: `9 O/ u' y- ?
34. TIM_HandleTypeDef htim6;
    
35. 
    1 G0 s+ q% a1 r) q  a9 V: N! d
36. void MX_TIM6_Init(void)
    * w# c) ]( d0 G$ H  Z' i
37. {
    
38. 
    
39.     __HAL_RCC_TIM6_CLK_ENABLE();
    
40. 
    * a$ j) l% u0 H( }
41.     htim6.Instance = TIM6;
    
42.     htim6.Init.Prescaler = 15;
    
43.     htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    
44.     htim6.Init.Period = TimeSet[TimeRecvStartStep1];
    
45.     htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
46. 
    
47.     HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    
48.     HAL_NVIC_EnableIRQ(TIM6_IRQn);
    
49. 
    ( A5 t6 O* Y! j) {5 B( Z
50.     HAL_TIM_Base_Init(&htim6);
    & b3 a# P9 E  E/ Q% N
51. 
    
52. }
    ! e* I7 Q$ D7 R5 }% Y5 ~9 k
53. 
    
54. 
    
55. void UART_GPIO_Init(void)
    
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
    
59.     __HAL_RCC_GPIOB_CLK_ENABLE();
    9 r, U* }; n5 W# `
60. 
    
61.     GPIO_InitStruct.Pin = COM_TX_Pin;
    % d- Z1 c' D0 D' a
62.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    - ~. w3 b. O, K1 w+ L. @2 r/ C
63.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    7 f+ q* c% d" J) F6 M
64.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
65.     HAL_GPIO_Init(COM_TX_GPIO_Port, &GPIO_InitStruct);
    5 x0 j6 F: I+ D/ M/ {& n/ R% X7 \
66. 
    
67.     GPIO_InitStruct.Pin = COM_RX_Pin;
    
68.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
    
69.     GPIO_InitStruct.Pull = GPIO_PULLUP;
    9 U- @# A, H/ G
70.     HAL_GPIO_Init(COM_RX_GPIO_Port, &GPIO_InitStruct);
    8 F4 U1 X4 i7 `
71. 
    
72.     HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
    
73.     HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
    6 S! x; g8 v) S3 A' o5 u2 b# O4 l
74. 
      ?) s& c" l# i' z1 ^9 C  O
75. }
    6 p+ _, C3 A, z, p2 h, L
76. 
    
77. 
    : h; D7 r# i7 s6 ~) U: _
78. /*******************************************************************************
    
79. * @FunctionName   : UART_Init.
    9 M5 J& c3 b' l8 g$ O
80. * @Description    : 模拟串口结构体初始化.
    
81. * @Input          : None.
    ' F% G3 l) m  V' X, W7 R
82. * @Output         : None.
    6 k, v1 a) `7 V! u
83. * @Return         : None.
    
84. * @Author&Data    : MrShuCai  2019.4.11.
    7 x. w3 g# S5 N  a1 K
85. *******************************************************************************/
    
86. void UART_Init(void)
    7 Q; _1 r7 A& Y$ i
87. {
    
88.     gsUARTBuff.CheckType = NONE;
    
89.     gsUARTBuff.UartMaxLength = Uartlength;
    
90.     gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
    
91.     UART_GPIO_Init();
    
92. 
    & P1 P9 G* }7 [9 u. {/ H. C
93.     if(BaudRate == 1200)
    
94.     {
    
95.         memcpy(TimeSet, &TimeSetBuff[0][0], sizeof(TimeSet));
    0 y6 W, E+ F: y3 h) A# F5 _9 Q
96.     }
    9 s  r; a. V: g& k
97.     else if(BaudRate == 2400)
    3 |; v- S: S$ _* [9 W7 c6 o
98.     {
    
99.         memcpy(TimeSet, &TimeSetBuff[1][0], sizeof(TimeSet));
    ! `  K/ W% b! T0 o/ R
100.     }
     $ s# z! b/ k  k5 q2 w3 ?- l/ G
101.     else if(BaudRate == 4800)
     2 G( L- [% R( N0 N" [
102.     {
     
103.         memcpy(TimeSet, &TimeSetBuff[2][0], sizeof(TimeSet));
     
104.     }
     
105.     else if(BaudRate == 9600)
     0 c8 D, V9 }: W, B' m# x
106.     {
     0 h, {4 U/ A) o  Y' V# [0 r  R
107.         memcpy(TimeSet, &TimeSetBuff[3][0], sizeof(TimeSet));
     
108.     }
     & d0 f/ s+ O2 {
109.     else
     " |7 z- I; ]& A" u& M
110.     {
     8 g2 k7 @2 u4 P5 @4 z$ Z& @' M& t! B
111. 
     
112.     }
     " \! g; L* B# C0 u
113. 
     * Y& S- A. \8 x
114.     MX_TIM6_Init();
     + g" q. X/ \6 ~: y( X
115. }
     
116. 
     6 q$ j+ h& I7 v4 G8 A
117. 
     
118. /*******************************************************************************
     % _+ ?1 I. L; p( N
119. * @FunctionName   : UART_Send_Data.
     
120. * @Description    : 模拟串口发送数据接口.
     1 m  I9 k4 |% h
121. * @Input          : None.
     
122. * @Output         : None.
     
123. * @Return         : None.
     7 h+ ^2 j) f3 b$ u. G
124. * @Author&Data    : MrShuCai  2019.4.11.
     
125. *******************************************************************************/
     * v+ L  j* I( S- ], @" x
126. void UART_Send_Data(uint8_t * data, uint8_t size)
     8 n; b+ n  ]7 h# m6 P- o2 x2 d
127. {
     
128.     gsUARTBuff.Sendlength = size;
     % h9 ^) ?9 D- a' S/ z
129.     memcpy(gsUARTBuff.UART_Send_buf, data, size);
     / x  g  l6 s& {5 H/ r% v) f" `$ f
130.    
     
131.       if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
132.         {
     4 q: f: z# {' }, n, G, S
133.             gsUARTBuff.TxEn = 1;
     2 N6 \+ t- n1 }3 V
134.             gsUARTBuff.RxEn = 0;
     
135.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ) m  E4 a6 W6 G
136. 
     6 |3 S$ n1 k3 D- w0 T- y
137.             TIM6->ARR = TimeSet[TimeSendStep];
     : h% o0 s3 ^/ W( c3 P5 |1 m3 M
138.             TIM6->EGR = TIM_EGR_UG;
     
139. 
     
140.             HAL_TIM_Base_Start_IT(&htim6);
     
141.         }
     
142.       
     
143. }
     
144. 
     
145. 
     8 _, b/ u+ h, A, m6 [' P% Q
146. /*******************************************************************************
     
147. * @FunctionName   : EXTI4_15_IRQHandler.
     
148. * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
     & ]# s& [0 y: {- `
149. * @Input          : None.
     : T- l# Y) D1 {. y2 V" A  O
150. * @Output         : None.
     ' E1 [8 _9 \9 y6 K0 H# A
151. * @Return         : None.
     
152. * @Author&Data    : MrShuCai  2019.4.11.
     
153. *******************************************************************************/
     ! V3 {7 h' K) C8 |, K
154. void EXTI4_15_IRQHandler(void)
     
155. {
     9 P. T" h0 Z6 A
156.     if(__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
     2 m% F1 V! y- |; I3 S* {( m
157.     {
     # \, i2 V6 f7 x! x
158.         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
     ; j1 k0 i$ ~4 q# G5 K
159. 
     
160.         if(gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
     
161.         {
     
162.             gsUARTBuff.RxEn = 1;
     . @6 [5 R$ ~. V$ Q) v8 }( h
163.             ucRecvData = 0;
     
164.             gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     ! E" l0 g7 A4 ^+ L
165. 
     " q* |$ f& U1 d
166.             TIM6->ARR = TimeSet[TimeRecvStartStep1];
     6 x8 E/ B  i# a% W1 m3 s
167.             TIM6->EGR = TIM_EGR_UG;                  //初始化定时器
     5 {) i4 U4 V" `  h6 y
168.                       EXTI->IMR &= ~(0x10);
     
169.                       EXTI->EMR &= ~(0x10);
     
170.             HAL_TIM_Base_Start_IT(&htim6);
     
171.         }
     
172.     }
     5 f& }% ^- V+ ^8 ]; t9 q
173. 
     + Z5 c( R) X, V1 K8 u/ l) C5 j  H
174. }
     
175. 
     * \* g! ?4 A2 S! M* E0 s+ O
176. 
     4 B$ G, n1 @5 E; }; ^, ?3 j
177. /*******************************************************************************
     & N4 I' q5 |2 W" F; o3 O
178. * @FunctionName   : BitValueChk.
     
179. * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
     
180. * @Input          : n 采集记录的位值.
     
181. * @Output         : BitValue.
     7 w! ~$ Q5 W. [/ D$ `; t
182. * @Return         : BitValue.
     
183. * @Author&Data    : MrShuCai  2019.5.1.
     
184. *******************************************************************************/
       p$ W" q* Q( ]0 z
185. uint8_t BitValueChk(uint8_t n)
     3 G, T0 u/ F/ ?. o; q1 b- F, V
186. {
     & y; l$ F4 B& p- [! r# B; K: ~
187.     uint8_t BitValCx = 0;
     : h5 F# l1 `# N
188. 
     2 t" o2 C. h% ]3 M5 q1 s7 O9 ^
189.     for(BitValCx = 0; n; n >>= 1)
     
190.     {
     
191.         BitValCx += n & 0x01;
     
192.     }
     8 C0 ]# j- w$ S) w* W7 D
193. 
     
194.     return (BitValCx < 2) ? (0) : (1);
     ; Z9 \4 b. v2 U# m0 T5 v1 e6 X, s
195. 
     
196. }
     
197. 
     
198. /*******************************************************************************
     9 O" p! S3 l6 M/ f
199. * @FunctionName   : TIM6_IRQHandler.
     , n1 q- k, {$ k/ @
200. * @Description    : 中断处理函数，包括发送和接收两部分.
     ) Z, g; ]- @2 b3 m* Z( D3 _! t
201. * @Input          : None.
     ! q* c% I2 d$ b+ D& |. D+ @
202. * @Output         : None.
       H2 P9 e/ W+ S' E* P
203. * @Return         : None.
     
204. * @Author&Data    : MrShuCai  2019.4.11.
     
205. *******************************************************************************/
     
206. void TIM6_IRQHandler(void)
     
207. {
     2 ^! e% g3 w( U2 b
208. 
     . n5 F8 @% ]5 k* v
209.     HAL_TIM_IRQHandler(&htim6);
     % L0 v4 `1 m& B* ~8 d1 d: [$ @5 b
210. 
     8 O) E9 P! g2 i, @
211.     if(gsUARTBuff.TxEn == 1)         /*数据发送，发送优先，无发送后才进入接收状态*/
     
212.     {
     
213.         switch(gsUARTBuff.UartStat)  /*串口发送位状态判断*/
     
214.         {
     
215.         case COM_START_BIT_DEAL :
       y; e- C9 s+ G4 n# u0 e+ E7 M4 y
216.         {
     . J6 u8 l- y& Z5 y3 }/ m
217.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_RESET);
     
218.             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
219.             ucSendBitCx = 0;
     
220.         }
     ' e! Z" \$ z6 ^) k( Y) r; m
221.         break;
     
222. 
     ( }* ~( R% d6 c. J% r! E9 a  P2 d1 U! [% L
223.         case COM_DATA_BIT_DEAL :
     
224.         {
     $ I# N! i; ?9 W6 k3 {
225.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, (GPIO_PinState)((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01));
     ( A$ s+ D- m. T; K# h% C+ I$ K7 K
226. 
     / I% J- j3 O6 S  Q% }8 ?  C' [
227.             ucSendBitCx ++;
     
228. 
     2 T1 F9 Y1 {' g7 M5 u) @- I
229.             if(ucSendBitCx >= 8)
     7 X9 b' p3 E$ S' @. M" s7 e
230.             {
     ) T& o7 J! x; s
231.                 if(gsUARTBuff.CheckType == NONE)
     3 t0 i4 m4 Z3 s3 u3 y
232.                 {
     # g+ K" f3 \: U5 M; t, o6 h
233.                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
234.                 }
     
235.                 else
     , F& P+ A. f8 M9 d9 d/ G: z
236.                 {
     5 K* p* W, J& C* Z- q! t
237.                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     , I) z2 J1 |# u$ d
238.                 }
     
239.             }
     5 s- Z+ ~1 H' T$ O( R' x
240. 
     ' X* M5 @5 a5 p; r
241.         }
     
242.         break;
       I' @3 G% x  l* r& A3 _0 F
243. 
     
244.         case COM_CHECK_BIT_DEAL :
     . \0 C* b6 m( j
245.         {
     
246. 
     
247.         }
     
248.         break;
     1 u6 `9 y0 u4 [2 G% j) Q! ~
249. 
     . b$ N$ r0 `  J6 C6 P+ N
250.         case COM_STOP_BIT_DEAL :
     ' a' w% _9 f# z+ u$ e
251.         {
     
252.             HAL_GPIO_WritePin(COM_TX_GPIO_Port, COM_TX_Pin, GPIO_PIN_SET);
     $ ~8 t0 I$ p' S' c
253. 
     
254.             ucSendBitCx = 0;
     & w$ j- u- M4 K1 ^
255. 
     
256.             if(ucSendLengCx < gsUARTBuff.Sendlength - 1)
     
257.             {
     - L$ r& K% s7 @0 V* s
258.                 gsUARTBuff.UartStat = COM_START_BIT_DEAL;
     
259.                 ucSendLengCx ++;
     
260.             }
     , d$ L2 ~  Y, ?) T# R0 |
261.             else
     
262.             {
     5 `$ b, l9 r0 n& \- Q$ K
263.                 ucSendLengCx = 0;
     1 |& d  j. Q! R4 t
264.                 gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     6 F) }) K  T6 K
265.                 gsUARTBuff.TxEn = 0;
     
266.                 gsUARTBuff.RxEn = 1;
     & Z/ S# t! V* J# R2 m1 ~+ k
267.                 HAL_TIM_Base_Stop_IT(&htim6);
     
268.                               EXTI->IMR |= 0x10;
     
269.                           EXTI->EMR |= 0x10;
     2 r. ]! I" y- }9 \6 `7 M
270.                 TIM6 ->CNT = 0;
     
271.             }
     - T' b3 t* I$ k" c' [3 a% L: N
272. 
     3 {# R8 }0 C5 C
273.         }
     
274.         break;
     
275. 
     : g8 N! O+ g, f. w
276.         default:
     - @* B: o, E: _  u
277.             break;
     1 y# o, m; K0 m. t% D, }1 q
278. 
     
279.         }
     : k5 [+ @$ Q' e& P0 Z
280.     }
       W& {$ F! z8 T: q  ]. K
281. 
     & D/ ?+ t% \& E6 E& Y( o. {
282. 
     
283.     if(gsUARTBuff.RxEn == 1)
     
284.     {
     
285.         switch(gsUARTBuff.UartStat)
     ! Z+ f% m/ K% N# L7 @+ Q; a
286.         {
     ( F6 O) {6 U6 P. s. ]
287.                     case COM_START_BIT_DEAL :
     
288.                     {
     
289.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
290. 
     6 K' U2 ]" F! i. l# O
291.                             if(++ ucAcquCx >= 3)
     ' `/ D. e1 U# a+ m- _
292.                             {
     . z+ d( F4 Y2 }2 @4 l& l
293.                                     if(BitValueChk(ucRecvBitBuff) == 0)                        
     
294.                                     {
     * J0 c: A( d) \8 M3 j
295.                                             gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
     
296.                                             TIM6->ARR = TimeSet[ucAcquCx];
     
297.                                     }
     / E7 c8 {. u- G5 ?4 z
298.                                     else
     " ~3 w8 i3 T7 U; q$ j$ p0 s
299.                                     {
     3 v9 |1 a+ E1 G1 Q7 N
300.                                             gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
301.                                     }
     
302.                                     
     
303.                                     ucRecvBitBuff = 0;
     ; I9 _% }$ g% A  ^7 ^6 {! V
304.                                     ucAcquCx = 0;
     , k" W$ N/ T+ K5 L
305.                             }
     & G& M6 D  X  K! o% x' }
306.                             else
     
307.                             {
     3 f1 \, }# f$ x2 K- Y; T
308.                                     TIM6->ARR = TimeSet[ucAcquCx];
     , p) I" j+ [: |; ?
309.                             }
     7 m1 C* @' @" I3 t& x* s
310. 
     ( s; q+ L0 y0 S! r
311. 
     1 U! I9 B0 b4 ^) I; L- h! a4 {, L$ b
312.                     }
     
313.                     break;
     
314. 
     6 x) o6 S: x# ~5 [' Y- C2 {- C
315.                     case COM_DATA_BIT_DEAL :                         //数据位
     7 p/ k' h) t( }0 ]% Z4 R; T
316.                     {
     / c! q. d7 w/ z6 }) l& {
317. 
     9 h+ B$ u5 g- C& p* ^5 _- F4 R. Y5 P8 s
318.                             ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
319. 
     
320.                             if(++ ucAcquCx >= 3)
     
321.                             {
     : v! ^' m3 f2 n' L! ]) O
322.                                     ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;
     - [3 Z) x: s' e
323. 
     
324.                                     if(ucRecvBitCx >= 7)
     1 s  S$ \* a% @1 {" G1 b
325.                                     {
     - w* ^" D* Q. h7 X; v4 C
326.                                             ucRecvBitCx = 0;
     
327. 
     5 {+ z; H6 C0 n5 g1 H# J
328.                                             if(gsUARTBuff.CheckType == NONE)
     " O( K$ a2 r7 E" l2 S+ Y+ m* b# c
329.                                             {
     ' w. p' L9 l5 S
330.                                                     gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
     
331.                                             }
     9 _7 f( r! a5 p8 w! `
332.                                             else
     
333.                                             {
     
334.                                                     gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
     ; A1 t5 y- J8 R2 N$ \
335.                                             }
     2 R  L/ S, R, y/ Q
336.                                     }
     
337.                                     else
     & o8 z8 S; G' i. s
338.                                     {
     ( \4 L- T5 J# m+ O  S& u
339.                                             ucRecvBitCx ++;
     & h, D, U5 s7 _+ r8 G( d
340.                                     }
     
341. 
     
342.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
343. 
     * }4 N7 e' J6 ?+ Q* l0 \  G
344.                                     ucAcquCx = 0;
     * v2 s: n7 I/ F3 V5 ^9 U; @
345.                                     ucRecvBitBuff = 0;
     
346.                             }
     
347.                             else
     
348.                             {
     . E' a3 s; ]( v
349.                                     TIM6->ARR = TimeSet[ucAcquCx];
     ( v$ L4 b- ^) F. r2 T
350.                             }
     & ^6 W$ q7 |! p( Z
351.                     }
     , n$ g  U9 j0 j
352.                     break;
     
353. 
     
354.                     case COM_CHECK_BIT_DEAL :                         //校验位
     
355.                     {
     ( Y; e, Z& i: ?. y$ Q: V1 C$ s' T
356. 
     
357.                     }
     
358.                     break;
     & N1 \4 a3 Q- [2 q3 o; k( c) e+ y# x. ?
359. 
     : z) x4 S/ ]: t9 Q# f) t/ J2 f
360.                     case COM_STOP_BIT_DEAL :                         //停止位
     # k: o# t0 X) E! J6 b3 h5 c7 o3 e
361.                     {
     
362. 
     : A4 ?* O% u! L4 D8 d5 k/ p
363.                         ucRecvBitBuff = (ucRecvBitBuff << 1) | (HAL_GPIO_ReadPin(COM_RX_GPIO_Port, COM_RX_Pin) & 0x01);
     
364. 
     
365.                             if( ++ ucAcquCx >= 3)
     
366.                             {
       v1 L. ~6 O6 x* q4 c
367.                                     if(BitValueChk(ucRecvBitBuff) == 1)   
     . }( j" d* [; J& k
368.                                     {
     6 {8 ~& s, u" W
369.                                             if(gsUARTBuff.Recvlength < gsUARTBuff.UartMaxLength)
     5 Y% e% O: Q) n
370.                                             {
     , K9 L, |! p  D8 K$ e$ O
371.                                                     gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
     
372.                                                     gsUARTBuff.Recvlength ++;
     
373.                                             }
     
374. 
     
375.                                             gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
     , E9 B" c" n6 g: S* i4 |
376.                                             HAL_TIM_Base_Stop_IT(&htim6);
     
377.                                             
       D$ b" \5 M/ B0 T8 l( S
378.                                             EXTI->IMR |= 0x10;
     
379.                                             EXTI->EMR |= 0x10;
     , ~( \$ p) u1 |7 b; Q" C$ X
380.                                             TIM6->CNT = 0;
     
381.                                     }
     2 w: ]- `* [# y. {$ ]) s; o
382.                                     else
     ( s  X8 B1 M! r) ~% a2 R- F
383.                                     {
     6 ~  j" D( l$ \8 }, @2 w
384.                                             ucAcquCx = 0;
     
385.                                     }
     6 r- u6 n, M8 J1 u; Q
386.                                     
     # W, V: ?! x4 ~0 M/ u
387.                                     ucRecvBitBuff = 0;
     3 N" u1 y/ ^. G9 a, H! t
388.                                     ucAcquCx = 0;
     
389.                             }
     
390.                             else
     1 Z' f$ f0 P0 W. Z0 w( P
391.                             {
     ) }7 |) Y1 M6 n( v2 Q: S3 a$ p2 U5 ^
392.                                     TIM6->ARR = TimeSet[ucAcquCx];
     
393.                             }
     
394.                     }
     
395.                     break;
     
396. 
     $ ]# P& n# L  ~" z  u7 k+ \9 O
397.                     default:
     
398.                             break;
     ' P* x; f! h5 h9 ]6 I2 d3 S8 x
399.                     }
     & e6 ?2 T: v2 b
400.     }
     ; D: ?; o/ G& K6 f0 a& R
401. }

复制代码

9 p' m0 ?. f/ v# d$ T/ b

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

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

# X, }( F. o: a; \. x