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

已于 2022-03-21 14:16:49 修改
阅读量827 收藏 5
点赞数 1
文章标签： risc-v mcu 单片机
于 2022-03-21 14:13:07 首次发布
原文链接：https://blog.csdn.net/weixin_44845994/article/details/123548420
版权

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

本文章介绍使用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. 程序如下

//双机通讯，使用USART



#include "debug.h"



/* Global define */

#define TxSize1    (size(TxBuffer1))

/* Global Variable */

u8 RxBuffer1 = 0; /* Send by UART2 */

u8 RequestData=0;//请求发送数据

u8 Rxfinish1 = 2;//先给个初始值，进入case 2，启动接收

//void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void UART4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void UART5_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void UART6_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void UART7_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

//void UART8_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));



/*********************************************************************

 * @fn      USARTx_CFG

 *

 * @brief   Initializes the USART2 & USART3 peripheral.

 *

 * @return  none

 */

void USARTx_CFG(void)

{

    GPIO_InitTypeDef  GPIO_InitStructure = {0};

    USART_InitTypeDef USART_InitStructure = {0};

    NVIC_InitTypeDef  NVIC_InitStructure = {0};



    RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2|RCC_APB1Periph_USART3|RCC_APB1Periph_UART4|RCC_APB1Periph_UART5|RCC_APB1Periph_UART6|RCC_APB1Periph_UART7|RCC_APB1Periph_UART8, ENABLE);

//    RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1, ENABLE);

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD, ENABLE);



//    /* USART1 TX-->A.9  RX-->A.10 */

//    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

//    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

//    GPIO_Init(GPIOA, &GPIO_InitStructure);

//    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

//    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* USART2 TX-->A.2  RX-->A.3 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    /* USART3 TX-->B.10  RX-->B.11 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOB, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOB, &GPIO_InitStructure);

    /* UART4 TX-->C.10  RX-->C.11 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    /* UART5 TX-->C.12  RX-->D.12 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOD, &GPIO_InitStructure);

    /* UART6 TX-->C.0  RX-->C.1 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    /* UART7 TX-->C.2  RX-->C.3 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOC, &GPIO_InitStructure);

//    /* UART8 TX-->C.4  RX-->C.5 */

//    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;

//    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

//    GPIO_Init(GPIOC, &GPIO_InitStructure);

//    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;

//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

//    GPIO_Init(GPIOC, &GPIO_InitStructure);



    USART_InitStructure.USART_BaudRate = 115200;

    USART_InitStructure.USART_WordLength = USART_WordLength_8b;

    USART_InitStructure.USART_StopBits = USART_StopBits_1;

    USART_InitStructure.USART_Parity = USART_Parity_No;

    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;



//    USART_Init(USART1, &USART_InitStructure);

//    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

    USART_Init(USART2, &USART_InitStructure);

    USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);//初始化全部关闭

    USART_Init(USART3, &USART_InitStructure);

    USART_ITConfig(USART3, USART_IT_RXNE, DISABLE);

    USART_Init(UART4, &USART_InitStructure);

    USART_ITConfig(UART4, USART_IT_RXNE, DISABLE);

    USART_Init(UART5, &USART_InitStructure);

    USART_ITConfig(UART5, USART_IT_RXNE, DISABLE);

    USART_Init(UART6, &USART_InitStructure);

    USART_ITConfig(UART6, USART_IT_RXNE, DISABLE);

    USART_Init(UART7, &USART_InitStructure);

    USART_ITConfig(UART7, USART_IT_RXNE, DISABLE);

//    USART_Init(UART8, &USART_InitStructure);

//    USART_ITConfig(UART8, USART_IT_RXNE, DISABLE);



//    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;

//    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

//    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

//    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

//    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = UART6_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = UART7_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

//    NVIC_InitStructure.NVIC_IRQChannel = UART8_IRQn;

//    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

//    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

//    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

//    NVIC_Init(&NVIC_InitStructure);



//    USART_Cmd(USART1, ENABLE);

    USART_Cmd(USART2, ENABLE);

    USART_Cmd(USART3, ENABLE);

    USART_Cmd(UART4, ENABLE);

    USART_Cmd(UART5, ENABLE);

    USART_Cmd(UART6, ENABLE);

    USART_Cmd(UART7, ENABLE);

//    USART_Cmd(UART8, ENABLE);

}

/*********************************************************************

 * @fn      main

 *

 * @brief   Main program.

 *

 * @return  none

 */

int main(void)

{

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

    Delay_Init();

    USART_Printf_Init(115200);

    USARTx_CFG(); /* USART2 & USART3 INIT */



    printf("DATA RECEIVED START! \r\n");



    //USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

    while(1)

    {



        switch (Rxfinish1)

        {

//        case 1:

//            printf("DATA RECEIVED FROM USART1 :%s\r\n",RxBuffer1);

        //            Rxfinish1=0;

//            USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);



//            break;

        case 2:

            printf("DATA RECEIVED FROM SLAVE_2 :%p\r\n",RxBuffer1);//打印Slave发送来的数据

            USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启下一个Slave中断，准备接受数据

            USART_SendData(USART3, RequestData);//发送准备好接受命令请求，Slave收到校验后，就开启发送

            while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);

            Delay_Ms(100);//给slave时间组织发送，时间太短会重新进入case 2.

            break;

        case 3:

            printf("DATA RECEIVED FROM SLAVE_3 :%p\r\n",RxBuffer1);

            USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);

            USART_SendData(UART4, RequestData);

            while(USART_GetFlagStatus(UART4, USART_FLAG_TXE) == RESET);

            Delay_Ms(100);

            break;

        case 4:

            printf("DATA RECEIVED FROM SLAVE_4 :%p\r\n",RxBuffer1);

            USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);

            USART_SendData(UART5, RequestData);

            while(USART_GetFlagStatus(UART5, USART_FLAG_TXE) == RESET);

            Delay_Ms(100);

            break;

        case 5:

            printf("DATA RECEIVED FROM SLAVE_5 :%p\r\n",RxBuffer1);

            USART_ITConfig(UART6, USART_IT_RXNE, ENABLE);

            USART_SendData(UART6, RequestData);

            while(USART_GetFlagStatus(UART6, USART_FLAG_TXE) == RESET);

            Delay_Ms(100);

            break;

        case 6:

            printf("DATA RECEIVED FROM SLAVE_6 :%p\r\n",RxBuffer1);

            USART_ITConfig(UART7, USART_IT_RXNE, ENABLE);

            USART_SendData(UART7, RequestData);

            while(USART_GetFlagStatus(UART7, USART_FLAG_TXE) == RESET);

            Delay_Ms(100);

            break;

        case 7:

            printf("DATA RECEIVED FROM SLAVE_7 :%p\r\n",RxBuffer1);

            USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

            USART_SendData(USART2, RequestData);

            while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);

            Delay_Ms(100);

            break;

//        case 8:

//            printf("DATA RECEIVED FROM UART8 :%p\r\n",RxBuffer1);

//            Rxfinish1=0;

//            Delay_Ms(500);

//            USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

//            USART_SendData(USART3, RequestData);

//            while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);

//            break;

        default:

            printf("DATA RECEIVED error%p\r\n");

            Delay_Ms(500);

            USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

            break;

        }



    }

}



/*********************************************************************

 * @fn      USART3_IRQHandler

 *

 * @brief   This function handles USART3 global interrupt request.

 *

 * @return  none

 */

//void USART1_IRQHandler(void)

//{

//    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)

 //   {

 //       RxBuffer1 = USART_ReceiveData(USART1);

  //      USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);

  //      Rxfinish1 = 1;

 //   }



//}



void USART2_IRQHandler(void)

{

    if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)

    {

        RxBuffer1 = USART_ReceiveData(USART2);

        USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);//关闭此中断

        Rxfinish1 = 2;

    }



}



void USART3_IRQHandler(void)

{

    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)

    {

        RxBuffer1 = USART_ReceiveData(USART3);

        USART_ITConfig(USART3, USART_IT_RXNE, DISABLE);

        Rxfinish1 = 3;

    }



}



void UART4_IRQHandler(void)

{

    if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)

    {

        RxBuffer1 = USART_ReceiveData(UART4);

        USART_ITConfig(UART4, USART_IT_RXNE, DISABLE);

        Rxfinish1 = 4;

    }



}



void UART5_IRQHandler(void)

{

    if(USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)

    {

        RxBuffer1 = USART_ReceiveData(UART5);

        USART_ITConfig(UART5, USART_IT_RXNE, DISABLE);

        Rxfinish1 = 5;

    }



}



void UART6_IRQHandler(void)

{

    if(USART_GetITStatus(UART6, USART_IT_RXNE) != RESET)

    {

        RxBuffer1= USART_ReceiveData(UART6);

        USART_ITConfig(UART6, USART_IT_RXNE, DISABLE);

        Rxfinish1 = 6;

    }



}



void UART7_IRQHandler(void)

{

    if(USART_GetITStatus(UART7, USART_IT_RXNE) != RESET)

    {

        RxBuffer1 = USART_ReceiveData(UART7);

        USART_ITConfig(UART7, USART_IT_RXNE, DISABLE);

        Rxfinish1 = 7;

    }



}



//void UART8_IRQHandler(void)

//{

//    if(USART_GetITStatus(UART8, USART_IT_RXNE) != RESET)

//    {

//        RxBuffer1 = USART_ReceiveData(UART8);

//        USART_ITConfig(UART8, USART_IT_RXNE, DISABLE);

//        Rxfinish1 = 8;

//    }

//

//}

6.Slave程序

//双机通讯，使用USART



#include "debug.h"

/* Global Variable */

u8 TxBuffer2 = 6;//这是发送的数据，可以分别配置Slave为不同的值

u8 RequestData=0;//检测请求命令是否正确

u8 RxBuffer2=0;

u8 Rxfinish2;

void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

/*********************************************************************

 * @fn      USARTx_CFG

 *

 * @brief   Initializes the USART2 & USART3 peripheral.

 *

 * @return  none

 */

void USARTx_CFG(void)

{

    GPIO_InitTypeDef  GPIO_InitStructure = {0};

    USART_InitTypeDef USART_InitStructure = {0};

    NVIC_InitTypeDef  NVIC_InitStructure = {0};



    RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2, ENABLE);

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE);



    /* USART2 TX-->A.2  RX-->A.3 */

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

    GPIO_Init(GPIOA, &GPIO_InitStructure);



    USART_InitStructure.USART_BaudRate = 115200;

    USART_InitStructure.USART_WordLength = USART_WordLength_8b;

    USART_InitStructure.USART_StopBits = USART_StopBits_1;

    USART_InitStructure.USART_Parity = USART_Parity_No;

    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;



    USART_Init(USART2, &USART_InitStructure);

    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);



    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);

    USART_Cmd(USART2, ENABLE);

}



/*********************************************************************

 * @fn      main

 *

 * @brief   Main program.

 *

 * @return  none

 */

int main(void)

{

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

    Delay_Init();

    USART_Printf_Init(115200);

    USARTx_CFG(); /* USART2 & USART3 INIT */





    while(1)

    {

        if(RxBuffer2==RequestData)//校验数据请求命令

        {

            USART_SendData(USART2, TxBuffer2);//向Master发送数据

            while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);

        }



    }

}



void USART2_IRQHandler(void)

{

    if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)//等待接受Master数据请求命令

    {

        RxBuffer2 = USART_ReceiveData(USART2);



    }

}

————————————————

版权声明：本文为CSDN博主「付小熊」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/weixin_44845994/article/details/123548420

借过风景
关注
RISC-V MCU 赤菟V307使用蓝牙进行通信
weixin_56772859的博客
07-01 958
本篇博客是关于赤菟V307芯片使用外设蓝牙操作的简单代码模板，包含端口复用以及接收数值后返回的功能。主要目的在为不熟悉操作的新手提供方法以及思路
RISC-V CH32V203 单片机定时器中断实验
飞多学堂的博客
04-20 1528
沁恒 RISC-V 32 位单片机定时器中断实验
赤菟开发板CH32V307VCT6学习2-GPIO
qq_53534483的博客
06-24 1645
我们观察官方的例程，可以很明显看出，其与STM32是很类似的，学习过STM32的可以很容易上手，该工程中我们也可以看到启动文件和相关库函数，说明我们可以很容易编写相关程序。（3）我们点击旁边的项目资源管理器，展开项目树，点开USER文件夹，点击main.c,我们可以很惊喜的发现，你仅仅创建了一个工程，这个软件就帮你添加了启动文件、库函数、时钟配置等等，实在太贴心了。观察官方例程后，发现其对于GPIO口的操作是很类似的，初始化结构体，调用相关库函数，使得GPIO口电平变化。（3）点击解除代码保护，点击下载。
分享国产RISC-V单片机通用
最新发布
EVERSPIN的博客
09-29 662
RAMSUN提供的RISC-V单片机，开源指令集架构，针对低功耗和高速响应等应用优化扩展，免费配套IDE等开发工具软件，免除第三方内核技术的授权费和提成费，通过内置和组合USB、PD、低功耗蓝牙、以太网等专业接口外设，构建了既有全球未来生态又能自主可控、且极具长期竞争力的MCU产品线。RISC-V 赋予技术创新，开放的指令集、开源的设计实现、开源的工具和开放的流程等正在改变着芯片设计的方法，未来芯片中包含开源 IP 的比例将会不断提高，芯片设计方法的变革将会引领新一轮商业模式的创新。
基于RISC-V MCU CH32V307单片机的触摸与显示方案
RISCVnet的博客
04-22 1901
CH32V307系列MCU内置全速USB、Ethernet和多达8个UART/USART串口等外设模块，在工业控制及民用消费领域有非常大的应用前景。CH32V307内置FSMC功能，使用FSMC可快速操作基于8080协议端口的TFT-LCD显示屏。基于显示屏的可视化产品丰富了人机交互的方式，可以方便地了解设备的运行状况、舒适安全地操纵设备。 LVGL图形库是一种显示库，其官网提供了详细的介绍以及丰富的移植例程。在网络上有许多基于ARM内核单片机产品的LVGL移植教程，读者可参照相关教程深入学习。CH3
RISC-V MCU应用之单片赤菟V307实现八串口服务器
RISCVnet的博客
03-09 3641
简介 串口服务器，提供串口转网络的功能，将串口转换成TCP/IP协议网络接口，实现串口和网络接口的数据双向透明传输，扩展串口设备的通讯距离。 赤菟V307是搭载沁恒自研RISC-V内核青稞V4F的高性能互联型MCU，主频支持144MHz，支持硬件浮点运算（FPU），提供八个UART接口、USB2.0高速接口（480Mbps）并内置了PHY收发器、千兆以太网MAC并集成10MPHY、2个CAN接口等丰富的外设资源。 基于八个UART接口、10M以太网的强大外设，通过单片赤菟V307即可实现八串口服务器.
RISC-V-Reader-Chinese-v2p1_risc-v_RISC-V开源MCU指令集手册
09-11
这是开源MCU设计指令集与涉及说明中文版。...RISC-V指令集是国内开发自有MCU的主流方案，具有完整的工具链和软件开发平台。阿里、平头哥、华大和GD都有相关的MCU产品。部分MCU产品支持AMD开发工具。
RISC-V MCU 应用教程之低功耗之睡眠模式
Zhu_zzzzzz的博客
06-29 727
以RISC-V MCU CH32V307为例睡眠模式下，所有的IO引脚都保持它们在运行模式时的状态。所有的外设时钟都正常工作。进入睡眠前，尽量关闭无用的外设时钟，以降低功耗。该模式唤醒所需的时间最短，几乎不耗时间，约 2~3 us。此模式下，以144MHz运行时，使能所有外设时的睡眠电流约15.1mA，关闭所有外设的睡眠电流约4.1mA（除了唤醒中断引脚时钟和电源模块时钟）。配置内核寄存器 控制位 执行或指令配置内核寄存器 控制位 执行睡眠指令时，配置 控制位 ，系统唤醒后控制器离开中断服务函数时，继续
RISC-V单片机快速入门07-板载LCD显示ESP8266数据
weixin_45006076的博客
08-11 899
前言： 本节，我们使用GD32VF103控制ESP-01S启动TCP Server，然后让多个网络调试助手连接ESP-01S并与之通信，并通过LCD显示TCP网络助手发来的数据。 一、基础知识 1.LCD简介 本实验使用的LCD为龙眼开发板板载LCD，是一个0.96英寸的屏，使用ST7735S驱动驱动，硬件引脚说明如下 本实验最终实现效果如下图： 图中设置中文显示需要使用字库软件设置，本实验采用字模Ⅲ这款字库软件，已经连同代码推送到云端，可以下载后使用。 2.字库软件安装 字模Ⅲ安装也比较简单，点击Zi
stm32f407中断死循环
qq_35216918的博客
09-03 1821
STM32f407的USART3中断死循环，形成死机。 我用的是 STM32F407芯片 USART3_IRQHandler 总是中断，程序死循环。 1、出现问题： 原程序的中断处理程序是： void USART2_IRQHandler(void) { u8 key = 0; USART_ClearFlag(USART2,USART_FLAG_TC ); //清除中断标志 if(USART_GetITStatus(USART2,USART_IT_RXNE)!=Bit_RESET)//检查指定的usart是否
国产单片机(沁恒微WCH)CH32V307评估板串口使用
初出茅庐的小李
07-26 4147
CH32V307系列是基于32位RISC-V设计的互联型微控制器，配备了硬件堆栈区、快速中断入口，在标准RISC-V基础上大大提高了中断响应速度。加入单精度浮点指令集，扩充堆栈区，具有更高的运算性能。扩展串口UART数量到8组，电机定时器到4组。提供USB2.0高速接口（480Mbps）并内置了PHY收发器，以太网MAC升级到千兆并集成了10M-PHY模块。
20220407-CH32V307以太网部分学习心得
weixin_48156955的博客
04-07 3801
CH32V307以太网部分学习心得
STM32F407 串口编程USART1，USART2，USART3，UART4
热门推荐
yunxianpiaoyu的专栏
03-22 3万+
串口设置的一般步骤可以总结为如下几个步骤：  1)  串口时钟使能，GPIO时钟使能。  2)  设置引脚复用器映射：调用GPIO_PinAFConfig函数。  3)  GPIO初始化设置：要设置模式为复用功能。  4)  串口参数初始化：设置波特率，字长，奇偶校验等参数。  5)  开启中断并且初始化NVIC，使能中断（如果需要开启中断才需要这个步骤）。  6)  使能串口。 
STM32 HAL库串口接收
weixin_44315150的博客
01-10 3991
在主函数中，完成初始化后 ，使用HAL_UART_Receive_IT打开中断并准备接收数据。 HAL_UART_Receive_IT(&huart3, BUFFER,1);表示USART3接受数据后放入BUFFER并进入中断，1代表每接收1位数据就进入中断一次。 void USART3_IRQHandler(void)//中断处理函数 { HAL_UART_IRQHandler(&huart3);//该函数会清空中断标志，取消中断使能，并间接调用回调函数 ...
【STM32基础】第二篇、STM32串口的使用
大屁桃的博客
01-28 9417
目录 第一部分、如何取出串口接收到的数据？ 第二部分、如何将串口接收的数据与目标数据进行匹配？ 第三部分、串口常用的发送数据的函数 1、发送一个字符 （8位） 2、发送一个16位数据（16位） 3、发送字符串 4、串口格式化打印函数 5、串口中断服务函数的模板 第四部分、STM32F1串口1到串口4的配置函数 1、串口1的配置函数 2、串口2的配置函数 3、串口3的配置函数 4、串口4的配置函数 第五部分、总结 第一部分、如何取出串口接收到的数据？ 这个功能是...
STM32L051低功耗STOP模式串口中断唤醒
Tonyの博客
08-15 5710
本文总结下STM32L051的STOP模式，通过外部中断「按键、串口」进行唤醒。
STM32F103C8T6进入STOP(停止)模式前降低功耗的操作,检测有效
qq_35142153的博客
02-18 3317
STM32的停止(STOP)模式进入前将功耗降低的操作
STM32 低功耗STOP模式，RTC唤醒
安柘千赫的博客
03-03 6975
芯片：STM32L071CB 开发环境：STM32CubeMX + keil5.33 使用实时时钟RTC的 WakeUpTimer定时器产生的中断将STM32从STOP低功耗模式下唤醒。 STOP模式： STM32低功耗运行模式之一，该模式下CPU会停止工作，但RAM中的数据仍然保留。待中断或事件触发后程序可以继续运行。 note：1、STOP模式退出后，系统时钟会自动配置为MSI或HSI，需要手动重新配置时钟，以及使用时钟的外设。 2、为了进一步降低STOP模式下的功耗，可...
GD32VF103 RISC-V MCU用户手册：闪存控制器详解
- **RISC-V处理器**: GD32VF103采用RISC-V架构，这是一种开放源代码的指令集架构，以其高效、低功耗和模块化设计而闻名。 - **系统架构**: 设计包括了处理核心、系统控制器、存储器接口等关键组件，支持高效的系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值