( @! K/ T6 v7 ~' U& ~6 f

STM32F030C8T6普通IO模拟串口输出

pdf 版 STM32F030C8T6普通IO模拟串口输出.pdf (104.21 KB, 下载次数: 62)

2018-8-13 09:23 上传

点击文件名下载附件

串口传输协议

首先，必须要知道串口通讯时数据是怎样传输的？这里以异步传输字符为例子，如下图所示：

一般字符传输都采用：1位起始位，8位数据位，1位停止位，没有校验位 的形式传输，其他形式的这里不讲。串口异步传输在空闲状态时都必须是高电平。第一位传输的是起始位，起始位会将原来空闲时的高电平拉成低电平，起始位用来来标识数据开始传输，提示接收方准备开始接收数据；当接收方第一次检测到一个下降沿时，就表示接收到了起始位。起始位后就是8位的数据位，接收方在接收每一位数据的时候会采集几十次，如果结果都是低电平，则接收到的数据位0，如果结果都是高电平，则棘手到的数据位是1。1位停止位会将电平拉成高电平，以为接收下一个数据做准备。

IO模拟串口发送程序

IO口模拟串口发送数据，必须严格按照上面的异步传输协议。我们用伪代码实现这一过程：

1. void VirtualCOM_ByteSend(u8 val)
   + p  A7 u. }( S4 ^" ?& k  p; Q/ X/ t- j
2. 
   
3. {
   4 f( v" q# m9 s, o* ^
4. 
   3 |: y5 ~% A# Y5 J( z$ b( T  H; M
5. u8 i;
   + S) D: m# J/ F* H' J4 P
6. 
   
7. IO_LOW(); //起始位，拉低电平
   
8. 
   
9. Delay(sometime);
   
10. 
    
11. for(i = 0; i < 8; i++) //8位数据位
    , q# q6 x. Z8 F4 [' O
12. 
    8 _  ?; w2 f) Z8 p: ]* N, E5 J
13. {
    : ~# T: V1 @7 ]% e( s# _1 \
14. 
    1 B& z! }5 `" K" e) I* _
15. if(val & 0x01)
    , l0 U% m: {/ q4 P( ?. f7 g8 F
16. 
    ( g# J/ J7 i6 R2 u# A& F: W1 e
17. IO_HIGH();
    
18. 
    3 L! m/ X7 P+ _; W
19. else
    
20. 
    
21. IO_LOW();
    
22. 
    " P" ^) q- X5 L" ~3 c5 d, E  I, L
23. Dealy(sometime);
    
24. 
    7 d  ~8 d$ `6 ?* Y3 Q3 Z& z: {
25. val >>= 1;
    
26. 
    ! {  j2 ^" l' q# u. j- `
27. }
    
28. 
    $ W$ c8 O' ^; P+ X) L$ H7 g
29. IO_HIGH(); //停止位，拉高电平
    # K+ P1 t  I$ F$ X. z- t
30. 
    
31. Delay(sometime);
    
32. 
    6 }/ q3 Q1 f5 L4 G& |3 j- c
33. }

复制代码

' B# q. m6 C3 [$ u: j

代码很简单，思路也很清晰，完全是按照异步传输的过程写的。这里最重要的是Delay(sometime)，sometime的延时时间就决定了传输的速度，sometime去取某些值才可以设置程序标准的串口波特率(1200、2400、9600、38400、115200等等)。

以上来源于：

http://blog.csdn.net/wxh0000mm/article/details/77863217?locationNum=2&fps=1

使用STM32F030实现

功能实现分析：设定一个引脚为输出，使用定时器定时相应的时间，在定时器中断中根据串口协议控制IO输出高低电平。再重定向到printf函数。

硬件

文章末尾有工程源码。使用STM32CubeMX生成的工程。

STM32F030C8T6 使用外部8MHz晶振，倍频到48MHz。

软件分析

将虚拟串口需要使用的TXD引脚初始化为输出。

1. static void MX_GPIO_Init(void)
   
2. 
   
3. {
   
4. 
   ) x0 y- v' G* o* ~2 Z& H8 S% @
5. 
     k8 @7 j; ]( }# S! K
6. 
     I( D% ~9 q) Z! n+ g; W: }; L
7.   GPIO_InitTypeDef GPIO_InitStruct;
   
8. 
   
9. 
   
10. 
    - j1 P) X9 H" j% Z' `! R
11.   /* GPIO Ports Clock Enable */
    
12. 
    
13.   __HAL_RCC_GPIOF_CLK_ENABLE();
    
14. 
    ( M: ^6 s( \# G( h  A
15.   __HAL_RCC_GPIOB_CLK_ENABLE();
    % V2 n. z% N) M* l) p% c# k
16. 
    
17. 
    
18. 
    
19.   /*Configure GPIO pin Output Level */
    # Q: E+ v' _2 V2 |4 m7 h
20. 
    
21.   HAL_GPIO_WritePin(SIMULATE_UART_TX_PORT, SIMULATE_UART_TX_PIN, GPIO_PIN_SET);
    
22. 
    * R# E/ b8 @0 L9 i- p( P4 X
23. 
    + T. ^& [$ y, T/ G, k. j# D- i
24. 
    
25.   /*Configure GPIO pin : PB12 */
    
26. 
    
27.   GPIO_InitStruct.Pin = SIMULATE_UART_TX_PIN;
    
28. 
    8 j4 |& P3 q% }9 t: \* `! j
29.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
30. 
    
31.   GPIO_InitStruct.Pull = GPIO_PULLUP;
      T3 a2 a" E0 m5 o: _0 ~( R
32. 
    ( D5 Y5 i' k4 S$ {& b+ t
33.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    
34. 
    
35.   HAL_GPIO_Init(SIMULATE_UART_TX_PORT, &GPIO_InitStruct);
    ; _- L- B$ j- Q& ]9 A
36. 
    2 Y5 H4 V; k0 b
37. 
    : k8 T% O0 }* n6 J; w/ Q! P( B
38. 
    
39. }

复制代码

虚拟串口波特率设置为9600。由此可以计算出传输1位的时间为1/9600=1.041666666666667e-4s。也就是104.167us，由此可知，可以设置定时器中断为104us。PS：在104ux时最大传输数据为255个，我测试了下，没有出现传输出错的现象。我测试了定时器中断为100us，很容易出现传输出错的现象，

使用TIM14，定时时间为104us。其他波特率可以做相应的修改。

数值的计算

(9+1)*(499+1)/48=104.167us

1. static void MX_TIM14_Init(void)
   
2. 
   $ V5 w7 O3 p( G3 e; |( `. H
3. {
   ) v" d% O% x( N9 q# m- F$ ~* X
4. 
   ; L* Q9 N7 `, {0 u: u
5. 
   & U$ S6 }0 H+ m( g  s& w6 S
6. 
   
7.   htim14.Instance = TIM14;
   
8. 
   
9.   htim14.Init.Prescaler = 499;
   
10. 
    
11.   htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
    ' o( s2 y9 D2 t  X1 x
12. 
    
13.   htim14.Init.Period = 9;
    
14. 
    
15.   htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
16. 
    & Z/ q% c- \0 i  @0 @& J
17.   htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
18. 
    8 C# {/ c, ]  ^" ^7 w) z; c
19.   if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
    
20. 
    ! f/ |& G% g3 Q0 l3 |6 i% U
21.   {
    0 s# M: k' S( S3 w
22. 
    
23.     _Error_Handler(__FILE__, __LINE__);
    5 w" ?7 ]2 I% S7 ]
24. 
    / ?- {1 G$ ^: P5 X
25.   }
    
26. 
    ! J" ?* d/ l" y: f: {4 J
27. }

复制代码

- c  ~' h- ?" n

在定时器中断中根据串口传输的协议控制IO(PB12)的引脚输出高低电平，

1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   " v  Z# N, Q9 S6 Z$ X
2. 
   & }6 B5 y) a/ V9 o3 H
3. {
   
4. 
   
5.     if(htim==(&htim14))
   ) B; u, O: c* z6 y3 `
6. 
     o/ J( M- l% [: G% y
7.     {
   4 A/ `' ]5 s, a5 I$ K" w. X* z
8. 
   5 h* Z+ P$ w8 Y  M: X  A6 M8 G
9.         static uint8_t i = 0;
   
10. 
    
11. static uint8_t send_counter = 0;
    
12. 
    & S! X. b* k7 s7 D6 O8 C" D3 ^, O
13. 
    ) G& r  x+ d! x# }7 `
14. 
    
15. if(uart_send.len)
    " p5 n- y3 h4 {- Z) Q2 I5 H; N& j" J, h( T
16. 
    
17. {
    + O3 ?7 `1 G: Q
18. 
    
19. if(send_counter==0)
    
20. 
    4 {7 w( {- i% A
21. {
    
22. 
    0 R; N8 U7 A0 ^
23. HAL_GPIO_WritePin(SIMULATE_UART_TX_PORT,SIMULATE_UART_TX_PIN,GPIO_PIN_RESET);
    & p) D' M3 c) H
24. 
    
25. send_counter++;
    
26. 
    * u3 V$ N$ a' }$ b) m* C, p
27. }
    : y& k/ ~' E8 G1 s4 D  U* c1 Q
28. 
    
29. else if(send_counter<9)
      h  w8 i/ z7 I* r9 w
30. 
    
31. {
    
32. 
    
33. if(uart_send.data[i]&0x01)
    
34. 
    7 f: {% I. w/ H2 P0 @) x
35. {
    ! X8 k0 V  y% }
36. 
    
37. HAL_GPIO_WritePin(SIMULATE_UART_TX_PORT,SIMULATE_UART_TX_PIN,GPIO_PIN_SET);
    
38. 
    ! `; v- p* J" p! ?
39. }
    
40. 
    
41. else
    7 [( I6 w9 {' O, ]' C
42. 
    
43. {
    
44. 
    ' r* b3 }7 ^" k8 r
45. HAL_GPIO_WritePin(SIMULATE_UART_TX_PORT,SIMULATE_UART_TX_PIN,GPIO_PIN_RESET);
    
46. 
    
47. }
    , {( O) A- A8 t' m, M6 X
48. 
    # D2 `/ B* _  S$ s
49. uart_send.data[i]>>=1;
    
50. 
    8 s5 W3 c% ~* K$ x$ F
51. send_counter++;
    . S' z8 h' A, W* N9 X; A
52. 
    
53. }
    
54. 
    / y0 e3 V$ X% E! \. O
55. else
    
56. 
    & [- }4 \, @& ]8 s+ Y  x# O
57. {
    ' e  o% I$ T. u% {/ _
58. 
    
59. i++;
      t+ |& k$ D, g8 q  F  i7 e
60. 
    " {8 b4 w4 L: f! Y: l. m
61. uart_send.len--;
    
62. 
    , y1 ?# s( H7 P9 M8 Y
63. send_counter=0;
    5 X# }1 r6 Y" r9 _/ l
64. 
    / P0 J! z& o, k
65. HAL_GPIO_WritePin(SIMULATE_UART_TX_PORT,SIMULATE_UART_TX_PIN,GPIO_PIN_SET);         
    
66. 
      p+ U; {, s4 C4 Q% o& M
67. }
    
68. 
    
69. }
    
70. 
    / e! _3 f- X/ e% U# r
71. else
    
72. 
    
73. {
    
74. 
    6 n& n1 ^% s4 u5 e! i3 m2 E
75. i = 0;
    . P( s# j: \8 T
76. 
    
77. uart_send.start_flag=0;
    
78. 
    $ d+ q0 _! ?* p. M
79. HAL_TIM_Base_Stop_IT(&htim14);
    , s* o3 F7 k" ?$ G
80. 
    
81. }
    
82. 
    
83.     }
    
84. 
    
85. }

复制代码

用于发送数据的结构体

1. struct UART_SEND
   
2. 
   
3. {
   
4. 
   & Y: {, j) ~& L; u: F; Q2 X
5.     volatile uint8_t start_flag;//使用volatile修饰是为了防止Keil把该变量优化掉,该变量用于判断一字节发送完毕，功能类似于串口发送完毕标志
   9 h1 K( U6 \: D4 o1 Z
6. 
   
7.     uint8_t len;                //需要发送的字符长度。
   ' N9 I3 I7 I2 g2 l: ]6 d
8. 
   $ a' s5 y6 ?- l6 T& ?
9.     uint8_t data[0XFF];            //需要发送的数据
   
10. 
    
11. };

复制代码

UART发送函数

1. /*
   
2. 
   
3.     发送一个字节的数据
     a8 L  V- v5 j! o
4. 
   2 r, A( Z& }% O
5. */
   4 q- u( d; |/ m8 i. R- z
6. 
   4 O' j  |; S5 c% {3 |- k2 r2 ~; g
7. void uart_send_char(uint8_t data)
   
8. 
   
9. {
   
10. 
    
11.     uart_send.start_flag=1;
    # U! [- @% X$ d2 }, y
12. 
    
13.     uart_send.data[0]=data;
    ( R" f% H* P4 J5 g3 Y
14. 
    ( a- q/ t7 x0 g2 W' t: |' @' Y
15.     uart_send.len=1;
    1 z8 t% S* w* ^! |  J+ z2 \
16. 
    
17.     HAL_TIM_Base_Start_IT(&htim14);
    / W5 m4 H2 c( N4 K
18. 
    
19. }
    % H: X$ i7 R- V0 {
20. 
    6 f7 k& k8 t5 V) l
21. /*
    
22. 
    " Y/ ]' o* `/ [5 T) d' e
23.     发送字符串
    
24. 
    7 i- M: w2 Z$ x% v6 d
25. */
    
26. 
    
27. void uart_send_string(uint8_t pdata[],uint8_t len)
    ; p7 D  b: ~3 v7 C% M" d% g
28. 
    
29. {
    * ~5 ~! A  ?( T
30. 
    
31.     uart_send.start_flag=1;
    2 n4 y; J! D0 ?- R
32. 
    . N6 z* b/ G( h! f
33. memcpy(uart_send.data,pdata,len);
    
34. 
    
35.     uart_send.len=len;
    
36. 
    
37.     HAL_TIM_Base_Start_IT(&htim14);
    3 W8 |$ G! q% X: K. M" n% x, L
38. 
    
39. }
    0 J7 t# F7 W& h) |* R
40. 
    * A  X( u/ w, A+ P& x' I: B
41. /*
    
42. 
    / B- q7 L4 A" b/ Y* z8 a
43. printf 重定向函数
    
44. 
    
45. */
    3 g$ x3 V. p; T; [  F) \. b2 q
46. 
    
47. int fputc(int ch, FILE *f)
      ]% b2 D& X1 \! u; @
48. 
    
49. {
    * ?' s" `% j4 e
50. 
    
51.     uart_send_char((uint8_t)ch);
    
52. 
    ) {3 Y8 [1 v- r. Z! Y: c( a5 n
53.     while(uart_send.start_flag!=0)
    3 Y3 W" r3 i- `
54. 
    ) D( F, A5 h, v) X# X# w
55.         ;
    
56. 
    ) M" V1 U9 p- f0 Y! V7 ~+ W: h: l; ?% Z
57.     return ch;
    # T$ r7 H# n# Z- H6 {
58. 
    
59. }

复制代码

程序工程可直接使用
Simulate_uart.zip (16.03 MB, 下载次数: 137)

2018-8-13 09:19 上传

点击文件名下载附件

支持一个。。。不错。。。

学习了，支持~~

串口模拟通讯没有尝试过,多串口通讯可以借鉴一下,版主辛苦了

非常不错的资料！

谢谢楼主分享！！！

签到签到签到