Timer on CLing

GD32 — 定时器 (TIMER)

Tue, 08 Sep 2026 14:52:21 +0800

GD32 — 定时器 (TIMER)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 13
推荐入门: TIMER1_pwmout（PWM 输出）

什么是定时器（TIMER）？

如果你把 MCU 比作一个"按节拍走路的人"，定时器就是它的节拍器。它本质上是一个从 0 开始不断加 1 的计数器，挂在某个固定频率的时钟上。数到设定值就"归零"并触发一个事件（更新中断、翻转引脚、产生 PWM 等）。

它的用途极广，几乎贯穿所有嵌入式项目：

用途	说明
精确延时 / 周期触发	替代 `delay()`，做精准定时任务
PWM 输出	调光、电机调速、舵机控制、音频
输入捕获（Input Capture）	测频率、测脉宽、测占空比
输出比较（Output Compare）	到指定时刻翻转/置位引脚
编码器接口	读取旋转编码器（电机测速）
死区/刹车	电机驱动、电源逆变（高级定时器）

一句话记忆：凡是"和时间、节奏、脉冲"有关的活，基本都交给定时器。

几个必须懂的核心概念

1. 时钟频率与分频

定时器的计数时钟来自 APB 总线，经 预分频器（PSC，Prescaler） 分频后得到实际计数频率：

`1`	`计数频率 f_cnt = 定时器输入时钟 / (PSC + 1)`

例如 GD32F30x 系统时钟 120MHz，APB2 上的 TIMER1 输入时钟也是 120MHz。若 PSC = 119，则 f_cnt = 120MHz / 120 = 1MHz，即每 1 微秒计一次数。

2. 自动重装载值（ARR，Auto-Reload / Period）

计数器从 0 数到 ARR（即 period），然后溢出归零，完成一个周期。一个 PWM 周期的时间：

`1`	`周期 T = (ARR + 1) / f_cnt`

本例里 period = 15999，所以一个周期 = 16000 / 1MHz = 16ms（约 62.5Hz）。

3. 比较值（CCR，Pulse / 占空比）

每个通道有一个比较寄存器。计数器在跑，当 计数器值 == 比较值 时，引脚按设定的极性翻转/置位。于是：

`1`	`占空比 = (CCR + 1) / (ARR + 1) （PWM 模式0/1 略有差别，但近似成立）`

CCR 越大，高电平时间越长，占空比越高。

4. PWM 模式 0 / 模式 1 与极性

PWM 模式 0：计数 < CCR 时输出无效电平（通常低），≥ CCR 时输出有效电平（高）。
PWM 模式 1：反过来。
极性（Polarity）：把"有效电平"定义成高还是低。极性一翻转，波形就上下颠倒，但占空比数值不变。

初学者只需记住：模式0/1 + 极性组合，决定"波形哪段是高"。本例用 PWM0 + 高极性，占空比 = CCR/ARR。

5. 向上 / 向下 / 中央对齐计数

向上计数（Up）：0 → ARR，最常用。
向下计数（Down）：ARR → 0。
中央对齐（Center-aligned）：0 → ARR → 0，对称波形，适合电机/电源。本例用向上计数。

GD32F30x 的定时器家族

TIMER0：高级定时器，带互补输出、死区、刹车，用于电机/逆变。
TIMER1 / TIMER2：通用定时器，PWM、输入捕获、输出比较都支持，最常用。
TIMER3~TIMER13（视型号）：更多通用/基本定时器。
每个通用定时器有 4 个通道（CH0~CH3），可独立输出不同占空比的 PWM。

常用库函数速查

函数	作用
`timer_deinit(TIMERx)`	复位定时器
`timer_init(TIMERx, &initpara)`	按结构体初始化（PSC/ARR/计数方向等）
`timer_prescaler_config()` / `timer_autoreload_value_config()`	运行时改分频 / 重装载值
`timer_channel_output_config()`	配置某通道输出（使能、极性、空闲态）
`timer_channel_output_pulse_value_config()`	设置比较值 CCR（决定占空比）
`timer_channel_output_mode_config()`	设为 PWM0/PWM1/翻转等模式
`timer_auto_reload_shadow_enable()`	开启 ARR 影子寄存器（避免更新瞬间毛刺）
`timer_enable(TIMERx)`	启动定时器

示例列表

TIMER1 PWM 输出 — TIMER1_pwmout ★ 入门推荐
TIMER1 输出比较有效 — TIMER1_ocactive
TIMER1 输出比较翻转 — TIMER1_octoggle
TIMER1 单脉冲 — TIMER1_singlepulse
TIMER1 外部触发 — TIMER1_exttrigger
TIMER2 输入捕获 — TIMER2_inputcapture
TIMER2 PWM 输入捕获 — TIMER2_pwminputcapture
TIMER0 互补信号 — TIMER0_complementarysignals
TIMER0 死区与刹车 — TIMER0_deadtime_break
TIMER0 6 步换相 — TIMER0_6-steps
TIMER0 DMA — TIMER0_dma
TIMER0 DMA 突发 — TIMER0_dma_burst
定时器级联同步 — TIMERs_cascadesynchro

学习路径建议

先吃透 TIMER1_pwmout：理解"PSC 决定频率、ARR 决定周期、CCR 决定占空比"这三件套。
再看 TIMER1_ocactive / TIMER1_octoggle 理解"输出比较"和 PWM 的关系。
需要测频率/脉宽时看 TIMER2_inputcapture；需要多路同步 PWM 看 TIMER0 系列。

下一篇：TIMER1 PWM 输出

GD32 TIMER — TIMER0 6 步换相

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER0 6 步换相

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER0_6-steps/main.c

功能简介

本示例演示定时器的基本用法。定时器是 MCU 最灵活的外设之一，可以实现定时、PWM、输入捕获、编码器等多种功能。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#include "systick.h"

void gpio_config(void);
void timer_config(void);
void nvic_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA8 PA9 PA10(TIMER0 CH0 CH1 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_10);

    /*configure PB13 PB14 PB15(TIMER0 CH0N CH1N CH2N) as alternate function*/
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_13);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_14);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_15);

    /*configure PB12(TIMER0 BKIN) as alternate function*/
    gpio_init(GPIOB,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_12);
}

void nvic_config(void)
{
#ifndef GD32F30X_HD
    nvic_irq_enable(TIMER0_TRG_CMT_TIMER10_IRQn, 0, 1);
#else
    nvic_irq_enable(TIMER0_TRG_CMT_IRQn, 0, 1);
#endif
}

void timer_config(void)
{
    /* -----------------------------------------------------------------------
    TIMER0 configuration:
    generate 3 complementary PWM signal.
    TIMER0CLK is fixed to systemcoreclock, the TIMER0 prescaler is equal to 119 
    so the TIMER0 counter clock used is 1MHz.
    insert a dead time equal to 200/systemcoreclock =1.67us 
    configure the break feature, active at low level, and using the automatic
    output enable feature.
    use the locking parameters level 0.
    ----------------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;
    timer_break_parameter_struct timer_breakpara;

    rcu_periph_clock_enable(RCU_TIMER0);

    timer_deinit(TIMER0);

    /* TIMER0 configuration */
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 599;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER0,&timer_initpara);

     /* CH0/CH0N,CH1/CH1N and CH2/CH2N configuration in timing mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_ENABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_HIGH;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_HIGH;

    timer_channel_output_config(TIMER0,TIMER_CH_0,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_1,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_2,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_0,299);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_0,TIMER_OC_MODE_TIMING);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_0,TIMER_OC_SHADOW_ENABLE);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_1,299);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_1,TIMER_OC_MODE_TIMING);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_1,TIMER_OC_SHADOW_ENABLE);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_2,299);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_2,TIMER_OC_MODE_TIMING);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_2,TIMER_OC_SHADOW_ENABLE);


    /* automatic output enable, break, dead time and lock configuration*/
    timer_breakpara.runoffstate      = TIMER_ROS_STATE_ENABLE;
    timer_breakpara.ideloffstate     = TIMER_IOS_STATE_ENABLE ;
    timer_breakpara.deadtime         = 164;
    timer_breakpara.breakpolarity    = TIMER_BREAK_POLARITY_LOW;
    timer_breakpara.outputautostate  = TIMER_OUTAUTO_ENABLE;
    timer_breakpara.protectmode      = TIMER_CCHP_PROT_OFF;
    timer_breakpara.breakstate       = TIMER_BREAK_DISABLE;
    timer_break_config(TIMER0,&timer_breakpara);
    
    /* TIMER0 primary output function enable */
    timer_primary_output_config(TIMER0,ENABLE);

    /* TIMER0 channel control update interrupt enable */
    timer_interrupt_enable(TIMER0,TIMER_INT_CMT);
    /* TIMER0 break interrupt disable */
    timer_interrupt_disable(TIMER0,TIMER_INT_BRK);

    /* TIMER0 counter enable */
    timer_enable(TIMER0);
}

int main(void)
{
    gpio_config(); 
    systick_config();
    nvic_config();
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

GD32 TIMER — TIMER0 DMA

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER0 DMA

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER0_dma/main.c

功能简介

本示例演示定时器 DMA 触发。定时器事件自动触发 DMA 传输，无需 CPU 干预，适合波形生成等高速场景。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define TIMER0_CH0CV  ((uint32_t)0x40012C34)

void gpio_config(void);
void timer_config(void);
void dma_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA8(TIMER0 CH0) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;

    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA0);

    /* initialize DMA channel5 */
    dma_deinit(DMA0,DMA_CH4);

    /* DMA channel5 initialize */
    dma_init_struct.periph_addr = (uint32_t)TIMER0_CH0CV;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_addr = (uint32_t)buffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_16BIT;
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.number = 3;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0,DMA_CH4,&dma_init_struct);
    
    dma_circulation_enable(DMA0,DMA_CH4);

    /* enable DMA channel5 */
    dma_channel_enable(DMA0,DMA_CH4);
}

void timer_config(void)
{
    /* TIMER0 DMA Transfer example -------------------------------------------------
    TIMER0CLK = 120MHz, Prescaler = 119 
    TIMER0 counter clock = systemcoreclock/120 = 1MHz.

    the objective is to configure TIMER0 channel 1 to generate PWM
    signal with a frequency equal to 1KHz and a variable duty cycle(25%,50%,75%) that is 
    changed by the DMA after a specific number of update DMA request.

    the number of this repetitive requests is defined by the TIMER0 repetition counter,
    each 2 update requests, the TIMER0 Channel 0 duty cycle changes to the next new 
    value defined by the buffer . 
    -----------------------------------------------------------------------------*/
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER0);

    timer_deinit(TIMER0);

    /* TIMER0 configuration */
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 1;
    timer_init(TIMER0,&timer_initpara);

    /* CH0 configuration in PWM1 mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_HIGH;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    timer_channel_output_config(TIMER0,TIMER_CH_0,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_0,buffer[0]);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* TIMER0 primary output enable */
    timer_primary_output_config(TIMER0,ENABLE);

    /* TIMER0 update DMA request enable */
    timer_dma_enable(TIMER0,TIMER_DMA_UPD);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER0);

    /* TIMER0 counter enable */
    timer_enable(TIMER0);
}

int main(void)
{
    gpio_config(); 
    dma_config();
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

GD32 TIMER — TIMER0 DMA 突发

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER0 DMA 突发

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER0_dma_burst/main.c

功能简介

本示例演示定时器 DMA 触发。定时器事件自动触发 DMA 传输，无需 CPU 干预，适合波形生成等高速场景。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define TIMER0_DMATB           ((uint32_t)0x40012C4C)

void gpio_config(void);
void timer_config(void);
void dma_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA8(TIMER0 CH0) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);

    /*configure PA9(TIMER0 CH1) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9);

    /*configure PA10(TIMER0 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_10);

    /*configure PA11(TIMER0 CH3) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_11);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;

    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA0);

    /* initialize DMA channel4 */
    dma_deinit(DMA0,DMA_CH4);

    /* DMA channel4 initialize */
    dma_init_struct.periph_addr = (uint32_t)TIMER0_DMATB;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_addr = (uint32_t)buffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_16BIT;
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.number = 8;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0,DMA_CH4,&dma_init_struct);

    dma_circulation_enable(DMA0,DMA_CH4);

    /* enable DMA channel4 */
    dma_channel_enable(DMA0,DMA_CH4);
    
}

void timer_config(void)
{
    /* TIMER0 DMA transfer example -------------------------------------------------
    TIMER0CLK = 120MHz, prescaler = 119 
    TIMER0 counter clock = systemcoreclock/120 = 1MHz.

      The objective is to configure TIMER0 channel 0~3(PA8~PA11) to generate PWM signal.
    capture compare register 0~3 are to be updated twice per circle.On the first update 
    DMA request, data1 is transferred to CH0CV, data2 is transferred to CH1CV, data3 is 
    transferred to CH2CV,data4 is transferred to CH3CV and duty cycle(10%,20%,30%,40%). 
    On the second update DMA request, data5 is transferred to CH0CV, data6 is transferred 
    to CH1CV, data7 is transferred to CH2CV,data8 is transferred to CH3CV and duty cycle
    (50%,60%,70%,80%). 
    -----------------------------------------------------------------------------*/
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER0);

    timer_deinit(TIMER0);

    /* TIMER0 configuration */
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER0,&timer_initpara);

    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_HIGH;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;

    timer_channel_output_config(TIMER0,TIMER_CH_0,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_1,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_2,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_3,&timer_ocintpara);

    /* CH0 configuration in PWM0 mode */
    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_0,buffer[0]);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* CH1 configuration in PWM0 mode */
    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_1,buffer[0]);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_1,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_1,TIMER_OC_SHADOW_DISABLE);

    /* CH2 configuration in PWM0 mode */
    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_2,buffer[0]);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_2,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_2,TIMER_OC_SHADOW_DISABLE);

    /* CH3 configuration in PWM0 mode */
    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_3,buffer[0]);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_3,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_3,TIMER_OC_SHADOW_DISABLE);

    /* TIMER0 primary output enable */
    timer_primary_output_config(TIMER0,ENABLE);

    /* TIMER0 update DMA request enable */
    timer_dma_transfer_config(TIMER0,TIMER_DMACFG_DMATA_CH0CV,TIMER_DMACFG_DMATC_4TRANSFER);
    timer_dma_enable(TIMER0,TIMER_DMA_UPD);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER0);

    /* TIMER0 counter enable */
    timer_enable(TIMER0);
}

int main(void)
{
    gpio_config(); 
    dma_config();
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

GD32 TIMER — TIMER0 互补信号

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER0 互补信号

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER0_complementarysignals/main.c

功能简介

本示例演示互补输出和死区控制。用于驱动半桥/全桥电路，上下管交替导通，死区时间防止上下管同时导通（直通）。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA8 PA9 PA10(TIMER0 CH0 CH1 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_10);

    /*configure PB13 PB14 PB15(TIMER0 CH0N CH1N CH2N) as alternate function*/
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_13);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_14);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_15);
}

void timer_config(void)
{
/* -----------------------------------------------------------------------
    TIMER0 configuration to:
    generate 3 complementary PWM signals with 3 different duty cycles:
    TIMER0CLK is fixed to systemcoreclock, the TIMER0 prescaler is equal to 6000 so the 
    TIMER0 counter clock used is 20KHz.
    the three duty cycles are computed as the following description: 
    the channel 0 duty cycle is set to 25% so channel 1N is set to 75%.
    the channel 1 duty cycle is set to 50% so channel 2N is set to 50%.
    the channel 2 duty cycle is set to 75% so channel 3N is set to 25%.
  ----------------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER0);

    timer_deinit(TIMER0);

    /* TIMER0 configuration */
    timer_initpara.prescaler         = 5999;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 15999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER0,&timer_initpara);

     /* CH1,CH2 and CH3 configuration in PWM mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_ENABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;

    timer_channel_output_config(TIMER0,TIMER_CH_0,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_1,&timer_ocintpara);
    timer_channel_output_config(TIMER0,TIMER_CH_2,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_0,3999);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_1,7999);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_1,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_1,TIMER_OC_SHADOW_DISABLE);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_2,11999);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_2,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_2,TIMER_OC_SHADOW_DISABLE);

    timer_primary_output_config(TIMER0,ENABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER0);
    timer_enable(TIMER0);
}

int main(void)
{
    gpio_config(); 
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

GD32 TIMER — TIMER0 死区与刹车

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER0 死区与刹车

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER0_deadtime_break/main.c

功能简介

本示例演示互补输出和死区控制。用于驱动半桥/全桥电路，上下管交替导通，死区时间防止上下管同时导通（直通）。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA8(TIMER0 CH0) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);

    /*configure PB13(TIMER0 CH0N) as alternate function*/
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_13);

    /*configure PB12(TIMER0 BKIN) as alternate function*/
    gpio_init(GPIOB,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_12);
}

void timer_config(void)
{
    /* -----------------------------------------------------------------------
    TIMER0 configuration:
    generate 1 complementary PWM signal.
    TIMER0CLK is fixed to systemcoreclock, the TIMER0 prescaler is equal to 120 so the
    TIMER0 counter clock used is 1MHz.
    the duty cycle is computed as the following description:
    the channel 0 duty cycle is set to 25% so channel 0N is set to 75%.

    insert a dead time equal to ((32+31)*16*4)/systemcoreclock = 33.6us

    configure the break feature, active at high level, and using the automatic
    output enable feature.

    use the locking parameters level1.
    ----------------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;
    timer_break_parameter_struct timer_breakpara;

    rcu_periph_clock_enable(RCU_TIMER0);

    timer_deinit(TIMER0);

    /* TIMER0 configuration */
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 1599;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV4;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER0,&timer_initpara);

    /* CH0/CH0N configuration in PWM mode0 */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_ENABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_HIGH;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;

    timer_channel_output_config(TIMER0,TIMER_CH_0,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_0,399);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* automatic output enable, break, dead time and lock configuration*/
    timer_breakpara.runoffstate      = TIMER_ROS_STATE_DISABLE;
    timer_breakpara.ideloffstate     = TIMER_IOS_STATE_DISABLE ;
    timer_breakpara.deadtime         = 255;
    timer_breakpara.breakpolarity    = TIMER_BREAK_POLARITY_LOW;
    timer_breakpara.outputautostate  = TIMER_OUTAUTO_ENABLE;
    timer_breakpara.protectmode      = TIMER_CCHP_PROT_0;
    timer_breakpara.breakstate       = TIMER_BREAK_ENABLE;
    timer_break_config(TIMER0,&timer_breakpara);

    /* TIMER0 primary output function enable */
    timer_primary_output_config(TIMER0,ENABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER0);

    /* TIMER0 counter enable */
    timer_enable(TIMER0);
}

int main(void)
{
    gpio_config(); 
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

GD32 TIMER — TIMER1 PWM 输出

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER1 PWM 输出

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER1_pwmout/main.c

功能简介

本示例用 TIMER1 的 3 个通道（CH0/CH1/CH2）同时输出 3 路 PWM（脉冲宽度调制） 波形，每路的频率相同、占空比不同：

CH0（PA0）：占空比 25%
CH1（PA1）：占空比 50%
CH2（PA2）：占空比 75%

PWM 是嵌入式里最常用、也最好玩的功能之一——LED 呼吸灯、电机调速、舵机转角、蜂鸣器音调，本质上都是"调占空比 / 调频率"。本例不依赖任何中断，配置好定时器后它就在后台自动、持续地翻转引脚，CPU 可以干别的（这里只是 while(1) 空转）。

PWM 是什么直观感受？ 想象一个电灯以很快的频率（比如 60Hz 以上，人眼看不见闪烁）在"亮—灭—亮—灭"。亮的时间占比就是"占空比"。占空比 25% 看起来暗，75% 看起来亮——这就是 LED 调光的原理。

硬件准备

1. 开发板

GD32F30x 评估板（本例无 LED/串口，纯定时器输出）。

2. 观察 PWM 的两种方式

示波器 / 逻辑分析仪：直接测量 PA0 / PA1 / PA2 三路波形，最直观。
用 LED + 限流电阻：把 PA0~PA2 各串一个 220Ω 电阻接 LED 到地。占空比 25% 的灯明显比 75% 的暗。注意 TIMER1 是 3.3V 电平，LED 别直接接大电流。
万用表测电压：直流档测 PA0，读数 ≈ 3.3V × 占空比（25% → 约 0.83V，50% → 约 1.65V，75% → 约 2.48V）。这也是"PWM 当 DAC 用"的思路。

3. 引脚

通道	引脚	复用功能
CH0	PA0	TIMER1_CH0
CH1	PA1	TIMER1_CH1
CH2	PA2	TIMER1_CH2

完整代码（带中文注释）

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      GPIO 配置：把 PA0/PA1/PA2 设为 TIMER1 的复用输出
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);   /* 用复用功能必须开 AF 时钟 */

    /* PA0/PA1/PA2 作为 TIMER1 的 CH0/CH1/CH2，配成 复用推挽输出 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_0);
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_1);
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_2);
}

/*!
    \brief      TIMER1 配置：输出 3 路不同占空比的 PWM
    计算过程：
      TIMER1CLK = SystemCoreClock / 120 = 120MHz / 120 = 1MHz
      周期 = (ARR+1) / 1MHz = 16000 / 1MHz = 16ms  → 频率约 62.5Hz
      CH0 占空比 = 4000 / 16000 = 25%
      CH1 占空比 = 8000 / 16000 = 50%
      CH2 占空比 = 12000 / 16000 = 75%
*/
void timer_config(void)
{
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct    timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER1);

    timer_deinit(TIMER1);   /* 先复位，防止残留配置干扰 */

    /* ---- 定时器基础参数 ---- */
    timer_initpara.prescaler         = 119;            /* 预分频：120MHz/(119+1)=1MHz */
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;   /* 边沿对齐（非中央对齐） */
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;     /* 向上计数 0→ARR */
    timer_initpara.period            = 15999;          /* 自动重装载值 ARR：0~15999 */
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;     /* 时钟不分频（与死区无关） */
    timer_initpara.repetitioncounter = 0;             /* 重复计数（高级定时器才用） */
    timer_init(TIMER1, &timer_initpara);

    /* ---- 三通道共用的输出参数 ---- */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;     /* 通道输出使能 */
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;  /* 互补通道不用 */
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;    /* 有效电平=高 */
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;   /* 空闲时输出低 */
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    timer_channel_output_config(TIMER1, TIMER_CH_0, &timer_ocintpara);
    timer_channel_output_config(TIMER1, TIMER_CH_1, &timer_ocintpara);
    timer_channel_output_config(TIMER1, TIMER_CH_2, &timer_ocintpara);

    /* ---- CH0：PWM 模式0，比较值 3999 → 占空比约 25% ---- */
    timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_0, 3999);
    timer_channel_output_mode_config(TIMER1, TIMER_CH_0, TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER1, TIMER_CH_0, TIMER_OC_SHADOW_DISABLE);

    /* ---- CH1：PWM 模式0，比较值 7999 → 占空比约 50% ---- */
    timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_1, 7999);
    timer_channel_output_mode_config(TIMER1, TIMER_CH_1, TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER1, TIMER_CH_1, TIMER_OC_SHADOW_DISABLE);

    /* ---- CH2：PWM 模式0，比较值 11999 → 占空比约 75% ---- */
    timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_2, 11999);
    timer_channel_output_mode_config(TIMER1, TIMER_CH_2, TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER1, TIMER_CH_2, TIMER_OC_SHADOW_DISABLE);

    /* 开启自动重装载影子寄存器（更新 ARR 时不产生毛刺） */
    timer_auto_reload_shadow_enable(TIMER1);
    /* 启动定时器，PWM 开始输出 */
    timer_enable(TIMER1);
}

int main(void)
{
    gpio_config();
    timer_config();

    while (1) {
        /* 定时器在后台自动翻转引脚，CPU 这里空转即可 */
    }
}

代码分段讲解

1. GPIO：PWM 引脚是"复用功能"

`1`	`gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_0); // PA0 = TIMER1_CH0`

PWM 波形不是软件一位位翻转出来的，而是定时器硬件直接驱动引脚产生的。所以引脚必须配成 GPIO_MODE_AF_PP（复用推挽），并且必须开 RCU_AF 时钟。如果忘了开 AF，引脚不会输出 PWM。

2. 定时器的"三件套"：PSC、ARR、CCR

PWM 的两个关键量——频率和占空比——由这三者决定：

参数	代码	含义	决定什么
预分频 PSC	`prescaler = 119`	计数时钟 = 120MHz/120 = 1MHz	时间基准
重装载 ARR	`period = 15999`	一个周期计 16000 次 → 16ms	频率（约 62.5Hz）
比较值 CCR	`pulse = 3999/7999/11999`	计到该值时翻转	占空比

占空比公式（PWM 模式 0、高极性）：

占空比 ≈ CCR / (ARR + 1)
CH0: 3999 / 16000 ≈ 25%
CH1: 7999 / 16000 ≈ 50%
CH2: 11999 / 16000 ≈ 75%

（代码注释里写 4000/16000 是取整近似，实际 CCR=3999，细节不重要，理解"比例"即可。）

为什么 TIMER1CLK 要除以 120 而不是直接用 120MHz？ 直接用 120MHz 计数，16000 次只有 133 微秒，频率高达 7.5kHz，对 LED 调光没问题，但本例想演示"慢一点、好测"。分频到 1MHz 后频率约 62.5Hz，既方便示波器观察，也接近 LED 调光的常用频段。想得到别的频率，改 PSC 或 ARR 即可。

3. 通道输出配置：使能 + 极性

1
2
3

timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;       // 通道输出打开
timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH; // 有效电平为高
timer_channel_output_config(TIMER1, TIMER_CH_x, &timer_ocintpara);

outputstate = ENABLE：告诉定时器"这个通道要往引脚上输出波形"。
ocpolarity = HIGH：把"有效电平"定义成高电平。配合 PWM0 模式，效果是"计数 < CCR 时输出低，≥ CCR 时输出高"——也就是高电平占 CCR/ARR，正弦地，占空比 = CCR/ARR。
互补通道（outputnstate/ocnpolarity）只在高级定时器 TIMER0 驱动半桥电机时才用，本例关掉。

4. 每通道：比较值 + 模式 + 影子

1
2
3

timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_0, 3999);  // 设 CCR
timer_channel_output_mode_config(TIMER1, TIMER_CH_0, TIMER_OC_MODE_PWM0);  // 设 PWM0
timer_channel_output_shadow_config(TIMER1, TIMER_CH_0, TIMER_OC_SHADOW_DISABLE); // 影子

三行缺一不可：

设比较值：决定占空比的核心数字。
设模式为 PWM0：让通道进入"比较值到就翻转"的 PWM 行为。
影子寄存器：这里 DISABLE 表示 CCR 立即生效。若开启影子（ENABLE），修改 CCR 会在下次更新事件才生效，可避免中途改值导致波形断裂。本例静态输出，关不关都行。

5. 启动：影子 ARR + 使能

1
2

timer_auto_reload_shadow_enable(TIMER1);  // ARR 用影子寄存器
timer_enable(TIMER1);                    // 启动！PWM 开始输出

timer_auto_reload_shadow_enable：让 ARR 也在"更新事件"时才更新，避免在计数中途改周期导致波形毛刺（本例虽不改 ARR，但这是好习惯）。
timer_enable 才是真正的"发令枪"——调用之后，硬件计数器开始跑，引脚上立刻出现 PWM 波形。配置再多，不 enable 就没输出。

实验现象

下载程序并复位后，PA0 / PA1 / PA2 立即开始输出 PWM（无需任何触发）。
用示波器看：
- 三路频率相同（约 62.5Hz，周期约 16ms）。
- 占空比分别为 25% / 50% / 75%，高电平宽度依次翻倍。
若用 LED 接这三路：亮度明显呈暗 → 中 → 亮三档。
若用万用表直流档：电压约为 0.83V / 1.65V / 2.48V（3.3V × 占空比）。

常见问题

Q1：下载后引脚没有任何波形？
按顺序排查：① 是否 timer_enable(TIMER1) 被调用（没启动当然没输出）；② 引脚是否配成 GPIO_MODE_AF_PP 且开了 RCU_AF；③ 是否开了 RCU_TIMER1 时钟；④ 通道 outputstate 是否为 TIMER_CCX_ENABLE。

Q2：频率/占空比和预期不符？
先确认系统时钟：GD32F30x 评估板通常是 120MHz，例程按此算 1MHz 计数时钟。若你的板子系统时钟不同（如 108MHz），TIMER1CLK = SystemCoreClock / 120 的分母就要相应改。频率 = 1MHz / (ARR+1)，占空比 = CCR/(ARR+1)，用公式反推即可。

Q3：想改频率怎么办？
频率 = 计数时钟 / (ARR+1)。改 period（ARR）最直接；要同时保住占空比比例，就按同比例改三路的 pulse 值。注意 ARR 越大频率越低。

Q4：想调占空比怎么办？
改对应通道的 timer_channel_output_pulse_value_config(..., CCR)。CCR 越大占空比越高。运行时也可以反复调用这个函数动态调（比如做呼吸灯）。

Q5：PWM 模式 0 和模式 1 有什么区别？
PWM0：计数 < CCR 输出无效（低），≥ CCR 输出有效（高）；PWM1 反过来。再叠加 ocpolarity 的极性翻转，最终波形可上可下。本例用 PWM0+高极性，结果是"高电平占比 = CCR/ARR"。记不住就实际用示波器看一眼。

Q6：为什么 PA0~PA2 能同时输出？一个定时器不是只有一个计数器吗？
对！TIMER1 只有一个计数器在跑，但它有多个比较通道（CH0~CH3），每个通道有独立的 CCR。计数器是大家共用的，每个通道拿同一个计数值和自己的 CCR 比，于是同一频率下能输出不同占空比的多路 PWM。这正是"用一个定时器驱动多个舵机/多个 LED"的原理。

小结

本示例把 PWM 的"三件套"讲得干干净净：

开时钟：RCU_GPIOA + RCU_AF（复用必须）+ RCU_TIMER1。
配 GPIO：PWM 引脚设 GPIO_MODE_AF_PP。
配定时器：PSC 定时间基准、ARR 定周期（频率）、计数方向=向上。
配通道：使能输出、设极性、设 PWM0 模式、设 CCR（占空比）。
启动：timer_auto_reload_shadow_enable + timer_enable，硬件自动输出。

记住公式 频率 = 计数时钟/(ARR+1)，占空比 = CCR/(ARR+1)，你就能随心所欲地产生任意 PWM。

拓展应用

掌握 PWM 后，可以做一堆好玩的项目：

LED 呼吸灯：在 while(1) 里用循环不断改 pulse 值（从 0 渐增到 ARR 再渐减），占空比平滑变化，LED 就会"呼吸"。
电机调速：把 PWM 接到直流电机驱动模块（如 L298N、TB6612）的使能端，占空比越大转速越高。
舵机控制：舵机靠 50Hz（周期 20ms）PWM 的脉宽定位，1.5ms 居中、0.5~~2.5ms 对应 0~~180°。改 ARR/PSC 得到 50Hz，再用 CCR 调脉宽即可。
蜂鸣器/音频：无源蜂鸣器用不同频率的 PWM 发出不同音调，可演奏简单音乐。
伪 DAC：低通滤波 PWM 得到平滑电压，用占空比当"模拟量输出"（精度有限但省 DAC 外设）。
多路独立 PWM：TIMER1 的 4 个通道可各自不同占空比，同时驱动 4 个舵机或 4 路 LED 调光。
进阶：需要精确测频率/脉宽时，看同目录 TIMER2_inputcapture；需要电机死区/互补输出看 TIMER0 系列。

想理解"比较值怎么自动改出呼吸灯/波形"，建议基于本例把 while(1) 改成动态调整 pulse 的小循环试试。

GD32 TIMER — TIMER1 单脉冲

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER1 单脉冲

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER1_singlepulse/main.c

功能简介

本示例演示单脉冲模式。定时器触发一次后只产生一个脉冲就停止，适合精确延时触发场景。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA0 PA1(TIMER1 CH0 CH1) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_1);
}

void timer_config(void)
{
    /* -----------------------------------------------------------------------
    TIMER1 configuration: single pulse mode
    the external signal is connected to TIMER1 CH0 pin (PA0) and the falling 
    edge is used as active edge.
    the single pulse signal is output on TIMER1 CH1 pin (PA1).

    the TIMER1CLK frequency is set to systemcoreclock,the prescaler is 
    60,so the TIMER1 counter clock is 2MHz.

    single pulse value = (TIMER1_Period - TIMER1_Pulse) / TIMER1 counter clock
                       = (65535 - 11535) / 2MHz = 27 ms.
    ----------------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocinitpara;
    timer_parameter_struct timer_initpara;
    timer_ic_parameter_struct timer_icinitpara;

    rcu_periph_clock_enable(RCU_TIMER1);

    timer_deinit(TIMER1);

    /* TIMER1 configuration */
    timer_initpara.prescaler         = 59;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 65535;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

    /* auto-reload preload disable */
    timer_auto_reload_shadow_disable(TIMER1);

    /* CH1 configuration in OC PWM mode */
    timer_ocinitpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocinitpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocinitpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocinitpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocinitpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocinitpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    
    timer_channel_output_config(TIMER1,TIMER_CH_1,&timer_ocinitpara);

    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_1,11535);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_1,TIMER_OC_MODE_PWM1);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_1,TIMER_OC_SHADOW_DISABLE);

    /* TIMER1 CH0 input capture configuration */
    timer_icinitpara.icpolarity  = TIMER_IC_POLARITY_FALLING;
    timer_icinitpara.icselection = TIMER_IC_SELECTION_DIRECTTI;
    timer_icinitpara.icprescaler = TIMER_IC_PSC_DIV1;
    timer_icinitpara.icfilter = 0x00;
    timer_input_capture_config(TIMER1,TIMER_CH_0,&timer_icinitpara);

    /* single pulse mode selection */
    timer_single_pulse_mode_config(TIMER1,TIMER_SP_MODE_SINGLE);

    /* slave mode selection : TIMER1 */
    /* TIMER1 input trigger : external trigger connected to CI0 */
    timer_input_trigger_source_select(TIMER1,TIMER_SMCFG_TRGSEL_CI0FE0);
    timer_slave_mode_select(TIMER1,TIMER_SLAVE_MODE_EVENT);
}

int main(void)
{
    gpio_config(); 
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

GD32 TIMER — TIMER1 输出比较翻转

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER1 输出比较翻转

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER1_octoggle/main.c

功能简介

本示例演示输出比较模式。定时器计数到设定值时自动翻转/置高/置低引脚，可以生成精确的方波信号。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA1(TIMER1 CH1) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_1);
}

void timer_config(void)
{
    /* ---------------------------------------------------------------------------
    TIMER1 configuration: output compare toggle mode:
    TIMER1CLK = systemcoreclock / 6000=20K,
    CH1 update rate = TIMER1 counter clock / CH1VAL = 20000/4000 = 5 Hz
    ----------------------------------------------------------------------------*/
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER1);

    timer_deinit(TIMER1);

    /* TIMER1 configuration */
    timer_initpara.prescaler         = 5999;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 3999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

     /* CH1 configuration in OC TOGGLE mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    
    timer_channel_output_config(TIMER1,TIMER_CH_1,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_1,3999);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_1,TIMER_OC_MODE_TOGGLE);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_1,TIMER_OC_SHADOW_DISABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER1);
    timer_enable(TIMER1);
}

int main(void)
{
    gpio_config(); 
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 TIMER — TIMER1 输出比较有效

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER1 输出比较有效

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER1_ocactive/main.c

功能简介

本示例演示输出比较模式。定时器计数到设定值时自动翻转/置高/置低引脚，可以生成精确的方波信号。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*Configure PA0 PA1 PA2(TIMER1 CH0 CH1 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_1);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_2);
}

void timer_config(void)
{
    /* ---------------------------------------------------------------
    TIMER1 Configuration: 
    TIMER1CLK = SystemCoreClock / 12000 = 10K,
    And generate 3 signals with 3 different delays:
    TIMER1_CH0 delay = 4000/10000  = 0.4s
    TIMER1_CH1 delay = 8000/10000  = 0.8s
    TIMER1_CH2 delay = 12000/10000 = 1.2s
    --------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER1);

    timer_deinit(TIMER1);

    /* TIMER1 configuration */
    timer_initpara.prescaler         = 11999;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 65535;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

    /* CH0,CH1 and CH2 configuration in OC active mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;

    timer_channel_output_config(TIMER1,TIMER_CH_0,&timer_ocintpara);
    timer_channel_output_config(TIMER1,TIMER_CH_1,&timer_ocintpara);
    timer_channel_output_config(TIMER1,TIMER_CH_2,&timer_ocintpara);

    /* CH0 configuration in OC active mode */
    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_0,3999);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_0,TIMER_OC_MODE_ACTIVE);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* CH1 configuration in OC active mode */
    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_1,7999);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_1,TIMER_OC_MODE_ACTIVE);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_1,TIMER_OC_SHADOW_DISABLE);

    /* CH2 configuration in OC active mode */
    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_2,11999);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_2,TIMER_OC_MODE_ACTIVE);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_2,TIMER_OC_SHADOW_DISABLE);

    timer_enable(TIMER1);
}

int main(void)
{
    gpio_config(); 
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 TIMER — TIMER1 外部触发

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER1 外部触发

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER1_exttrigger/main.c

功能简介

本示例演示定时器的基本用法。定时器是 MCU 最灵活的外设之一，可以实现定时、PWM、输入捕获、编码器等多种功能。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA2(TIMER1 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_2);

    /*configure PA0(TIMER1 CH0) as floating function*/
    gpio_init(GPIOA,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
}

void timer_config(void)
{
    /* Timer with an external trigger -------------------------------------
    TIMER1 is configured as slave timer for an external trigger connected
    to TIMER1 CI0 pin :
    - The TIMER1 CI0FE0 is used as trigger input
    - rising edge is used to start the TIMER1: event mode.
    - TIMER1 CH2 is used PWM0 Mode 
    the starts of the TIMER1 counter are controlled by the 
    external trigger.  
    -------------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocinitpara;
    timer_parameter_struct timer_initpara;
    timer_ic_parameter_struct timer_icinitpara;

    rcu_periph_clock_enable(RCU_TIMER1);

    timer_deinit(TIMER1);

    /* TIMER1 configuration */
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 7999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

     /* CH2 configuration in OC PWM0 mode */
    timer_ocinitpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocinitpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocinitpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocinitpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocinitpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocinitpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    timer_channel_output_config(TIMER1,TIMER_CH_2,&timer_ocinitpara);

    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_2,3999);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_2,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_2,TIMER_OC_SHADOW_DISABLE);

    /* TIMER1 CH0 input capture configuration */
    timer_icinitpara.icpolarity  = TIMER_IC_POLARITY_RISING;
    timer_icinitpara.icselection = TIMER_IC_SELECTION_DIRECTTI;
    timer_icinitpara.icprescaler = TIMER_IC_PSC_DIV1;
    timer_icinitpara.icfilter    = 0x02;
    timer_input_capture_config(TIMER1,TIMER_CH_0,&timer_icinitpara);

    /* slave mode selection : TIMER1 */
    /* TIMER1 input trigger : external trigger connected to CI0 */
    timer_input_trigger_source_select(TIMER1,TIMER_SMCFG_TRGSEL_CI0FE0);
    timer_slave_mode_select(TIMER1,TIMER_SLAVE_MODE_EVENT);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER1);
}

int main(void)
{
    gpio_config();
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

GD32 TIMER — TIMER2 PWM 输入捕获

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER2 PWM 输入捕获

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER2_pwminputcapture/main.c

功能简介

本示例演示定时器 PWM 输入捕获功能。可以测量外部 PWM 信号的频率和占空比，常用于读取遥控器信号、编码器等。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#include "systick.h"

int main(void)
{
    systick_config();
    gpio_configuration(); 
    gd_eval_com_init(EVAL_COM1);
    nvic_configuration();
    timer_configuration();

    while (1){
        delay_1ms(1000);
        printf("\r /**** TIMER2 PWM Input Capture Demo ****/\r\n");
        printf("the dutycycle is %d\n",dutycycle);
        printf("the frequence is %d\n",frequency);
    }
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

GD32 TIMER — TIMER2 输入捕获

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMER2 输入捕获

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMER2_inputcapture/main.c

功能简介

本示例演示定时器输入捕获功能。当外部信号边沿到来时，定时器自动记录当前计数值，可以精确测量信号的脉宽和频率。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#include "systick.h"

int main(void)
{
    gpio_configuration(); 
    gd_eval_com_init(EVAL_COM1);
    nvic_configuration();
    timer_configuration();
    systick_config();
    while (1)
    {
        delay_1ms(1000);
        printf("\r /**** TIMER2 Input Capture Demo ****/\r\n");
        printf("the frequence is %d\n",fre);
    }
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

GD32 TIMER — TIMERs_cascadesynchro

Tue, 08 Sep 2026 14:52:21 +0800

TIMER — TIMERs_cascadesynchro

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/TIMER/TIMERs_cascadesynchro/main.c

功能简介

本示例演示定时器的基本用法。定时器是 MCU 最灵活的外设之一，可以实现定时、PWM、输入捕获、编码器等多种功能。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void gpio_config(void);
void timer_config(void);

/*!
    \brief      configure the GPIO ports
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA6(TIMER2 CH0) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_6);

    /*configure PA2(TIMER1 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_2);

    /*configure PA8(TIMER0 CH0) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
}

void timer_config(void)
{
    /* timers synchronisation in cascade mode ----------------------------
       1/TIMER1 is configured as master timer:
       - PWM mode is used
       - The TIMER1 update event is used as trigger output  

       2/TIMER2 is slave for TIMER1 and master for TIMER0,
       - PWM mode is used
       - The ITR1(TIMER1) is used as input trigger 
       - external clock mode is used,the counter counts on the rising edges of
         the selected trigger.
       - the TIMER2 update event is used as trigger output. 

       3/TIMER0 is slave for TIMER2,
       - PWM mode is used
       - The ITR2(TIMER2) is used as input trigger
       - external clock mode is used,the counter counts on the rising edges of
         the selected trigger.
      -------------------------------------------------------------------- */
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER0);
    rcu_periph_clock_enable(RCU_TIMER1);
    rcu_periph_clock_enable(RCU_TIMER2);

    /* TIMER1  configuration */
    timer_deinit(TIMER1);

    timer_initpara.prescaler         = 5999;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 3999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

    /* CH1 configuration in PWM0 mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    timer_channel_output_config(TIMER1,TIMER_CH_2,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER1,TIMER_CH_2,1999);
    timer_channel_output_mode_config(TIMER1,TIMER_CH_2,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER1,TIMER_CH_2,TIMER_OC_SHADOW_DISABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER1);
    /* select the master slave mode */
    timer_master_slave_mode_config(TIMER1,TIMER_MASTER_SLAVE_MODE_ENABLE);
    /* TIMER1 update event is used as trigger output */
    timer_master_output_trigger_source_select(TIMER1,TIMER_TRI_OUT_SRC_UPDATE);

    /* TIMER2  configuration */
    timer_deinit(TIMER2);

    timer_initpara.prescaler         = 0;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 1;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER2,&timer_initpara);

    /* CH0 configuration in PWM0 mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    timer_channel_output_config(TIMER2,TIMER_CH_0,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER2,TIMER_CH_0,1);
    timer_channel_output_mode_config(TIMER2,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER2,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER2);
    /* slave mode selection: TIMER2 */
    timer_slave_mode_select(TIMER2,TIMER_SLAVE_MODE_EXTERNAL0);
    timer_input_trigger_source_select(TIMER2,TIMER_SMCFG_TRGSEL_ITI1);
    /* select the master slave mode */
    timer_master_slave_mode_config(TIMER2,TIMER_MASTER_SLAVE_MODE_ENABLE);
    /* TIMER2 update event is used as trigger output */
    timer_master_output_trigger_source_select(TIMER2,TIMER_TRI_OUT_SRC_UPDATE);

    /* TIMER0  configuration */
    timer_deinit(TIMER0);

    timer_initpara.prescaler         = 0;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 1;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER0,&timer_initpara);

    /* CH0 configuration in PWM0 mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;
    timer_channel_output_config(TIMER0,TIMER_CH_0,&timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER0,TIMER_CH_0,1);
    timer_channel_output_mode_config(TIMER0,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(TIMER0,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(TIMER0);
    /* TIMER0 output enable */
    timer_primary_output_config(TIMER0,ENABLE);
    /* slave mode selection: TIMER0 */
    timer_slave_mode_select(TIMER0,TIMER_SLAVE_MODE_EXTERNAL0);
    timer_input_trigger_source_select(TIMER0,TIMER_SMCFG_TRGSEL_ITI2);

    /* TIMER counter enable */
    timer_enable(TIMER1);
    timer_enable(TIMER2);
    timer_enable(TIMER0);
}

int main(void)
{
    gpio_config(); 
    timer_config();

    while (1);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。