CH32V30x 学习指南

从8051到RISC-V的平滑过渡 · 基于你的工程包定制

第一章 概述与思维转变

核心思维转变

// 点亮LED，一行搞定
P1 = 0xFE;

// 点亮LED，四步流程
1. 开时钟 (RCC)
2. 配置结构体
3. 调用Init函数
4. 操作GPIO

概念映射表

架构对比

第二章 时钟系统 (RCC)

RCC 基础概念

RCC (Reset and Clock Control) 是时钟控制器，负责：

• 系统时钟配置（HSI/HSE/PLL）
• 总线时钟分频（AHB/APB1/APB2）
• 外设时钟门控（开启/关闭各外设时钟）

时钟树详解

RCC 常用API

常用外设时钟宏

第三章 GPIO 详解

GPIO 模式详解

GPIO 初始化流程

// GPIO初始化完整模板
void LED_Init(void)
{
    // 第1步：开启GPIOC时钟 【必须！8051无此步骤】
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

    // 第2步：定义GPIO初始化结构体
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    // 第3步：填充结构体成员
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_2;          // PC2引脚
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;    // 推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    // 翻转速度

    // 第4步：调用初始化函数
    GPIO_Init(GPIOC, &GPIO_InitStructure);
}

GPIO 常用API

// 等价于 8051 的 P1_0 = 1;
GPIO_SetBits(GPIOC, GPIO_Pin_2);

// 等价于 8051 的 P1_0 = 0;
GPIO_ResetBits(GPIOC, GPIO_Pin_2);

// 等价于 8051 的 if(P1_0 == 0)
if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == Bit_RESET) {
    // 按键按下
}

实战练习：LED闪烁

#include <STC15F2K60S2.H>

sbit LED = P2^0;

void main() {
    while(1) {
        LED = 0;
        Delay_ms(500);
        LED = 1;
        Delay_ms(500);
    }
}

#include "debug.h"

void main(void) {
    // 系统初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();

    // GPIO初始化
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure = {0};
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    while(1) {
        GPIO_SetBits(GPIOC, GPIO_Pin_2);
        Delay_Ms(500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_2);
        Delay_Ms(500);
    }
}

第四章 定时器与中断

CH32V30x 定时器分类

基本定时中断配置

void Timer0_Init(void) {
    TMOD &= 0xF0;
    TMOD |= 0x01;  // 模式1
    TL0 = 0x18;
    TH0 = 0xFC;    // 1ms @12MHz
    TF0 = 0;
    TR0 = 1;       // 启动
    ET0 = 1;       // 中断使能
    EA = 1;        // 总中断
}

void T0_ISR() interrupt 1 {
    TH0 = 0xFC;
    TL0 = 0x18;
    // 处理代码
}

void TIM3_Init(void) {
    // 1. 开时钟
    RCC_APB1PeriphClockCmd(
        RCC_APB1Periph_TIM3, ENABLE);

    // 2. 配置定时器
    TIM_TimeBaseInitTypeDef TIM_InitStruct;
    TIM_InitStruct.TIM_Period = 1000-1;    // ARR
    TIM_InitStruct.TIM_Prescaler = 96-1;   // PSC
    TIM_InitStruct.TIM_ClockDivision = 0;
    TIM_InitStruct.TIM_CounterMode =
        TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM3, &TIM_InitStruct);

    // 3. 配置中断
    TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);

    // 4. 配置NVIC
    NVIC_InitTypeDef NVIC_InitStruct;
    NVIC_InitStruct.NVIC_IRQChannel = TIM3_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 3;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);

    // 5. 启动定时器
    TIM_Cmd(TIM3, ENABLE);
}

void TIM3_IRQHandler(void) {
    if(TIM_GetITStatus(TIM3, TIM_IT_Update)) {
        // 处理代码
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
    }
}

NVIC 中断控制器

NVIC 优先级分组

实战练习：定时器LED

#include "debug.h"

// 中断函数声明（WCH特有属性）
void TIM3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

// 全局变量
volatile uint32_t uwTick = 0;
volatile uint8_t Led_Flag = 0;

// TIM3初始化：1ms中断
void TIM3_Init(void)
{
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct = {0};
    TIM_TimeBaseInitStruct.TIM_Period = 1000 - 1;
    TIM_TimeBaseInitStruct.TIM_Prescaler = 96 - 1;
    TIM_TimeBaseInitStruct.TIM_ClockDivision = 0;
    TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);

    TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);

    NVIC_InitTypeDef NVIC_InitStruct = {0};
    NVIC_InitStruct.NVIC_IRQChannel = TIM3_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 3;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);

    TIM_Cmd(TIM3, ENABLE);
}

// TIM3中断服务函数
void TIM3_IRQHandler(void)
{
    if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
    {
        uwTick++;
        if(uwTick >= 1000) {
            uwTick = 0;
            Led_Flag ^= 1;
            if(Led_Flag) GPIO_SetBits(GPIOC, GPIO_Pin_2);
            else GPIO_ResetBits(GPIOC, GPIO_Pin_2);
        }
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
    }
}

int main(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();
    USART_Printf_Init(115200);

    // LED初始化
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStruct);

    TIM3_Init();

    while(1) { }
}

第五章 串口通信

USART 初始化配置

串口初始化需要配置三大块：GPIO（引脚复用）、USART（通信参数）、NVIC（中断优先级）。

下面以 USART3（PB10/PB11）为例，演示完整的串口初始化，包含接收中断：

#include "debug.h"

// 声明中断处理函数（WCH专用快速中断属性）
void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void Usart3_Init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    /*---------- 第1步：开时钟 ----------*/
    // USART3 在 APB1 上，GPIO 在 APB2 上
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

    /*---------- 第2步：配置GPIO ----------*/
    // PB10(TX) + PB11(RX) 都配为复用推挽
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10 | GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    /*---------- 第3步：配置USART参数 ----------*/
    USART_InitStructure.USART_BaudRate            = 115200;              // 波特率
    USART_InitStructure.USART_WordLength           = USART_WordLength_8b;   // 8位数据
    USART_InitStructure.USART_StopBits             = USART_StopBits_1;      // 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(USART3, &USART_InitStructure);

    // 使能接收中断
    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);

    /*---------- 第4步：配置NVIC ----------*/
    NVIC_InitStructure.NVIC_IRQChannel                   = USART3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    /*---------- 第5步：使能串口 ----------*/
    USART_Cmd(USART3, ENABLE);
}

printf 重定向

#include "debug.h"

int main(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();

    // 一行搞定串口printf（USART1, PA9输出）
    USART_Printf_Init(115200);

    printf("Hello CH32V30x!\n");
    printf("System Clock: %d Hz\n", SystemCoreClock);

    int count = 0;
    while(1) {
        printf("Count: %d\n", count++);
        Delay_Ms(1000);
    }
}

接收处理（中断方式）

串口接收推荐使用中断方式，每收到一个字节自动触发 USART_IT_RXNE 中断。

/*==================== 中断处理函数 ====================*/
void USART3_IRQHandler(void)
{
    u8 temp;
    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    {
        // 读取接收到的数据（同时自动清除RXNE标志）
        temp = USART_ReceiveData(USART3);

        // 在这里处理接收到的数据
        // 例如：回显（收到什么就发回什么）
        USART_SendData(USART3, temp);
    }
    // 手动清除中断挂起位，确保不会重复触发
    USART_ClearITPendingBit(USART3, USART_IT_RXNE);
}

下面是完整的发送+接收示例，每秒发送字符 'a'，同时通过中断接收数据：

#include "debug.h"

// 中断函数声明
void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

void Usart3_Init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10 | GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOB, &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(USART3, &USART_InitStructure);
    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel                   = USART3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    USART_Cmd(USART3, ENABLE);
}

/*---------- 接收中断 ----------*/
void USART3_IRQHandler(void)
{
    u8 temp;
    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    {
        temp = USART_ReceiveData(USART3);
        // 回显：收到什么发回什么
        USART_SendData(USART3, temp);
    }
    USART_ClearITPendingBit(USART3, USART_IT_RXNE);
}

/*---------- 主函数 ----------*/
int main(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();
    Usart3_Init();

    while(1)
    {
        // 每秒发送一个字符 'a'
        USART_SendData(USART3, 'a');
        Delay_Ms(1000);
    }
}

第六章 综合项目

移植你的任务调度器

#include "debug.h"

/*==================== 任务调度器 ====================*/

volatile uint32_t uwTick = 0;

typedef struct {
    void (*task_func)(void);
    uint32_t rate_ms;
    uint32_t last_ms;
} task_t;

void Led_Task(void);
void Key_Task(void);
void Display_Task(void);

task_t Scheduler_Task[] = {
    {Led_Task,      500,  0},
    {Key_Task,      10,   0},
    {Display_Task,  100,  0},
};

const uint8_t task_num = sizeof(Scheduler_Task) / sizeof(task_t);

void Scheduler_Run(void)
{
    for(uint8_t i = 0; i < task_num; i++) {
        uint32_t now = uwTick;
        if(now - Scheduler_Task[i].last_ms >= Scheduler_Task[i].rate_ms) {
            Scheduler_Task[i].last_ms = now;
            Scheduler_Task[i].task_func();
        }
    }
}

/*==================== 任务实现 ====================*/

uint8_t led_state = 0;

void Led_Task(void) {
    led_state ^= 1;
    if(led_state) GPIO_SetBits(GPIOC, GPIO_Pin_2);
    else GPIO_ResetBits(GPIOC, GPIO_Pin_2);
}

void Key_Task(void) {
    // 按键扫描
}

void Display_Task(void) {
    static uint32_t count = 0;
    printf("Tick: %lu\n", count++);
}

/*==================== 主函数 ====================*/

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

void TIM3_IRQHandler(void) {
    if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET) {
        uwTick++;
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
    }
}

int main(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();
    USART_Printf_Init(115200);

    // GPIO/TIM初始化...

    while(1) {
        Scheduler_Run();
    }
}

工程模板结构建议

附录

API 速查表

GPIO

定时器

USART

常见问题排查