( d& V" j* H' ?& _' Y- D7 N

一、概述

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。
  3 U+ C/ t/ ~- P7 Y/ z+ r

二、硬件电路

                                             

                                         图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： 串口控制命令
8 g. }$ `2 g& E& {( Y5 o" J! e

                          图：4_3 控制实例

四、源代码

1.USART初始化结构体介绍

1. typedefstruct
   
2. {
   6 w( }6 Z" U4 x$ C0 \$ E; I) M+ \
3. uint32_tUSART_BaudRate;           
   ! i* K5 j1 s0 \) W
4. uint16_tUSART_WordLength;         
   + T0 X9 A1 c, {$ R
5. uint16_tUSART_StopBits;           
   5 ?, ?) T2 P4 k% P8 S% h# H/ }
6. uint16_tUSART_Parity;              
   * C7 \+ |0 s! ~/ _7 A
7. uint16_tUSART_Mode;               
   % `) L4 \  ~1 [6 j7 I: t
8. uint16_tUSART_HardwareFlowControl;
   
9. } USART_InitTypeDef;

复制代码

• 波特率：每秒传输的二进制位个数。
• 数据长度：可选择8位，9位。
• 停止位：可选择0.5位、1位、1.5位和2位。
• 校验位：可选择无校验、奇校验、偶检验。
• USART模式：可选择接收模式、发送模式、收发模式。
  

2．主函数
8 g. ]1 O- x( G# L

1. /*
   
2. * Name                : main
   
3. * Description         : ---
   * U; R( k& g( K
4. * Author              : ysloveivy.
   - N# g( G1 c9 }% h
5. *
   / `+ n, I, b. U0 }) v* d
6. * History
   
7. * --------------------
   
8. * Rev                 : 0.00
   
9. * Date                : 11/21/2015
   # Z2 J7 O; u$ Z
10. *
    7 g5 s$ R4 j! a7 W; s
11. * create.
    # I. g# L: r% n- e* b/ Z
12. * --------------------
    
13. */
    6 H; j3 B5 ]- O9 u
14. int main(void)
    
15. {
    
16.         inti;
    / T' B' v( V# {! f1 t; j) C- v
17.         char buffer[20];
    
18.         led.initialize();
    6 H3 F( e/ {6 J) B
19.         usart4.initialize(9600);
    : P$ ~. ]+ q# j/ q2 H- B; N/ u6 o
20.         usart4.printf("hello! I am iCore3!\r\n");                              //串口4输出
    
21.         while(1){
    
22.                 if(usart4.receive_ok_flag){                                          //接收完成
    ' e0 s# V$ k1 a( ?$ u
23. usart4.receive_ok_flag = 0;
    6 x: y" o2 I% V
24.                         for(i = 0;i <20;i++){
    6 h5 C& ?% c1 N( \$ P2 T$ L
25.                                 buffer[i] = tolower(usart4.receive_buffer[i]);
    
26.                         }
    
27.                         //比较接收信息
    7 Z% F& F/ Y& @
28.                         if(memcmp(buffer,"led_red_on",strlen("led_red_on")) == 0){
    
29.                                 LED_RED_ON;
    ( F+ Y% @! L1 I
30.                                 usart4.printf("ok!\r\n");
    
31.                         }
    
32.                         if(memcmp(buffer,"led_red_off",strlen("led_red_off")) == 0){
    6 |) f+ Z7 W8 C) A" `
33.                                 LED_RED_OFF;
    
34.                                 usart4.printf("ok!\r\n");
    
35.                         }
    1 Z& S7 \8 Q! q3 C1 E. v
36.                         if(memcmp(buffer,"led_green_on",strlen("led_green_on")) == 0){
    # k* n: ^% t; X* i
37.                                 LED_GREEN_ON;
    
38.                                 usart4.printf("ok!\r\n");
    1 Z, `( s+ {' [4 [  n! P/ }
39.                         }
    
40.                         if(memcmp(buffer,"led_green_off",strlen("led_green_off")) == 0){
    - Z' W0 i  J5 N& z% R
41.                                 LED_GREEN_OFF;
    
42.                                 usart4.printf("ok!\r\n");
    
43.                         }
    
44.                         if(memcmp(buffer,"led_blue_on",strlen("led_blue_on")) == 0){
    ; w# Y6 K! R( w# G5 Y" r1 L
45.                                 LED_BLUE_ON;
    
46.                                 usart4.printf("ok!\r\n");
    6 w* T* _1 [: a& I  p! o
47.                         }
    
48.                         if(memcmp(buffer,"led_blue_off",strlen("led_blue_off")) == 0){
    
49.                                 LED_BLUE_OFF;
    
50.                                 usart4.printf("ok!\r\n");
    $ ]* j7 F- i; e
51.                         }
    
52.                 }
    . S3 i% h. v: K9 l/ J  T7 L  f' ~; l
53.         }
    
54. }
    3 ~" a; ^2 ^  M( K6 C7 L2 [7 S

复制代码

3.USART初始化及相关配置

1. /*
   9 m: o  s5 E9 g& M- c
2. * Name               : initialize_usart4
   
3. * Description        : ---
   
4. * Author             : XiaomaGee
   5 j+ m- Z5 j& T$ X3 E  e& Y7 ^
5. *
   
6. * History
   
7. * -------------------
   
8. * Rev                : 0.00
   
9. * Date               : 11/21/2015
   
10. *
    # l. n- R6 e, e: Y# q! _+ N
11. * create.
    
12. * -------------------
    
13. */
    
14. staticint initialize_usart4(unsignedlongintbaudrate)
    # M4 ?4 H' E) g
15. {
    
16.         GPIO_InitTypeDefGPIO_InitStructure;
    
17.         USART_InitTypeDefUSART_InitStructure;
    
18.         NVIC_InitTypeDef NVIC_InitStructure;
    ; T8 V+ I* @* U. d
19. 
    
20.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);             // GPIO时钟使能
    , y3 P9 g) [7 E
21. 
    * \9 B2 J! Q3 W9 D. @2 U, g
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;                        //PA0为复用推挽输出
    & {! y- T$ I1 Y( A
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    8 [8 R. a4 C2 t0 M
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    & c1 d, l, m; l) k
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    : r7 y0 o- t1 K# \: j8 O  N! Q. d
26. 
    1 S' J+ S# f/ Y, G6 e4 K
27.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;                        //PA1为浮空输入
    6 d) t! ]  N& C$ g: J7 g" G& ~% a
28.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    ) U6 L9 ~0 c; B. d1 I. c' _) J
29.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    6 }% q' `% n2 l/ F
30.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
31. 
    
32.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource0,GPIO_AF_UART4);           //PA0引脚复用为UART4
    
33.         GPIO_PinAFConfig(GPIOA,GPIO_PinSource1,GPIO_AF_UART4);           //PA1引脚复用为UART4
    
34. 
    
35.         USART_DeInit(UART4);
    
36.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);            //UART4时钟使能
    
37.         USART_InitStructure.USART_BaudRate = baudrate;                   //波特率
    9 K- o: r9 B9 {4 e
38.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;      //8个数据位
    
39.         USART_InitStructure.USART_StopBits = USART_StopBits_1;           //1个停止位
    , k% Y6 Y  ^% G5 Q; [8 M) A6 b
40.         USART_InitStructure.USART_Parity = USART_Parity_No ;             //无奇偶校验位
    
41.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
42.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;  //收发模式
    0 z: o  g& ~$ O2 ?2 l" l
43.         USART_Init(UART4, &USART_InitStructure);                         //初始化UART4
    - ~: M( F0 l* y3 \, {
44.         USART_Cmd(UART4, ENABLE);                                        //使能UART4
    
45.         USART_ITConfig(UART4,USART_IT_PE,ENABLE);
    
46.         USART_ITConfig(UART4,USART_IT_RXNE,ENABLE);                      //打开UART4的中断
    % q4 T5 N4 B" {: W& [5 ~
47. 
    + @, _& C5 R; x7 u+ U
48.         NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    ( b7 v/ m5 N' }7 ~4 g) G8 k
49.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
50.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
51.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
52.         NVIC_Init(&NVIC_InitStructure);
    ) c! `2 S+ o" H5 E% F1 v
53. 
    
54.         return0;
    
55. }
    * s' ?3 h2 o* p: w( B
56. /*
    
57. * Name               : send_buffer4
    1 f9 m. J- m0 y* |; r; E
58. * Description        : ---
    
59. * Author             : XiaomaGee
    
60. *
    1 c3 V4 N0 Q5 c6 ^; V
61. * History
    ; w' ^- E* a2 t( U4 E0 p
62. * -------------------
    7 n8 T: ^/ R! w
63. * Rev                : 0.00
    
64. * Date               : 11/21/2015
    
65. *
    
66. * create.
    
67. * -------------------
    
68. */
    " `& o! t- N9 j! ]! Z1 u0 {6 Z
69. staticint
    % K( Y8 F- c* W7 O( l- p' n( t
70. send_buffer4(void * buf,intlen)
    6 o: {7 [5 w* z( k
71. {
    
72.         char *p = (char *)buf;
    
73. 
    * R1 e+ Q9 P9 }$ p. Q4 q
74.         if(len<= 0)return -1;
    ( }& ]2 H% u0 q/ Z4 Y# U
75. 
    
76.         while(len --){
    8 f% u2 e- N9 b$ `2 W$ p& w
77.                 send_byte_to_usart4(*p);
    
78.                 p ++;
    
79.         }
    
80.         return0;
    & E7 J( k& y* s$ O* t
81. }
    
82. 
    5 W1 z( \, I% k
83. /*
    
84. * Name               : send_byte_to_usart4
    4 J% r% |* H4 [8 d6 v9 L9 J; S
85. * Description        : ---
    
86. * Author             : XiaomaGee
    
87. *
    : o; j# D* @: N& @! Q
88. * History
    * s# L- I1 T9 s" \3 ]2 {: I
89. * -------------------
    " x. |$ ~: G- @
90. * Rev                : 0.00
    ( |) L5 h, F2 B% {) Y# s! K* K
91. * Date               : 11/21/2015
    
92. *
    & h& ?& _. J0 \7 {2 ^
93. * create.
    , y2 x/ T; c% o
94. * -------------------
    
95. */
    6 O- i- K' ?0 k" K/ Q5 ?8 d. \" {
96. staticint
    % E9 K4 I  x; b& k, H  {5 {2 Z
97. send_byte_to_usart4(char data)                  //TTL通信
    
98. {
    
99.         while(!(USART_GetFlagStatus(UART4,USART_FLAG_TC) == 1));          //等待发送数据完成
    
100.         USART_SendData(UART4,data);                                       //将数据写入数据寄存器中
     
101. 
     ; L+ |! s& X8 u. d
102.         return0;
     , W8 |1 u" d, M) r$ E3 C4 C- d
103. }
       P2 T3 }7 Y4 y, w  Y
104. 
     & G- h5 v! W& m# S$ f: j
105. /*
     
106. * Name               : send_string_to_usart4
     ; k8 [6 w" l' D0 u  E
107. * Description        : ---
     
108. * Author             : XiaomaGee
     ( k8 O3 k1 G+ p( J
109. *
     
110. * History
     $ l4 K, K" J; y: I& A
111. * -------------------
     3 c3 ?5 ^, _: Q! B9 K
112. * Rev                : 0.00
     4 v! r1 R9 r0 c. G, F& e3 W# G
113. * Date               : 11/21/2015
     
114. *
     
115. * create.
     
116. * -------------------
     
117. */
     
118. staticint
     / S, R3 A2 ~4 }6 M+ w7 ~: q
119. send_string_to_usart4(char * str)
     
120. {
     $ A; |! ]) b- j% }
121.         while(*str!='\0'){
     ) z" i0 s% }. G1 e' m; O; U9 g, a
122.                 while(!(USART_GetFlagStatus(UART4,USART_FLAG_TC) == 1));
     
123.                 USART_SendData(UART4,*str++);
     
124.         }
     1 g" N$ ~1 [. _# J  m, c& M1 Q
125.         return0;
     
126. }
     
127. /*
     
128. * Name               : UART4_IRQHandler
     
129. * Description        : ---
     
130. * Author             : XiaomaGee
       a" {# l% x  e8 {  p. ~
131. *
     # ]; ?9 _) {! P/ r  t( s( A: v
132. * History
     
133. * -------------------
     
134. * Rev                : 0.00
     
135. * Date               : 11/21/2015
     3 l. T  C; I" l! [. O
136. *
     ' X5 l% O3 K* E# G
137. * create.
     
138. * -------------------
     . V# Q& q; f8 Y. x/ Z* ^
139. */
     7 w% i& X: X2 f4 L  I
140. int
     . j& `6 p) b$ d
141. UART4_IRQHandler(void)
     : e0 M5 _! ~$ @1 g5 S1 n
142. {
     
143. while(USART_GetFlagStatus(UART4,USART_FLAG_RXNE) == 0);
     
144.         usart4.receive_buffer[usart4.counter++]=USART_ReceiveData(UART4); //接收数据
     $ v: u. T+ p( h5 |" P! h# Z
145. 
     ' L% _/ g/ ?# k; z
146.         if(usart4.receive_buffer[usart4.counter - 1] == '\n'&& usart4.receive_buffer[usart4.counter - 2] == '\r'){
     2 [9 W9 B  L1 F) B, l" S! G
147.                         usart4.receive_buffer[usart4.counter-1]=0;
     
148.                         usart4.counter=0;
     
149.                 usart4.receive_ok_flag=1;
     ) f- S" Y$ X/ X
150. return0;
     
151. }
     
152. /*
     
153. * Name               : printf
     
154. * Description        : ---
     
155. * Author             : XiaomaGee
     5 q( w3 t( a% g$ G8 B3 Z8 X! G
156. *
     ) Q; g& K9 z: v$ z1 T1 b
157. * History
     
158. * -------------------
     , b) W1 e! v% }3 |4 H8 P' _
159. * Rev                : 0.00
     
160. * Date               : 11/21/2015
     
161. *
     
162. * create.
     1 }, F6 u  N4 u5 [8 j# `  u* N: D
163. * -------------------
     
164. */
     
165. staticint
     3 Q& q, V& [3 a$ R: i. f7 B) U
166. my_printf4(constchar * fmt,...)                             //串口4输出
     ' b, B! Q8 j4 P" d
167. {
     
168.         __va_listarg_ptr;
     
169.         charbuf[UART_BUFFER_SIZE];
     
170. 
     
171.         memset(buf,'\0',sizeof(buf));
     9 F8 ?; e, H% T" C
172. 
     
173.         va_start(arg_ptr,fmt);
     1 F/ ]( L! p* G  C( a) H4 L% V
174.         vsprintf(buf,fmt,arg_ptr);
       N$ k3 P7 h. T8 j  h# h
175.         va_end(arg_ptr);
     
176. 
     $ x( s; S  I) s/ S  z
177.         send_string_to_usart4(buf);
     + r7 ~2 O( Q8 L3 o! E: C4 b+ v% X
178. 
     3 v( q- G$ @5 p0 P. e) L
179.         return0;

复制代码

五、 实验现象

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

六、代码包下载

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

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

好牛好贴

谢谢楼主的强大资源