RISC-V MCU应用教程之赤菟V307多UART通信

最新推荐文章于 2024-03-27 14:29:35 发布
最新推荐文章于 2024-03-27 14:29:35 发布
阅读量508 收藏 2
点赞数 1
分类专栏： RISC-V MCU 文章标签： 单片机 risc-v mcu
原文链接：https://blog.csdn.net/weixin_44845994/article/details/123548420
版权

本文章介绍使用CH32V307单片机实现主机轮回接收从机传输的数据，并在串口软件显示。
您需要的资料：CH32V307单片机数据手册及例程
一、单片机串口部分简介

由上图可知，CH32V307有8个串口（USART+UART）。

 由数据手册可知，USART有3个，USART1挂接在APB2总线上，USART2和USART2以及7个UART挂接在APB1总线上。
为了方便插拔引脚转接线，将数据手册中有关串口引脚陈列如下表格中。

防止原有映射引脚被其它外设占用，手册中定义的串口复用引脚陈列如下。

二、通讯原理及实现

1. Master程序为采集数据单片机烧录，Slave程序为数据发送单片机烧录；
2. 主程序使6个串口中断周期性的开关，达到每次只接受一个Slave数据，达到周期性采集6个Slave数据的目的。最多可外接8路串口，本例程中USART1用来与PC串口通讯，UART8因器件不够暂未使用到。Slave均使用USART2，分别连接到Master剩余的6串口上。
3. 若Master指定采集第x个Slave数据，则需先发送一个数据0作为启动Slave发送数据的请求命令，Slave判定请求命令正确后，在进行数据的发送。这种协议的约定，保证了Master接收Slave数据的完整性。（在Master接收到Slave数据后，可将原数据返回Slave做校验，本程序暂未实现，请读者自行尝试）
4. 硬件连接如下，因为没有足够的usb供电，Slave取电为板载级联杜邦线方式。中间一块为Master采集板，周边六块为Slave数据发送板。

 5. 程序如下

  1 //双机通讯，使用USART
  2 
  3 #include "debug.h"
  4 
  5 /* Global define */
  6 #define TxSize1    (size(TxBuffer1))
  7 /* Global Variable */
  8 u8 RxBuffer1 = 0; /* Send by UART2 */
  9 u8 RequestData=0;//请求发送数据
 10 u8 Rxfinish1 = 2;//先给个初始值，进入case 2，启动接收
 11 //void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 12 void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 13 void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 14 void UART4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 15 void UART5_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 16 void UART6_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 17 void UART7_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 18 //void UART8_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
 19 
 20 /*********************************************************************
 21  * @fn      USARTx_CFG
 22  *
 23  * @brief   Initializes the USART2 & USART3 peripheral.
 24  *
 25  * @return  none
 26  */
 27 void USARTx_CFG(void)
 28 {
 29     GPIO_InitTypeDef  GPIO_InitStructure = {0};
 30     USART_InitTypeDef USART_InitStructure = {0};
 31     NVIC_InitTypeDef  NVIC_InitStructure = {0};
 32 
 33     RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2|RCC_APB1Periph_USART3|RCC_APB1Periph_UART4|RCC_APB1Periph_UART5|RCC_APB1Periph_UART6|RCC_APB1Periph_UART7|RCC_APB1Periph_UART8, ENABLE);
 34 //    RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE);
 35     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD, ENABLE);
 36 
 37 //    /* USART1 TX-->A.9  RX-->A.10 */
 38 //    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
 39 //    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 40 //    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 41 //    GPIO_Init(GPIOA, &GPIO_InitStructure);
 42 //    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
 43 //    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 44 //    GPIO_Init(GPIOA, &GPIO_InitStructure);
 45     /* USART2 TX-->A.2  RX-->A.3 */
 46     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
 47     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 48     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 49     GPIO_Init(GPIOA, &GPIO_InitStructure);
 50     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
 51     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 52     GPIO_Init(GPIOA, &GPIO_InitStructure);
 53     /* USART3 TX-->B.10  RX-->B.11 */
 54     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
 55     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 56     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 57     GPIO_Init(GPIOB, &GPIO_InitStructure);
 58     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
 59     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 60     GPIO_Init(GPIOB, &GPIO_InitStructure);
 61     /* UART4 TX-->C.10  RX-->C.11 */
 62     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
 63     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 64     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 65     GPIO_Init(GPIOC, &GPIO_InitStructure);
 66     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
 67     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 68     GPIO_Init(GPIOC, &GPIO_InitStructure);
 69     /* UART5 TX-->C.12  RX-->D.12 */
 70     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
 71     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 72     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 73     GPIO_Init(GPIOC, &GPIO_InitStructure);
 74     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
 75     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 76     GPIO_Init(GPIOD, &GPIO_InitStructure);
 77     /* UART6 TX-->C.0  RX-->C.1 */
 78     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
 79     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 80     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 81     GPIO_Init(GPIOC, &GPIO_InitStructure);
 82     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
 83     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 84     GPIO_Init(GPIOC, &GPIO_InitStructure);
 85     /* UART7 TX-->C.2  RX-->C.3 */
 86     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
 87     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 88     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 89     GPIO_Init(GPIOC, &GPIO_InitStructure);
 90     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
 91     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
 92     GPIO_Init(GPIOC, &GPIO_InitStructure);
 93 //    /* UART8 TX-->C.4  RX-->C.5 */
 94 //    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
 95 //    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 96 //    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
 97 //    GPIO_Init(GPIOC, &GPIO_InitStructure);
 98 //    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
 99 //    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
100 //    GPIO_Init(GPIOC, &GPIO_InitStructure);
101 
102     USART_InitStructure.USART_BaudRate = 115200;
103     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
104     USART_InitStructure.USART_StopBits = USART_StopBits_1;
105     USART_InitStructure.USART_Parity = USART_Parity_No;
106     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
107     USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
108 
109 //    USART_Init(USART1, &USART_InitStructure);
110 //    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
111     USART_Init(USART2, &USART_InitStructure);
112     USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);//初始化全部关闭
113     USART_Init(USART3, &USART_InitStructure);
114     USART_ITConfig(USART3, USART_IT_RXNE, DISABLE);
115     USART_Init(UART4, &USART_InitStructure);
116     USART_ITConfig(UART4, USART_IT_RXNE, DISABLE);
117     USART_Init(UART5, &USART_InitStructure);
118     USART_ITConfig(UART5, USART_IT_RXNE, DISABLE);
119     USART_Init(UART6, &USART_InitStructure);
120     USART_ITConfig(UART6, USART_IT_RXNE, DISABLE);
121     USART_Init(UART7, &USART_InitStructure);
122     USART_ITConfig(UART7, USART_IT_RXNE, DISABLE);
123 //    USART_Init(UART8, &USART_InitStructure);
124 //    USART_ITConfig(UART8, USART_IT_RXNE, DISABLE);
125 
126 //    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
127 //    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
128 //    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
129 //    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
130 //    NVIC_Init(&NVIC_InitStructure);
131     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
132     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
133     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
134     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
135     NVIC_Init(&NVIC_InitStructure);
136     NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
137     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
138     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
139     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
140     NVIC_Init(&NVIC_InitStructure);
141     NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
142     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
143     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
144     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
145     NVIC_Init(&NVIC_InitStructure);
146     NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
147     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
148     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
149     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
150     NVIC_Init(&NVIC_InitStructure);
151     NVIC_InitStructure.NVIC_IRQChannel = UART6_IRQn;
152     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
153     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
154     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
155     NVIC_Init(&NVIC_InitStructure);
156     NVIC_InitStructure.NVIC_IRQChannel = UART7_IRQn;
157     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
158     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
159     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
160     NVIC_Init(&NVIC_InitStructure);
161 //    NVIC_InitStructure.NVIC_IRQChannel = UART8_IRQn;
162 //    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
163 //    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
164 //    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
165 //    NVIC_Init(&NVIC_InitStructure);
166 
167 //    USART_Cmd(USART1, ENABLE);
168     USART_Cmd(USART2, ENABLE);
169     USART_Cmd(USART3, ENABLE);
170     USART_Cmd(UART4, ENABLE);
171     USART_Cmd(UART5, ENABLE);
172     USART_Cmd(UART6, ENABLE);
173     USART_Cmd(UART7, ENABLE);
174 //    USART_Cmd(UART8, ENABLE);
175 }
176 /*********************************************************************
177  * @fn      main
178  *
179  * @brief   Main program.
180  *
181  * @return  none
182  */
183 int main(void)
184 {
185     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
186     Delay_Init();
187     USART_Printf_Init(115200);
188     USARTx_CFG(); /* USART2 & USART3 INIT */
189 
190     printf("DATA RECEIVED START! \r\n");
191 
192     //USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
193     while(1)
194     {
195 
196         switch (Rxfinish1)
197         {
198 //        case 1:
199 //            printf("DATA RECEIVED FROM USART1 :%s\r\n",RxBuffer1);
200         //            Rxfinish1=0;
201 //            USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
202 
203 //            break;
204         case 2:
205             printf("DATA RECEIVED FROM SLAVE_2 :%p\r\n",RxBuffer1);//打印Slave发送来的数据
206             USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启下一个Slave中断，准备接受数据
207             USART_SendData(USART3, RequestData);//发送准备好接受命令请求，Slave收到校验后，就开启发送
208             while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
209             Delay_Ms(100);//给slave时间组织发送，时间太短会重新进入case 2.
210             break;
211         case 3:
212             printf("DATA RECEIVED FROM SLAVE_3 :%p\r\n",RxBuffer1);
213             USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
214             USART_SendData(UART4, RequestData);
215             while(USART_GetFlagStatus(UART4, USART_FLAG_TXE) == RESET);
216             Delay_Ms(100);
217             break;
218         case 4:
219             printf("DATA RECEIVED FROM SLAVE_4 :%p\r\n",RxBuffer1);
220             USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);
221             USART_SendData(UART5, RequestData);
222             while(USART_GetFlagStatus(UART5, USART_FLAG_TXE) == RESET);
223             Delay_Ms(100);
224             break;
225         case 5:
226             printf("DATA RECEIVED FROM SLAVE_5 :%p\r\n",RxBuffer1);
227             USART_ITConfig(UART6, USART_IT_RXNE, ENABLE);
228             USART_SendData(UART6, RequestData);
229             while(USART_GetFlagStatus(UART6, USART_FLAG_TXE) == RESET);
230             Delay_Ms(100);
231             break;
232         case 6:
233             printf("DATA RECEIVED FROM SLAVE_6 :%p\r\n",RxBuffer1);
234             USART_ITConfig(UART7, USART_IT_RXNE, ENABLE);
235             USART_SendData(UART7, RequestData);
236             while(USART_GetFlagStatus(UART7, USART_FLAG_TXE) == RESET);
237             Delay_Ms(100);
238             break;
239         case 7:
240             printf("DATA RECEIVED FROM SLAVE_7 :%p\r\n",RxBuffer1);
241             USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
242             USART_SendData(USART2, RequestData);
243             while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
244             Delay_Ms(100);
245             break;
246 //        case 8:
247 //            printf("DATA RECEIVED FROM UART8 :%p\r\n",RxBuffer1);
248 //            Rxfinish1=0;
249 //            Delay_Ms(500);
250 //            USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
251 //            USART_SendData(USART3, RequestData);
252 //            while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
253 //            break;
254         default:
255             printf("DATA RECEIVED error%p\r\n");
256             Delay_Ms(500);
257             USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
258             break;
259         }
260 
261     }
262 }
263 
264 /*********************************************************************
265  * @fn      USART3_IRQHandler
266  *
267  * @brief   This function handles USART3 global interrupt request.
268  *
269  * @return  none
270  */
271 //void USART1_IRQHandler(void)
272 //{
273 //    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
274  //   {
275  //       RxBuffer1 = USART_ReceiveData(USART1);
276   //      USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
277   //      Rxfinish1 = 1;
278  //   }
279 
280 //}
281 
282 void USART2_IRQHandler(void)
283 {
284     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
285     {
286         RxBuffer1 = USART_ReceiveData(USART2);
287         USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);//关闭此中断
288         Rxfinish1 = 2;
289     }
290 
291 }
292 
293 void USART3_IRQHandler(void)
294 {
295     if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
296     {
297         RxBuffer1 = USART_ReceiveData(USART3);
298         USART_ITConfig(USART3, USART_IT_RXNE, DISABLE);
299         Rxfinish1 = 3;
300     }
301 
302 }
303 
304 void UART4_IRQHandler(void)
305 {
306     if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)
307     {
308         RxBuffer1 = USART_ReceiveData(UART4);
309         USART_ITConfig(UART4, USART_IT_RXNE, DISABLE);
310         Rxfinish1 = 4;
311     }
312 
313 }
314 
315 void UART5_IRQHandler(void)
316 {
317     if(USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
318     {
319         RxBuffer1 = USART_ReceiveData(UART5);
320         USART_ITConfig(UART5, USART_IT_RXNE, DISABLE);
321         Rxfinish1 = 5;
322     }
323 
324 }
325 
326 void UART6_IRQHandler(void)
327 {
328     if(USART_GetITStatus(UART6, USART_IT_RXNE) != RESET)
329     {
330         RxBuffer1= USART_ReceiveData(UART6);
331         USART_ITConfig(UART6, USART_IT_RXNE, DISABLE);
332         Rxfinish1 = 6;
333     }
334 
335 }
336 
337 void UART7_IRQHandler(void)
338 {
339     if(USART_GetITStatus(UART7, USART_IT_RXNE) != RESET)
340     {
341         RxBuffer1 = USART_ReceiveData(UART7);
342         USART_ITConfig(UART7, USART_IT_RXNE, DISABLE);
343         Rxfinish1 = 7;
344     }
345 
346 }
347 
348 //void UART8_IRQHandler(void)
349 //{
350 //    if(USART_GetITStatus(UART8, USART_IT_RXNE) != RESET)
351 //    {
352 //        RxBuffer1 = USART_ReceiveData(UART8);
353 //        USART_ITConfig(UART8, USART_IT_RXNE, DISABLE);
354 //        Rxfinish1 = 8;
355 //    }
356 //
357 //}

6. Slave程序

 1 //双机通讯，使用USART
 2 
 3 #include "debug.h"
 4 /* Global Variable */
 5 u8 TxBuffer2 = 6;//这是发送的数据，可以分别配置Slave为不同的值
 6 u8 RequestData=0;//检测请求命令是否正确
 7 u8 RxBuffer2=0;
 8 u8 Rxfinish2;
 9 void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
10 /*********************************************************************
11  * @fn      USARTx_CFG
12  *
13  * @brief   Initializes the USART2 & USART3 peripheral.
14  *
15  * @return  none
16  */
17 void USARTx_CFG(void)
18 {
19     GPIO_InitTypeDef  GPIO_InitStructure = {0};
20     USART_InitTypeDef USART_InitStructure = {0};
21     NVIC_InitTypeDef  NVIC_InitStructure = {0};
22 
23     RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE);
24     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE);
25 
26     /* USART2 TX-->A.2  RX-->A.3 */
27     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
28     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
29     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
30     GPIO_Init(GPIOA, &GPIO_InitStructure);
31     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
32     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
33     GPIO_Init(GPIOA, &GPIO_InitStructure);
34 
35     USART_InitStructure.USART_BaudRate = 115200;
36     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
37     USART_InitStructure.USART_StopBits = USART_StopBits_1;
38     USART_InitStructure.USART_Parity = USART_Parity_No;
39     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
40     USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
41 
42     USART_Init(USART2, &USART_InitStructure);
43     USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
44 
45     NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
46     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
47     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
48     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
49     NVIC_Init(&NVIC_InitStructure);
50     USART_Cmd(USART2, ENABLE);
51 }
52 
53 /*********************************************************************
54  * @fn      main
55  *
56  * @brief   Main program.
57  *
58  * @return  none
59  */
60 int main(void)
61 {
62     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
63     Delay_Init();
64     USART_Printf_Init(115200);
65     USARTx_CFG(); /* USART2 & USART3 INIT */
66 
67 
68     while(1)
69     {
70         if(RxBuffer2==RequestData)//校验数据请求命令
71         {
72             USART_SendData(USART2, TxBuffer2);//向Master发送数据
73             while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
74         }
75 
76     }
77 }
78 
79 void USART2_IRQHandler(void)
80 {
81     if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)//等待接受Master数据请求命令
82     {
83         RxBuffer2 = USART_ReceiveData(USART2);
84 
85     }
86 }

 注：主机先上电，从机再上电，否则数据接收混乱，正在处理这个问题。

Zhu_zzzzzz
关注
专栏目录
RISC-V MCU 赤菟V307使用蓝牙进行通信
weixin_56772859的博客
07-01 927
本篇博客是关于赤菟V307芯片使用外设蓝牙操作的简单代码模板，包含端口复用以及接收数值后返回的功能。主要目的在为不熟悉操作的新手提供方法以及思路
RISC-V MCU应用之单片赤菟V307实现八串口服务器
RISCVnet的博客
03-09 3629
简介 串口服务器，提供串口转网络的功能，将串口转换成TCP/IP协议网络接口，实现串口和网络接口的数据双向透明传输，扩展串口设备的通讯距离。 赤菟V307是搭载沁恒自研RISC-V内核青稞V4F的高性能互联型MCU，主频支持144MHz，支持硬件浮点运算（FPU），提供八个UART接口、USB2.0高速接口（480Mbps）并内置了PHY收发器、千兆以太网MAC并集成10MPHY、2个CAN接口等丰富的外设资源。 基于八个UART接口、10M以太网的强大外设，通过单片赤菟V307即可实现八串口服务器.
基于riscv指令设计一个简易SOC——uart
ZY_HAHAHA的博客
06-13 570
SOC uart部分
国产单片机(沁恒微WCH)CH32V307评估板串口使用
初出茅庐的小李
07-26 3663
CH32V307系列是基于32位RISC-V设计的互联型微控制器，配备了硬件堆栈区、快速中断入口，在标准RISC-V基础上大大提高了中断响应速度。加入单精度浮点指令集，扩充堆栈区，具有更高的运算性能。扩展串口UART数量到8组，电机定时器到4组。提供USB2.0高速接口（480Mbps）并内置了PHY收发器，以太网MAC升级到千兆并集成了10M-PHY模块。
基于CH32V307单片机的USART主机与U(S)ART多从机通讯
weixin_44845994的博客
03-17 3011
本文章介绍使用CH32V307单片机实现主机轮回接收从机传输的数据，并在串口软件显示。 您需要的资料：CH32V307单片机数据手册及例程 一、单片机串口部分简介 由上图可知，CH32V307有8个串口（USART+UART）。 由数据手册可知，USART有3个，USART1挂接在APB2总线上，USART2和USART2以及7个UART挂接在APB1总线上。 为了方便插拔引脚转接线，将数据手册中有关串口引脚陈列如下表格中。 串口引脚号 串口名称 PA8 USART1_CK PA9
RISC-V MCU 开发教程之CH32V307配置Flash和RAM
Zhu_zzzzzz的博客
02-24 826
赤菟V307（CH32V307）是一款RISC-V内核的MCU，搭载的是沁恒自研RISC-V内核青稞V4F，最高主频144MHz，支持单精度浮点运算（FPU）。通常官网介绍Flash大小为256 KB，SRAM大小为64 KB。 仔细阅读应用手册发现，其Flash和SRAM的大小支持配置，具体配置项如下： 192 KB Flash + 128 KB SRAM 224 KB Flash + 96 KB SRAM 256 KB Flash + 54 KB SRAM 288 KB Flash + 3
基于CH32V307单片机的USART+Flash双机通讯
weixin_44845994的博客
03-14 2804
USART通讯是典型的串口通讯，有别于并口通讯的多路线缆同时传输，串口使用较少的线缆，排队分时传输的方式实现数据传输。 CH32V307单片机是南京的一家MCU厂商，芯片资料可至官网下载，链接为：沁恒CH32V307芯片资料 开发环境使用的是MounRiver Studio 阅读下列内容，您需要掌握USART通讯机制及API函数（借助开发板视频，其它书籍资料学习）。 新建一个CH32V307单片机工程，复制下列代码替换main函数中内容。 程序实现的功能及使用： 两块CH32V307开发板之间使用USAR
RISC-V MCU 应用教程之低功耗之睡眠模式
Zhu_zzzzzz的博客
06-29 699
以RISC-V MCU CH32V307为例睡眠模式下，所有的IO引脚都保持它们在运行模式时的状态。所有的外设时钟都正常工作。进入睡眠前，尽量关闭无用的外设时钟，以降低功耗。该模式唤醒所需的时间最短，几乎不耗时间，约 2~3 us。此模式下，以144MHz运行时，使能所有外设时的睡眠电流约15.1mA，关闭所有外设的睡眠电流约4.1mA（除了唤醒中断引脚时钟和电源模块时钟）。配置内核寄存器 控制位 执行或指令配置内核寄存器 控制位 执行睡眠指令时，配置 控制位 ，系统唤醒后控制器离开中断服务函数时，继续
RISC-V-Reader-Chinese-v2p1_risc-v_RISC-V开源MCU指令集手册
09-11
这是开源MCU设计指令集与涉及说明中文版。...RISC-V指令集是国内开发自有MCU的主流方案，具有完整的工具链和软件开发平台。阿里、平头哥、华大和GD都有相关的MCU产品。部分MCU产品支持AMD开发工具。
【沁恒WCH CH32V307V-R1的单线半双工模式串口通讯】
vor234的博客
02-13 1493
该模块包含 3 个通用同步异步收发器（USART1/2/3）和 5 个通用异步收发器（UART4/5/6/7/8）。注：对于 CH32V20x_D6、CH32F20x_D6，串口 4 为同步异步收发器（USART4）。本例演示了UART2和USAT3单线半双工模式数据传输和接收，熟悉STM32开发用易上手配置。✨✨✨这是使用MounRiver Studio开发的项目，支持在RISC-V核心基础硬件CH32V307评估板上使用带有msh Shell的RTOS快速原型。
赤菟开发板CH32V307VCT6学习1-开发环境搭建
qq_53534483的博客
06-23 2357
赤菟开发板CH32V307VCT6学习1-开发环境搭建
[RISC-V MCU 应用开发]RISC-V MCU-遥控智能小车
ic2121的博客
02-08 472
先介绍一下CH32V307吧，赤菟V307是搭载沁恒自研RISC-V内核青稞V4F的高性能互联型MCU，主频支持144MHz，支持硬件浮点运算（FPU），提供八个UART接口、USB2.0高速接口（480Mbps）并内置了PHY收发器、千兆以太网MAC并集成10M PHY、2个CAN接口等丰富的外设资源。下位机采用的是CH32V307作为主控制器，通过PWM控制小车，并通过AHT10读取环境温湿度，并将参数显示在LCD上，通过MOS模块驱动加湿器模块。然后通过时间差实现1s采集和更新一次数据的功能。
沁恒MCU串口使用指南
havc_W的博客
01-10 3569
沁恒MCU串口使用指南（类16C550串口）
沁恒CH32V307单片机入门（01）：基础说明与流程体验
热门推荐
Naisu的各种笔记
01-29 1万+
工作这几年单片机主要就接触过 Atmel、Renesas、Microchip、ST 这些厂家的，最近几年因为内部外部的各种因素单片机的价格和供应都挺不稳定的，将来会发生什么也不好说。另外这些年国内的单片机发展也挺快的。所以准备试试国产的单片机。
CH32Vx 之GPIO实验
lanwailan的博客
08-16 550
配合中断以及开发板的按钮实现LED的开灭，涉及知识点中断以及GPIO控制。. 我的开发板控制LED的GPIO口对应PA15。PB3 对应 EXIT3。
沁恒ch32v307vct6，开启中断后执行一次后就不再进入中断
最新发布
m0_68416755的博客
03-27 532
沁恒
单片机非阻塞串口中断收发数据
曹晓林的博客
06-21 942
串口非阻塞式操作，单片机使用中断方式进行串口的收发操作
沁恒 CH32V208(五): CH32V208 运行FreeRTOS示例的说明
IOsetting的专栏
05-16 994
以沁恒的FreeRTOS示例项目为例, 说明如何在 CH32V208 评估上运行 FreeRTOS, 以及运行 FreeRTOS 涉及的库文件改动
一种检测有无佩戴安全帽的装置
weixin_61154553的博客
12-26 1048
目录一、预想功能二、系统框架三、硬件介绍四、软件介绍1、K210程序2、CH32V307程序串口接收配置中断配置语音模块函数PWM初始化配置接收数据进行播报五、实际效果识别时MaixBit开发板外接2.4寸显示屏观察识别结果完整视频演示基于RISC-V MCU CH32V307开发板和以K210作为核心单元的MaixBit开发板所开发的装置，该装置运行时旋转，他可以通过判断是否检测到人脸，如若检测到人脸便判断是否佩戴了安全帽，通过串口发送数据到CH32V307，CH32V307通过PWM输出驱动电机停止旋转
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值