( j, w' A* w4 a) |* h) c

一、概述

1、UART简介

     UART:通用同步/异步串行接收/发送器，由时钟发生器、数据发送器和接收器三大部分组成。UART是一个全双工通用同步/异步串行收发模块，该接口是一个高度灵活的串行通信设备。STM32F407IGT6具有6个UART收发器，可使用相应的代码使能后使用。

2、UART特点

• 全双工操作(相互独立的接收数据和发送数据)。
• 同步操作时，可主机时钟同步，也可从机时钟同步。
• 支持8和9位数据位，1或2位停止位的串行数据桢结构。
• 由硬件支持的奇偶校验位发生和检验。
• 数据溢出检测。
• 帧错误检测。
• 包括错误起始位的检测噪声滤波器和数字低通滤波器。
• 三个完全独立的中断，TX发送完成、TX发送数据寄存器空、RX接收完成。
• 支持多机通信模式。
• 支持倍速异步通信模式。
  

3、UART时序                              

           图4_0 UART时序

空闲位：高电平。

启动位：一个低电平。

字符数据：可以选择8和9位数据位。

奇偶校验位：根据需要选择是否进行校验。

停止位：一个高电平。

4、TTL、RS232、RS485、RS422通信

TTL、RS232、RS485都是指电平信号，USART可使用相应的电平转换芯片，实现这三种通信。

• TTL：电平信号数据表示采用二进制规定，+5V等价于逻辑“1”，0V等价于逻辑“0”。通讯方式为全双工通信。
• RS232：232中任何一条信号线的电压均为负逻辑关系。即：逻辑“1”为-3到-15V;逻辑“0”为+3到+15V。通讯方式为全双工，通讯距离15m，RS-232的数据最高传输速率为20Kbps。
• RS485：RS485采用差分信号负逻辑，逻辑"1”以两线间的电压差为-(2~6)V表示;逻辑"0"以两线间的电压差为+(2~6)V表示。通讯方式为半双工，通讯距离1200m，RS-485的数据最高传输速率为10Mbps。
• RS422：RS422采用两对差分线传输数据，电平与RS485相同。通讯方式为全双工，通讯距离1200m，RS-422的数据最高传输速率为10Mbps。
  + _, w4 c; n; q- [: n' u4 f. G- \

二、硬件电路

                                             

                                         图4_1UART引脚图

           图4_2UART转USB

  本试验使用的芯片STM32F407IGT6，使用UART为UART_4，引脚位PA0和PA1，经过串口转USB芯片CH340转换后，可通过USB接口与计算机通讯。

三、 实验原理

  计算机安装 CH340 驱动后，可通过串口工具来接收串口发送的数据和向串口发送给数据。用串口工具打开iCore3对应的端口，波特率设为115200，发送相应的命令，便可以控制ARM LED的亮灭情况。串口命令如下表：

LED_RED_ON\cr\lf	LED 红灯亮
LED_RED_OFF\cr\lf	LED 红灯灭
LED_BLUE_ON\cr\lf	LED 蓝灯亮
LED_BLUE_OFF\cr\lf	LED 蓝灯灭
LED_GREEN_ON\cr\lf	LED 绿灯亮
LED_GREEN_OFF\cr\lf	LED 绿灯灭

              表4_1： 串口控制命令
2 r' p$ S+ i# l* k

                          图：4_3 控制实例

四、源代码

1.USART初始化结构体介绍

1. typedefstruct
   0 _! ^$ L( s3 G* V: d+ K. O! }" E5 H
2. {
   
3. uint32_tUSART_BaudRate;           
   
4. uint16_tUSART_WordLength;         
   " q* M% D+ M. C7 V6 k( p
5. uint16_tUSART_StopBits;           
   
6. uint16_tUSART_Parity;              
   2 f' F2 J) r/ s, Y7 d3 y
7. uint16_tUSART_Mode;               
   
8. uint16_tUSART_HardwareFlowControl;
   
9. } USART_InitTypeDef;

复制代码

• 波特率：每秒传输的二进制位个数。
• 数据长度：可选择8位，9位。
• 停止位：可选择0.5位、1位、1.5位和2位。
• 校验位：可选择无校验、奇校验、偶检验。
• USART模式：可选择接收模式、发送模式、收发模式。
  6 h2 u' o6 d% A. J( J* S  U' f

2．主函数

1. /*
   
2. * Name                : main
   
3. * Description         : ---
   
4. * Author              : ysloveivy.
   : L% H" U/ ]4 A2 R4 Z
5. *
   
6. * History
   
7. * --------------------
   
8. * Rev                 : 0.00
   3 i( W2 J+ Q( R0 ~
9. * Date                : 11/21/2015
   
10. *
    - w; v4 z: k, b/ g8 D, j
11. * create.
    3 B8 ]  o0 m0 m& O
12. * --------------------
    8 A5 E" Z1 d* G2 d& u, H
13. */
    - Y5 U! ^& M; {% Z- P
14. int main(void)
    
15. {
    : f/ Y" ]" A  ]) d, b/ ^2 V7 O$ b6 l
16.         inti;
    
17.         char buffer[20];
    
18.         led.initialize();
    
19.         usart4.initialize(9600);
    
20.         usart4.printf("hello! I am iCore3!\r\n");                              //串口4输出
    
21.         while(1){
    ; y( l. H! \" X( \+ `
22.                 if(usart4.receive_ok_flag){                                          //接收完成
    
23. usart4.receive_ok_flag = 0;
    
24.                         for(i = 0;i <20;i++){
    0 Q- W4 N) w  w1 b6 i2 ]( Z
25.                                 buffer[i] = tolower(usart4.receive_buffer[i]);
    6 Y* U* n! i8 x6 L! ^( P
26.                         }
    
27.                         //比较接收信息
    + M( h% L6 f% I1 ]& Q0 c3 L; f
28.                         if(memcmp(buffer,"led_red_on",strlen("led_red_on")) == 0){
    
29.                                 LED_RED_ON;
    : X# p1 O# X6 M
30.                                 usart4.printf("ok!\r\n");
    
31.                         }
    + ^8 b! ~0 x8 B% G# G2 |
32.                         if(memcmp(buffer,"led_red_off",strlen("led_red_off")) == 0){
    & d; R7 ^2 v0 r9 H4 d
33.                                 LED_RED_OFF;
    
34.                                 usart4.printf("ok!\r\n");
    % o1 k0 T3 G* y+ K/ e( H
35.                         }
    
36.                         if(memcmp(buffer,"led_green_on",strlen("led_green_on")) == 0){
    
37.                                 LED_GREEN_ON;
    . j+ u9 w0 v; J4 \
38.                                 usart4.printf("ok!\r\n");
    
39.                         }
    
40.                         if(memcmp(buffer,"led_green_off",strlen("led_green_off")) == 0){
    
41.                                 LED_GREEN_OFF;
    
42.                                 usart4.printf("ok!\r\n");
      L! O5 ~% z) ?
43.                         }
    % E0 E8 S+ S: c1 i4 \. Q
44.                         if(memcmp(buffer,"led_blue_on",strlen("led_blue_on")) == 0){
    
45.                                 LED_BLUE_ON;
    2 C0 V6 F9 {$ k
46.                                 usart4.printf("ok!\r\n");
    
47.                         }
    " G) ~4 g9 \( i) }: y+ |5 g3 F
48.                         if(memcmp(buffer,"led_blue_off",strlen("led_blue_off")) == 0){
    # @4 O" y6 f$ H
49.                                 LED_BLUE_OFF;
    
50.                                 usart4.printf("ok!\r\n");
    + h1 r- [1 J, l( P
51.                         }
    
52.                 }
    
53.         }
    
54. }
    8 V: o: H1 [3 L/ @& y3 h

复制代码

3.USART初始化及相关配置

1. /*
   - G9 e; ]/ W* K1 r# X& D: _
2. * Name               : initialize_usart4
   0 w7 o0 n  e( d7 C( A4 v0 u
3. * Description        : ---
   
4. * Author             : XiaomaGee
   
5. *
   
6. * History
   
7. * -------------------
   ! N* g, t  d- q- ~
8. * Rev                : 0.00
   7 B. z* Z! K$ g1 `: ^. c
9. * Date               : 11/21/2015
   
10. *
    ! e) c9 ]' ^2 w. C
11. * create.
    + E! T/ X% t3 g% {/ R. Z
12. * -------------------
    
13. */
    
14. staticint initialize_usart4(unsignedlongintbaudrate)
    5 X0 o( j. b+ p7 J
15. {
    
16.         GPIO_InitTypeDefGPIO_InitStructure;
    
17.         USART_InitTypeDefUSART_InitStructure;
    # b( H$ k, W+ `4 Y  ~- \
18.         NVIC_InitTypeDef NVIC_InitStructure;
    
19. 
    
20.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);             // GPIO时钟使能
    5 \0 _8 g# j. y, Q) K
21. 
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;                        //PA0为复用推挽输出
    
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    6 L. F* l4 Y/ h8 J5 W0 X
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    . d2 G4 I- r5 h7 i& D1 N5 f
26. 
    
27.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                        //PA1为浮空输入
    
28.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
29.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
30.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    , ~+ C! B: f' w, b/ e
31. 
    7 ~% m& \. l- r3 v& }
32.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource0,GPIO_AF_UART4);           //PA0引脚复用为UART4
    
33.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource1,GPIO_AF_UART4);           //PA1引脚复用为UART4
    2 K: I- I5 i  B
34. 
    + o* V0 S3 q& R4 v. a, T2 g
35.         USART_DeInit(UART4);
    
36.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);            //UART4时钟使能
    
37.         USART_InitStructure.USART_BaudRate = baudrate;                   //波特率
    : b2 \" U5 q8 F2 T1 Y) Y# Q
38.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;      //8个数据位
    9 B9 a% w$ ?: m4 w( }; o+ V/ f2 z0 h" W
39.         USART_InitStructure.USART_StopBits = USART_StopBits_1;           //1个停止位
    
40.         USART_InitStructure.USART_Parity = USART_Parity_No ;             //无奇偶校验位
    ' P" e- M" i+ m/ A2 \
41.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    3 ~# O* [) o* P- W* o+ X$ h
42.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;  //收发模式
    
43.         USART_Init(UART4, &USART_InitStructure);                         //初始化UART4
    
44.         USART_Cmd(UART4, ENABLE);                                        //使能UART4
    
45.         USART_ITConfig(UART4,USART_IT_PE,ENABLE);
    
46.         USART_ITConfig(UART4,USART_IT_RXNE,ENABLE);                      //打开UART4的中断
    . j- ~$ L" q; P
47. 
    
48.         NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    
49.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
50.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
51.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    + l: Q; N* b9 J3 s  w, |
52.         NVIC_Init(&NVIC_InitStructure);
    ) C- D5 v9 w4 i0 t8 S: \
53. 
    . l7 B- k2 h  b, q5 \. N/ P, ~
54.         return0;
    
55. }
    
56. /*
    5 l. A7 \  k( L  i" Y6 e  I
57. * Name               : send_buffer4
    1 b% D4 T! c7 i, O2 `3 V* m- I
58. * Description        : ---
    
59. * Author             : XiaomaGee
    
60. *
    % C  W) z( S4 f, G6 r% c5 X0 f0 z
61. * History
    
62. * -------------------
    
63. * Rev                : 0.00
    
64. * Date               : 11/21/2015
    
65. *
    
66. * create.
    
67. * -------------------
    
68. */
    / z( c, c# Q3 W7 {
69. staticint
    3 S2 _4 z4 u1 s1 A& e& O
70. send_buffer4(void * buf,intlen)
    1 }( ]4 q7 ~  n( T
71. {
    ' K( p; j, o- H2 K! Z% Z3 W. v, m
72.         char *p = (char *)buf;
    
73. 
    
74.         if(len<= 0)return -1;
    
75. 
    
76.         while(len --){
    1 z5 N9 G+ g( r1 V: I
77.                 send_byte_to_usart4(*p);
    ; j8 Y7 C) i' c
78.                 p ++;
    
79.         }
    
80.         return0;
    ; `& U" L+ ~3 B# H& L8 m! v
81. }
    
82. 
    
83. /*
    
84. * Name               : send_byte_to_usart4
    2 s) K+ V7 ~3 [4 ?# j% A
85. * Description        : ---
    
86. * Author             : XiaomaGee
    
87. *
    
88. * History
      a! G7 S. k  B+ l# G% c: H
89. * -------------------
    
90. * Rev                : 0.00
    
91. * Date               : 11/21/2015
    , t9 T- ?) S/ Q, h- @. h8 R9 d4 b
92. *
    . v* e. Q7 l- o* h3 L. X: J
93. * create.
    
94. * -------------------
    " u( m, v' T' a
95. */
    
96. staticint
    
97. send_byte_to_usart4(char data)                  //TTL通信
    ; ^4 f' Q# p8 j8 S) y% S: q! y  M
98. {
    
99.         while(!(USART_GetFlagStatus(UART4,USART_FLAG_TC) == 1));          //等待发送数据完成
    " g3 Y( v( R+ |; n- b% }
100.         USART_SendData(UART4,data);                                       //将数据写入数据寄存器中
     
101. 
     
102.         return0;
     # i8 E8 q' t0 u5 m, X1 o
103. }
     
104. 
     
105. /*
     
106. * Name               : send_string_to_usart4
     5 x8 b! ^4 N% E5 q, L- ^
107. * Description        : ---
     
108. * Author             : XiaomaGee
     
109. *
     
110. * History
     
111. * -------------------
     . F# g2 ]0 `6 k' y. S! P
112. * Rev                : 0.00
     
113. * Date               : 11/21/2015
     ; ]8 ~/ ^+ `6 j
114. *
     : b0 g- ~* j. _, V# s7 M5 b; R& [( V
115. * create.
     . c9 C6 F/ N* `
116. * -------------------
     
117. */
     1 x$ T6 V# T* y
118. staticint
     
119. send_string_to_usart4(char * str)
     
120. {
     7 c/ [, V. S# H  Z) _; ^
121.         while(*str!='\0'){
     
122.                 while(!(USART_GetFlagStatus(UART4,USART_FLAG_TC) == 1));
     * B* o' o. s: ^
123.                 USART_SendData(UART4,*str++);
     ! h) L" i( P2 v# J9 J% b! l4 L6 A0 s
124.         }
     8 z2 Q; ]* I+ t9 V9 v! ?
125.         return0;
     3 U( I; ]. S8 S. F
126. }
     
127. /*
     
128. * Name               : UART4_IRQHandler
     
129. * Description        : ---
     $ l7 U& {' O0 o" ^8 @6 @- |6 h- m
130. * Author             : XiaomaGee
     
131. *
     
132. * History
     
133. * -------------------
     ( X+ h5 C  J+ y4 Z7 h
134. * Rev                : 0.00
     
135. * Date               : 11/21/2015
     
136. *
     ' y- o& L5 P; L3 m6 x  m( j: t
137. * create.
     
138. * -------------------
     
139. */
     ; b8 g8 ]  {6 S- C
140. int
     
141. UART4_IRQHandler(void)
     
142. {
     5 A' `0 k* A) e8 d# o& k; l4 V
143. while(USART_GetFlagStatus(UART4,USART_FLAG_RXNE) == 0);
     
144.         usart4.receive_buffer[usart4.counter++]=USART_ReceiveData(UART4); //接收数据
     
145. 
     4 L" G/ f, h4 ^" i; B) h
146.         if(usart4.receive_buffer[usart4.counter - 1] == '\n'&& usart4.receive_buffer[usart4.counter - 2] == '\r'){
     
147.                         usart4.receive_buffer[usart4.counter-1]=0;
     
148.                         usart4.counter=0;
     1 n8 w+ s( b' R) f: G. e; z9 @, e
149.                 usart4.receive_ok_flag=1;
     
150. return0;
     
151. }
     3 v  |8 I8 q8 ?9 z( W9 L* L
152. /*
     " ]7 W% U6 u- D
153. * Name               : printf
     9 _' i& J% b$ |1 g$ W3 T: h
154. * Description        : ---
     2 E: m8 h# ~/ C" E9 Q3 U+ Z
155. * Author             : XiaomaGee
     
156. *
     
157. * History
     
158. * -------------------
     
159. * Rev                : 0.00
     
160. * Date               : 11/21/2015
     
161. *
     0 \& A5 e! v3 m' S2 }, r/ T9 D9 ?5 P
162. * create.
     2 s" b3 }0 c) U8 f0 z
163. * -------------------
     
164. */
     
165. staticint
     ' H( H9 {! W8 `5 s$ }9 x3 ]4 r
166. my_printf4(constchar * fmt,...)                             //串口4输出
     
167. {
     $ N6 ^* ~% G# v) x. \% V. i+ E, f, S
168.         __va_listarg_ptr;
     
169.         charbuf[UART_BUFFER_SIZE];
     & P1 x% k/ M: k4 Q. ^
170. 
     ! g/ K+ u# v) I& m7 ~7 b
171.         memset(buf,'\0',sizeof(buf));
     + G5 _3 t% Z- T0 T- l
172. 
     
173.         va_start(arg_ptr,fmt);
     " T% u0 q4 R0 F3 t8 r1 f6 Z& D
174.         vsprintf(buf,fmt,arg_ptr);
     
175.         va_end(arg_ptr);
     
176. 
     
177.         send_string_to_usart4(buf);
     3 P; p, T7 W- z
178. 
     / G4 g" t% F7 j( W% H8 ]
179.         return0;

复制代码

五、 实验现象

通过串口调试工具输入相应的命令，可以看到iCore3执行相应的明命令，LED按控制命令亮灭。

六、代码包下载

网盘：https://pan.baidu.com/s/1pJxluWF

感谢分享，已汇总到2月技术原创  https://www.stmcu.org.cn/module/forum/thread-614799-1-1.html

好牛好贴

谢谢楼主的强大资源