不同串口连接不同外设根据不同控制指令来执行相应的功能（wifi、语音等）如何同时进行不同串口之间的配置原理和配置单个串口相同，下面就以三个串口中断分别来进行LED的控制，后面根据自己的需求将串口接在不同的外设上面就好了。

stm32c8t6上面可以使用很多串口，通常没有经过重映射的引脚有三组串口
USART1 ------> TX(PA9) RX(PA10)
USART2 ------> TX(A2)  RX(A3)
USART3 ------> TX(PB10) RX(PB11)

下面所配置的串口就是这三组串口

下面是进行端口映射可以配置的串口引脚，可以根据自己的需求查看相关数据手册进行配置，和基本的配置大致相同，多了端口映射





串口配置源码

1. /*========================usart.h=====================*/
   
2. 
   
3. #ifndef __USART_H
   
4. #define __USART_H
   
5. 
   
6. #include "stm32f10x.h"
   
7. #include <stdio.h>
   
8. 
   
9. //串口1
   
10. #define USART1_GPIO_PORT      GPIOA
    
11. #define USART1_GPIO_CLK       RCC_APB2Periph_GPIOA
    
12. #define USART1_TX_GPIO_PIN    GPIO_Pin_9
    
13. #define USART1_RX_GPIO_PIN    GPIO_Pin_10
    
14. 
    
15. //串口2
    
16. #define USART2_GPIO_PORT      GPIOA
    
17. #define USART2_GPIO_CLK       RCC_APB2Periph_GPIOA
    
18. #define USART2_TX_GPIO_PIN    GPIO_Pin_2
    
19. #define USART2_RX_GPIO_PIN    GPIO_Pin_3
    
20. 
    
21. //串口3
    
22. #define USART3_GPIO_PORT      GPIOB
    
23. #define USART3_GPIO_CLK       RCC_APB2Periph_GPIOB
    
24. #define USART3_TX_GPIO_PIN    GPIO_Pin_10
    
25. #define USART3_RX_GPIO_PIN    GPIO_Pin_11
    
26. 
    
27. 
    
28. void usart_init(void);
    
29. void usart_init2(void);
    
30. void usart_init3(void);
    
31. void Init_Usart(void);
    
32. void USART_Send_Byte(USART_TypeDef* USARTx, uint16_t Data);
    
33. void USART_Send_String(USART_TypeDef* USARTx, char *str);
    
34. 
    
35. #endif  /* __USART_H */

复制代码

1. /*=======================usart.c======================*/
   
2. #include "./usart/usart.h"
   
3. /**
   
4. * 功能：串口初始化函数
   
5. * 参数：None
   
6. * 返回值：None
   
7. */
   
8. void usart_init(void)
   
9. {
   
10.     GPIO_InitTypeDef GPIO_Init_Structure;                            //定义GPIO结构体
    
11.     USART_InitTypeDef USART_Init_Structure;                          //定义串口结构体
    
12.         NVIC_InitTypeDef  NVIC_Init_Structure;                                                                                                                //定义中断结构体
    
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
14.         
    
15.     RCC_APB2PeriphClockCmd(USART1_GPIO_CLK,  ENABLE);                 //开启GPIOA时钟
    
16.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,  ENABLE);            //开启APB2总线复用时钟
    
17.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,  ENABLE);          //开启USART1时钟
    
18. 
    
19.     //配置PA9  TX
    
20.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_AF_PP;                //复用推挽
    
21.     GPIO_Init_Structure.GPIO_Pin   = USART1_TX_GPIO_PIN;
    
22.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_50MHz;   
    
23.     GPIO_Init( USART1_GPIO_PORT, &GPIO_Init_Structure);
    
24. 
    
25.     //配置PA10 RX
    
26.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;                //复用推挽
    
27.     GPIO_Init_Structure.GPIO_Pin   = USART1_RX_GPIO_PIN;
    
28.     GPIO_Init( USART1_GPIO_PORT, &GPIO_Init_Structure);
    
29.     //串口相关配置
    
30.           USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);                                                                                                                                                                        //串口中断配置
    
31.     USART_Init_Structure.USART_BaudRate = 115200;                                          //波特率设置为115200
    
32.     USART_Init_Structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;       //硬件流控制为无
    
33.     USART_Init_Structure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;                       //模式设为收和发
    
34.     USART_Init_Structure.USART_Parity = USART_Parity_No;                                   //无校验位
    
35.     USART_Init_Structure.USART_StopBits = USART_StopBits_1;                                //一位停止位
    
36.     USART_Init_Structure.USART_WordLength = USART_WordLength_8b;                           //字长为8位   
    
37.     USART_Init(USART1, &USART_Init_Structure);                                             //初始化        
    
38.     USART_Cmd(USART1, ENABLE);                                                            //串口使能
    
39.                
    
40.                 //中断结构体配置
    
41.         NVIC_Init_Structure.NVIC_IRQChannel                         =   USART1_IRQn;
    
42.         NVIC_Init_Structure.NVIC_IRQChannelCmd           =   ENABLE;
    
43.         NVIC_Init_Structure.NVIC_IRQChannelPreemptionPriority  =  0;
    
44.         NVIC_Init_Structure.NVIC_IRQChannelSubPriority         =  1;
    
45.         NVIC_Init(&NVIC_Init_Structure);
    
46. 
    
47. }
    
48. 
    
49. 
    
50. 
    
51. 
    
52. void usart_init2(void)
    
53. {
    
54.     GPIO_InitTypeDef GPIO_Init_Structure;                            //定义GPIO结构体
    
55.     USART_InitTypeDef USART_Init_Structure;                          //定义串口结构体
    
56.         NVIC_InitTypeDef  NVIC_Init_Structure;                                                                                                                //定义中断结构体
    
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
58.         
    
59.     RCC_APB2PeriphClockCmd(USART2_GPIO_CLK,  ENABLE);                 //开启GPIOA时钟
    
60.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,  ENABLE);            //开启APB2总线复用时钟
    
61.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,  ENABLE);          //开启USART1时钟
    
62. 
    
63.     //配置PA2 TX
    
64.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_AF_PP;                //复用推挽
    
65.     GPIO_Init_Structure.GPIO_Pin   = USART2_TX_GPIO_PIN;
    
66.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_10MHz;
    
67. 
    
68.     GPIO_Init( USART2_GPIO_PORT, &GPIO_Init_Structure);
    
69. 
    
70.     //配置PA3 RX
    
71.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;                //复用推挽
    
72.     GPIO_Init_Structure.GPIO_Pin   = USART2_RX_GPIO_PIN;
    
73.     GPIO_Init( USART2_GPIO_PORT, &GPIO_Init_Structure);
    
74.         
    
75.     USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);        
    
76.     USART_Init_Structure.USART_BaudRate = 115200;                                          //波特率设置为115200
    
77.     USART_Init_Structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;       //硬件流控制为无
    
78.     USART_Init_Structure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;                       //模式设为收和发
    
79.     USART_Init_Structure.USART_Parity = USART_Parity_No;                                   //无校验位
    
80.     USART_Init_Structure.USART_StopBits = USART_StopBits_1;                                //一位停止位
    
81.     USART_Init_Structure.USART_WordLength = USART_WordLength_8b;                           //字长为8位  
    
82.     USART_Init(USART2, &USART_Init_Structure);  
    
83.     USART_Cmd(USART2, ENABLE);
    
84.                
    
85.                 //中断结构体配置
    
86.         NVIC_Init_Structure.NVIC_IRQChannel                         =   USART2_IRQn;
    
87.         NVIC_Init_Structure.NVIC_IRQChannelCmd           =   ENABLE;
    
88.         NVIC_Init_Structure.NVIC_IRQChannelPreemptionPriority  =  0;
    
89.         NVIC_Init_Structure.NVIC_IRQChannelSubPriority         =  3;
    
90.         NVIC_Init(&NVIC_Init_Structure);
    
91. }
    
92. 
    
93. 
    
94. 
    
95. void usart_init3(void)
    
96. {
    
97.     GPIO_InitTypeDef GPIO_Init_Structure;                            //定义GPIO结构体
    
98.     USART_InitTypeDef USART_Init_Structure;                          //定义串口结构体
    
99.           NVIC_InitTypeDef  NVIC_Init_Structure;                                                                                                                //定义中断结构体
    
100.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
     
101.         
     
102.     RCC_APB2PeriphClockCmd(USART3_GPIO_CLK,  ENABLE);                 //开启GPIOA时钟
     
103.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,  ENABLE);            //开启APB2总线复用时钟
     
104.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,  ENABLE);          //开启USART1时钟
     
105. 
     
106.     //配置PB10 TX
     
107.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_AF_PP;                //复用推挽
     
108.     GPIO_Init_Structure.GPIO_Pin   = USART3_TX_GPIO_PIN;
     
109.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_10MHz;
     
110.     GPIO_Init( USART3_GPIO_PORT, &GPIO_Init_Structure);
     
111. 
     
112.     //配置PB11 RX
     
113.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;                //复用推挽
     
114.     GPIO_Init_Structure.GPIO_Pin   = USART3_RX_GPIO_PIN;
     
115.     GPIO_Init( USART3_GPIO_PORT, &GPIO_Init_Structure);
     
116.         
     
117.     USART_ITConfig(USART3,USART_IT_RXNE,ENABLE);        
     
118.     USART_Init_Structure.USART_BaudRate = 115200;                                          //波特率设置为115200
     
119.     USART_Init_Structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;       //硬件流控制为无
     
120.     USART_Init_Structure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;                       //模式设为收和发
     
121.     USART_Init_Structure.USART_Parity = USART_Parity_No;                                   //无校验位
     
122.     USART_Init_Structure.USART_StopBits = USART_StopBits_1;                                //一位停止位
     
123.     USART_Init_Structure.USART_WordLength = USART_WordLength_8b;                           //字长为8位   
     
124.     USART_Init(USART3, &USART_Init_Structure);   
     
125.     USART_Cmd(USART3, ENABLE);
     
126.                
     
127.                 //中断结构体配置
     
128.         NVIC_Init_Structure.NVIC_IRQChannel                         =   USART3_IRQn;
     
129.         NVIC_Init_Structure.NVIC_IRQChannelCmd           =   ENABLE;
     
130.         NVIC_Init_Structure.NVIC_IRQChannelPreemptionPriority  =  1;
     
131.         NVIC_Init_Structure.NVIC_IRQChannelSubPriority         =  3;
     
132.         NVIC_Init(&NVIC_Init_Structure);
     
133. }
     
134. 
     
135. 
     
136. //三个串口初始化函数
     
137. void Init_Usart(void)
     
138. {
     
139.         usart_init();
     
140.         usart_init2();
     
141.         usart_init3();
     
142. }
     
143. 
     
144. 
     
145. 
     
146. /**
     
147. * 功能：串口写字节函数
     
148. * 参数1：USARTx ：串口号
     
149. * 参数2：Data   ：需写入的字节
     
150. * 返回值：None
     
151. */
     
152. void USART_Send_Byte(USART_TypeDef* USARTx, uint16_t Data)
     
153. {
     
154.     USART_SendData(USARTx, Data);
     
155.     while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE)==RESET);
     
156. }
     
157. /**
     
158. * 功能：串口写字符串函数
     
159. * 参数1：USARTx ：串口号
     
160. * 参数2：str    ：需写入的字符串
     
161. * 返回值：None
     
162. */
     
163. void USART_Send_String(USART_TypeDef* USARTx, char *str)
     
164. {
     
165.     uint16_t i=0;
     
166.     do
     
167.     {
     
168.         USART_Send_Byte(USARTx,  *(str+i));
     
169.         i++;
     
170.     }
     
171.     while(*(str + i) != '\0');
     
172. 
     
173.     while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
     
174. }
     
175. /**
     
176. * 功能：重定向
     
177. */
     
178. int fputc(int ch,FILE *f)
     
179. {
     
180.     USART_SendData(USART1, (uint8_t)ch);
     
181.     while(USART_GetFlagStatus(USART1, USART_FLAG_TXE)==RESET);
     
182.     return (ch);
     
183. }
     
184. /**
     
185. * 功能：重定向
     
186. */
     
187. int fgetc(FILE *f)
     
188. {
     
189.     while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE)==RESET);
     
190.     return (int)USART_ReceiveData(USART1);
     
191. }
     
192. 
     
193. /*
     
194. void USART1_IRQHandler(void)
     
195. {
     
196.     if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET)
     
197.     {
     
198. 
     
199.     }
     
200. }*/
     
201. 
     
202. 
     
203. /*
     
204. void USART2_IRQHandler(void)
     
205. {
     
206.     if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET)
     
207.     {
     
208. 
     
209.     }
     
210. }*/
     
211. 
     
212. 
     
213. 
     
214. /*
     
215. void USART3_IRQHandler(void)
     
216. {
     
217.     char temp;
     
218.     if(USART_GetITStatus(USART3,USART_IT_RXNE) != RESET)
     
219.     {
     
220. 
     
221.     }
     
222. }
     
223. */

复制代码

1. /*=======================main.c======================*/
   
2. #include "stm32f10x.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. int main()
   
6. {
   
7.     Init_Usart();
   
8.         led_init();
   
9. 
   
10.         printf("====================串口测试=====================\n");
    
11.         //USART_Send_String(USART1,"usart1 test\n");
    
12.     while(1)
    
13.     {
    
14.                         
    
15.     }
    
16. }
    
17. 
    
18. //串口1中断
    
19. void USART1_IRQHandler(void)
    
20. {
    
21.         char temp;
    
22.         //USART_Send_String(USART1,"Usart1 interrupt test\n");        
    
23.         if(USART_GetITStatus(USART1,USART_IT_RXNE)!= RESET)
    
24.         {
    
25.                 temp = USART_ReceiveData(USART1);
    
26.                 if(temp == 'O')
    
27.                 {
    
28.                         GPIO_ResetBits(GPIOC,GPIO_Pin_13);
    
29.                         USART_Send_String(USART1,"Led Open Successful\n");               
    
30.                 }
    
31.                 if(temp == 'C')
    
32.                 {
    
33.                         GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
34.                         USART_Send_String(USART1,"Led Close Successful\n");
    
35.                 }
    
36.         }
    
37. }
    
38. 
    
39. 
    
40. //串口2中断
    
41. void USART2_IRQHandler(void)
    
42. {
    
43.         char temp;
    
44.         //USART_Send_String(USART2,"Usart2 interrupt test\n");        
    
45.         if(USART_GetITStatus(USART2,USART_IT_RXNE)!= RESET)
    
46.         {
    
47.                 temp = USART_ReceiveData(USART2);
    
48.                 if(temp == 'O')
    
49.                 {
    
50.                         GPIO_ResetBits(GPIOC,GPIO_Pin_13);
    
51.                         USART_Send_String(USART2,"Led Open Successful\n");               
    
52.                 }
    
53.                 if(temp == 'C')
    
54.                 {
    
55.                         GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
56.                         USART_Send_String(USART2,"Led Close Successful\n");
    
57.                 }
    
58.         }
    
59. }
    
60. 
    
61. //串口3中断
    
62. void USART3_IRQHandler(void)
    
63. {
    
64.         char temp;
    
65.         //USART_Send_String(USART3,"Usart3 interrupt test\n");        
    
66.         if(USART_GetITStatus(USART3,USART_IT_RXNE)!= RESET)
    
67.         {
    
68.                 temp = USART_ReceiveData(USART3);
    
69.                 if(temp == 'O')
    
70.                 {
    
71.                         GPIO_ResetBits(GPIOC,GPIO_Pin_13);
    
72.                         USART_Send_String(USART3,"Led Open Successful\n");               
    
73.                 }
    
74.                 if(temp == 'C')
    
75.                 {
    
76.                         GPIO_SetBits(GPIOC,GPIO_Pin_13);
    
77.                         USART_Send_String(USART3,"Led Close Successful\n");
    
78.                 }
    
79.         }
    
80. }
    

复制代码

实验结果



————————————————
版权声明：@slow-walker