STM32定时器应用指南

STM32F103有两个基本定时器TIM6和TIM7，它们的功能完全相同，资源是完全独立的，可以同时使用。

主要特性：

定时原理:

影子寄存器： 实际起作用的寄存器，用户不可直接访问。举个例子：我们可以把预分频系数写入预分频器寄存器(TIMx_PSC)，但是预分频器寄存器只是起到缓存数据的作用，只有等到更新事件发生时，预分频器寄存器的值才会被自动写入其影子寄存器中，这时才真正起作用。

自动重载寄存器：自动重载寄存器及其影子寄存器的作用在于自动重载寄存器是否具有缓冲作用还受到ARPE位的控制。

更新事件的产生：

1. 软件产生，将 TIMx_EGR 寄存器的位UG置 1，产生更新事件后，硬件会自动将 UG 位清零。
2. 硬件产生，基本定时器的计数器(CNT)是一个递增的计数器，当寄存器(TIMx_CR1)的CEN位置 1，即使能定时器，每来一个CK_CNT脉冲，TIMx_CNT的值就会递增加1。当TIMx_CNT值与TIMx_ARR的设定值相等时，TIMx_CNT的值就会被自动清零并且会生成更新事件（如果开启相应的功能，就会产生DMA请求、产生中断信号或者触发DAC同步电路)，然后下一个 CK_CNT脉冲到来，TIMx_CNT的值就会递增加1，如此循环。在此过程中，TIMx_CNT等于 TIMx_ARR时，我们称之为定时器溢出，因为是递增计数，故而又称为定时器上溢。定时器溢出就伴随着更新事件的发生。

计数模式与溢出条件：

递增计数模式实例说明：

递减计数模式实例说明：

中心对齐计数模式实例说明：

控制寄存器 1(TIMx_CR1)

DMA/中断使能寄存器(TIMx_DIER)

状态寄存器(TIMx_SR)

计数器(TIMx_CNT)

预分频器(TIMx_PSC)

自动重装载寄存器(TIMx_ARR)

程序流程

功能：使用定时器中断实现LED灯闪烁.

定时器中断初始化

void btim_timx_int_init(uint16_t psc, uint16_t per)
{
    g_timx_handle.Instance = TIM6;
    g_timx_handle.Init.Prescaler = psc;
    g_timx_handle.Init.Period = per;
    
    HAL_TIM_Base_Init(&g_timx_handle);
    
    HAL_TIM_Base_Start_IT(&g_timx_handle);
    
}

定时器基础MSP初始化函数

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM6)
    {
        __HAL_RCC_TIM6_CLK_ENABLE();
        HAL_NVIC_SetPriority(TIM6_IRQn, 1, 3);
        HAL_NVIC_EnableIRQ(TIM6_IRQn);
    }
}

定时器6中断服务函数

void TIM6_IRQHandler()
{
    HAL_TIM_IRQHandler(&g_timx_handle);
}

定时器溢出中断回调函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM6)
    {
        LED0_TOGGLE();
    }
}

主函数

#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "./BSP/KEY/key.h"
#include "./BSP/BEEP/beep.h"
#include "./BSP/EXTI/exti.h"
#include "./BSP/WDG/wdg.h"
#include "./BSP/TIMER/btim.h"

int main(void)
{
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    btim_timx_int_init(7199, 4999);
  
    while(1)
    {
        
    }
} 

主要特性

16位递增、递减、中心对齐计数器（计数值：0~65535）

16位预分频器（分频系数：1~65536）

4个独立通道：输入捕获，输出比较，PWM生成，单脉冲模式输出

使用外部信号控制定时器且可实现多个定时器互连的同步电路

支持针对定位的增量编码器和霍尔传感器电路

触发输入作为外部时钟或者按周期的电流管理

控制器包括：触发控制器，从模式控制器，编码器接口

触发控制器：用来提供触发信号给别的外设

从模式控制器：可以控制计数器复位、启动、递增/递减、计数

编码器接口：针对编码器计数

控制寄存器1（TIMx_CR1）

从模式控制寄存器（TIMx_SMCR）

DMA/中断使能寄存器（TIMx_DIER）

状态寄存器（TIMx_SR）

计数寄存器（TIMx_CNT）

预分频寄存器（TIMx_PSC）

自动重载寄存器（TIMx_ARR）

通用定时器输出模式

PWM，即脉冲宽度调制，是利用微处理器的数字输出对模拟电路进行控制的一种非常有效的技术。让定时器产生PWM，在计数器频率固定时，PWM频率自动重载寄存器（TIMx_ARR）的值决定，其占空比由捕获/比较寄存器（TIMx_CCRx）的值决定。

PWM模式

PWM控制寄存器

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

捕获/比较使能寄存器（TIMx_CCER）

捕获/比较寄存器（TIMx_CCR1/2/3/4）

相关库函数介绍

功能：使用TM3通道2（由PB5复用）输出PWM,PB5引脚连接了LED0,从而实现PWM输出控制LED0亮度。

程序流程：

通用定时器PWM输出初始化函数

void gtim_timx_pwm_chy_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef timx_oc_pwm_chy;
    
    g_timx_pwm_chy_handle.Instance = TIM3;                       //定时器选择
    g_timx_pwm_chy_handle.Init.Prescaler = psc;                  //定时器分频
    g_timx_pwm_chy_handle.Init.Period = arr;
    g_timx_pwm_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP; //定时器计数模式
    HAL_TIM_PWM_Init(&g_timx_pwm_chy_handle);   //初始化PWM
    
    timx_oc_pwm_chy.OCMode = TIM_OCMODE_PWM1;   //模式选择PWM1
    timx_oc_pwm_chy.Pulse = arr/2;              //占空比为50%
    timx_oc_pwm_chy.OCNPolarity = TIM_OCNPOLARITY_LOW;  //输出比较极性为低
    
    HAL_TIM_PWM_ConfigChannel(&g_timx_pwm_chy_handle, &timx_oc_pwm_chy, TIM_CHANNEL_2);   //配置定时器3通道2
    HAL_TIM_PWM_Start(&g_timx_pwm_chy_handle, TIM_CHANNEL_2);  //开启PWM通道  
}

定时器输出PWM MSP初始化函数

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM3)
    {
        GPIO_InitTypeDef gpio_init_struct;
        __HAL_RCC_GPIOB_CLK_ENABLE();
        __HAL_RCC_TIM3_CLK_ENABLE();
        
        gpio_init_struct.Pin = GPIO_PIN_5;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;
        gpio_init_struct.Pull = GPIO_PULLUP;
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOB, &gpio_init_struct);
        
        __HAL_RCC_AFIO_CLK_ENABLE();
        __HAL_AFIO_REMAP_TIM3_PARTIAL();   //设置重映射,把TIM3通道2映射到PB5
    }
}

主函数

int main(void)
{
    uint16_t ledrpwmval = 0;
    uint8_t dir = 1;
    
    
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    
    gtim_timx_pwm_chy_init(500 - 1, 72 - 1);

     
    while(1)
    {
        delay_ms(10);
        
        if(dir) ledrpwmval++;
        else ledrpwmval--;
        
        if(ledrpwmval > 300) dir = 0;
        if(ledrpwmval == 0) dir = 1;
        
        __HAL_TIM_SET_COMPARE(&g_timx_pwm_chy_handle, TIM_CHANNEL_2, ledrpwmval);
    }
}

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

捕获/比较使能寄存器（TIMx_CCER）

相关函数的功能

功能

1、使用TM5CH1来做输入捕获，捕获PA0上的高电平脉宽，并将脉宽时间通过串口打印出来，然后通过按WKUP按键，模拟输入高电平，例程中能测试的最长高电平脉宽时间为： 4194303us.

2、LED0闪烁指示程序运行。

通用定时器TIM5通道1输入捕获初始化函数

void gtim_timx_cap_chy_init(uint16_t arr, uint16_t psc)
{
    TIM_IC_InitTypeDef timx_ic_cap_chy = {0};
    
    //初始化定时器参数 
    g_timx_cap_chy_handle.Instance = TIM5;        //定时器5的基地址
    g_timx_cap_chy_handle.Init.Prescaler = psc;   //定时器的分频系数
    g_timx_cap_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;   //递增计数模式
    g_timx_cap_chy_handle.Init.Period = arr;    //自动重装载值
    HAL_TIM_IC_Init(&g_timx_cap_chy_handle);    //初始化
    
    //配置通道映射、捕获边沿、分频、滤波等
    timx_ic_cap_chy.ICPolarity = TIM_ICPOLARITY_RISING;     //配置捕获极性为上升沿
    timx_ic_cap_chy.ICSelection = TIM_ICSELECTION_DIRECTTI; //映射到通道1
    timx_ic_cap_chy.ICPrescaler = TIM_ICPSC_DIV1;           //不进行分频
    timx_ic_cap_chy.ICFilter = 0;                           //不进行滤波
    HAL_TIM_IC_ConfigChannel(&g_timx_cap_chy_handle, &timx_ic_cap_chy, TIM_CHANNEL_1);   //初始化
    
    __HAL_TIM_ENABLE_IT(&g_timx_cap_chy_handle, TIM_IT_UPDATE);  //使能更新中断
    HAL_TIM_IC_Start_IT(&g_timx_cap_chy_handle, TIM_CHANNEL_1);  //开始捕获TIM5的通道1
}

通用定时器输入捕获初始化函数

void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
     if(htim->Instance == TIM5)    //判断定时器是否正确
     {
         GPIO_InitTypeDef gpio_init_struct;     //GPIO配置结构体
         
         __HAL_RCC_TIM5_CLK_ENABLE();    //使能定时器时钟
         __HAL_RCC_GPIOA_CLK_ENABLE();   //使能GPIOA时钟
         
         gpio_init_struct.Pin = GPIO_PIN_0;              //配置引脚号
         gpio_init_struct.Mode = GPIO_MODE_AF_PP;        //配置复用推挽输出
         gpio_init_struct.Pull = GPIO_PULLDOWN;          //配置下拉模式
         gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;  //配置输出速度
         HAL_GPIO_Init(GPIOA, &gpio_init_struct);   //初始化
         
         HAL_NVIC_SetPriority(TIM5_IRQn, 1, 3);          //设置中断优先级
         HAL_NVIC_EnableIRQ(TIM5_IRQn);                  //使能TIM5中断
     }
}

定时器TIM5中断服务函数

//定时器5中断服务函数
void TIM5_IRQHandler(void)
{
    //HAL库中断公共处理函数
    HAL_TIM_IRQHandler(&g_timx_cap_chy_handle);
}

定时器输入捕获中断处理回调函数

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM5)
    {
        if((g_timxchy_cap_sta & 0x80) == 0)  //未成功捕获
        {
            if(g_timxchy_cap_sta & 0x40)  //捕获下降沿
            {
                g_timxchy_cap_sta |= 0x80;   //位7置1 代表成功捕获
                g_timxchy_cap_val = HAL_TIM_ReadCapturedValue(&g_timx_cap_chy_handle, TIM_CHANNEL_1);   //保存当前计数器的值
                TIM_RESET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, TIM_CHANNEL_1);   //失能通道
                TIM_SET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, TIM_CHANNEL_1, TIM_ICPOLARITY_RISING);   //使能通道1为上降沿捕获
            }
            else  //捕获上升沿
            {
                g_timxchy_cap_sta = 0;
                g_timxchy_cap_val = 0;
                g_timxchy_cap_sta |= 0x40;
                __HAL_TIM_DISABLE(&g_timx_cap_chy_handle);   //失能定时器5
                __HAL_TIM_SET_COUNTER(&g_timx_cap_chy_handle, 0);   //计数器的值清0
                TIM_RESET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, TIM_CHANNEL_1);   //失能通道
                TIM_SET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, TIM_CHANNEL_1, TIM_ICPOLARITY_FALLING); //使能通道1为下降沿捕获
                __HAL_TIM_ENABLE(&g_timx_cap_chy_handle);   //使能定时器5
            }
        }
    }
}

定时器更新中断回调函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM5)
    {
        if((g_timxchy_cap_sta & 0x80) == 0)  //未成功捕获
        {
            if(g_timxchy_cap_sta & 0x40)     //已经成功捕获
            {
                if((g_timxchy_cap_sta & 0X3F) == 0x3f)  //高电平时间过长
                {
                    TIM_RESET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, TIM_CHANNEL_1);   //失能通道
                    TIM_SET_CAPTUREPOLARITY(&g_timx_cap_chy_handle, TIM_CHANNEL_1, TIM_ICPOLARITY_FALLING); //使能通道1为下降沿捕获
                    g_timxchy_cap_sta |= 0x80;    //标记成功捕获一次
                    g_timxchy_cap_val = 0xFFFF;
                }
                else   //累积定时器溢出次数
                {
                    g_timxchy_cap_sta++;
                }
            }
        }
    }
    
    if(htim->Instance == TIM6)
    {
        LED0_TOGGLE();
    }
    
    if(htim->Instance == TIM7)
    {
        LED1_TOGGLE();
    }
}

主函数

int main(void)
{
    uint32_t temp = 0;
    uint8_t t= 0;
    
    
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    
    gtim_timx_cap_chy_init(0xFFFF, 72 - 1);  //1MHz

     
    while(1)
    {
        if(g_timxchy_cap_sta & 0x80)
        {
            temp = g_timxchy_cap_sta & 0x3F;
            temp = temp * 65536;    //溢出时间总和
            temp += g_timxchy_cap_val;   //溢出的总时间
            printf("HIGH:%d us\r\n", temp);
            g_timxchy_cap_sta = 0;  //开启下一次捕获
        }
        
        t++;
        
        if(t > 20)
        {
            t = 0;
            LED0_TOGGLE();
        }
        delay_ms(10);
    }
}  

主程序运行流程

中断程序运行流程

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

与输入捕获配置相同

捕获/比较使能寄存器（TIMx_CCER）

与输入捕获配置相同

从模式控制寄存器（TIMx_SMCR）

相关库函数

功能：

使用TM2CH1做输入捕获，我们将捕获PA0上的高电平脉宽，并将脉宽进行计数，通过串口打印出来。大家可以通过按WKUP按键，输入高电平脉冲，通过按KEY0重设当前计数。 LED0闪烁，提示程序运行。

通用定时器脉冲计数初始化函数

void gtim_timx_cnt_chy_init(uint16_t psc)
{
    TIM_SlaveConfigTypeDef timx_slave_config = {0};
    
    
    g_timx_cnt_chy_handle.Instance = TIM2;                       //定时器选择
    g_timx_cnt_chy_handle.Init.Prescaler = psc;                  //定时器分频
    g_timx_cnt_chy_handle.Init.Period = 65535;
    g_timx_cnt_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP; //定时器计数模式
    HAL_TIM_IC_Init(&g_timx_cnt_chy_handle);   //初始化PWM
    
    timx_slave_config.SlaveMode = TIM_SLAVEMODE_EXTERNAL1;
    timx_slave_config.InputTrigger = TIM_TS_TI1F_ED;
    timx_slave_config.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;
    timx_slave_config.TriggerFilter = 0;
    HAL_TIM_SlaveConfigSynchro(&g_timx_cnt_chy_handle, &timx_slave_config);
    
    HAL_TIM_IC_Start(&g_timx_cnt_chy_handle, TIM_CHANNEL_1);
}

主函数

int main(void)
{
    uint16_t curcnt;  //存储当前的计数值
    uint16_t oldcnt;   //存储旧的计数值
    uint8_t key;      //按键的键值
    uint8_t t;        //延时时间
    
    
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    key_init();
    gtim_timx_cnt_chy_init(0);  

     
    while(1)
    {
        key = key_scan(0);
        if(key == 1)
        {
            __HAL_TIM_SET_COUNTER(&g_timx_cnt_chy_handle, 0);
        }
        
        curcnt = __HAL_TIM_GET_COUNTER(&g_timx_cnt_chy_handle);
        
        if(oldcnt != curcnt)
        {
            oldcnt = curcnt;
            printf("CNT:%d\r\n", oldcnt);
        }
        
        t++;
        
        if(t > 20)
        {
            t = 0;
            LED0_TOGGLE();
        }
        delay_ms(10);
    }
}  

控制寄存器1（TIMx_CR1）

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

捕获/比较使能寄存器（TIMx_CCER）

事件产生寄存器（TIMx_EGR）

重复计数器寄存器（TIMx_RCR）

捕获/比较寄存器1/2/3/4（TIMx_CCR1/2/3/4）

断路和死区寄存器（TIMx_BDTR）

具体函数功能

功能：

通过TIM8CH1(由PC6复用)输出PWM,然后为了指示PWM的输出情况，我们用杜邦线将PC6和PE5引脚的排针连接起来，从而实现PWM输出控制LED1(硬件已连接在PPE5引脚上)的亮灭。注意的点是：PE5要设置成浮空输入，避免引脚冲突，我们在main函数中设置好了，请看源码。上电默认输出5个PWM波，连接好杜邦线后可以看见LED1亮灭五次。之后按一下按键KEYO,就会输出5个PWM波控制LED1亮灭五次。LED0闪烁提示系统正在运行。

高级定时器输出指定个数PWM初始化

void atim_timx_npwm_chy_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef timx_oc_npwm_chy = {0};
    
    g_timx_npwm_chy_handle.Instance = TIM8;
    g_timx_npwm_chy_handle.Init.Prescaler = psc;
    g_timx_npwm_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;  //向上计数模式
    g_timx_npwm_chy_handle.Init.Period = arr;
    g_timx_npwm_chy_handle.Init.RepetitionCounter = 0;  //重复计数器初始值
    g_timx_npwm_chy_handle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; /*使能TIMx_ARR进行缓冲 */
    HAL_TIM_PWM_Init(&g_timx_npwm_chy_handle);
    
    timx_oc_npwm_chy.OCMode = TIM_OCMODE_PWM1;  //使用PWM1工作模式
    timx_oc_npwm_chy.Pulse = arr / 2;           //占空比设置为50%
    timx_oc_npwm_chy.OCPolarity = TIM_OCPOLARITY_HIGH;   //高电平有效
    HAL_TIM_PWM_ConfigChannel(&g_timx_npwm_chy_handle, &timx_oc_npwm_chy, TIM_CHANNEL_1);  //进行初始化
    
    __HAL_TIM_ENABLE_IT(&g_timx_npwm_chy_handle, TIM_IT_UPDATE);  //允许更新中断
    
    HAL_TIM_PWM_Start(&g_timx_npwm_chy_handle, TIM_CHANNEL_1);    //开启对应的PWM通道
}

高级定时器输出指定个数PWM MSP回调函数

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM8)
    {
        GPIO_InitTypeDef gpio_init_struct;
        
        __HAL_RCC_GPIOC_CLK_ENABLE();
        __HAL_RCC_TIM8_CLK_ENABLE();
        
        gpio_init_struct.Pin = GPIO_PIN_6;
        gpio_init_struct.Pull = GPIO_PULLUP;
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
        
        HAL_NVIC_SetPriority(TIM8_UP_IRQn, 1, 3);
        HAL_NVIC_EnableIRQ(TIM8_UP_IRQn);
    }
}

高级定时器设置PWM个数函数

void atim_timx_npwm_chy_set(uint8_t npwm)
{
    if(npwm == 0) return;
    
    g_npwm_remain = npwm;   //保存脉冲个数
    HAL_TIM_GenerateEvent(&g_timx_npwm_chy_handle, TIM_EVENTSOURCE_UPDATE);  //产生一次软件更新事件，在中断里面处理脉冲输出
    __HAL_TIM_ENABLE(&g_timx_npwm_chy_handle);   //使能定时器TIM8
}

定时器8中断服务函数

void TIM8_UP_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&g_timx_npwm_chy_handle);
}

定时器更新中断回调函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM8)
    {
        if(g_npwm_remain)
        {
            TIM8->RCR = g_npwm_remain - 1;
            HAL_TIM_GenerateEvent(&g_timx_npwm_chy_handle, TIM_EVENTSOURCE_UPDATE);
            __HAL_TIM_ENABLE(&g_timx_npwm_chy_handle);
            g_npwm_remain = 0;
        }
        else
        {
            TIM8->CR1 &= ~(1 << 0);
        }
    }
}

主函数

void LED_init(void)
{
    GPIO_InitTypeDef gpio_init_struct;
    
    gpio_init_struct.Pin = GPIO_PIN_5;
    gpio_init_struct.Mode = GPIO_MODE_INPUT;      //设置为输入，防止冲突(PC6)
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOE, &gpio_init_struct);
}

int main(void)
{
    uint8_t t = 0;
    uint8_t key = 0;
    
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
//    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    key_init();
    
    LED_init();   //需要重新配置PE5为输入模式防止冲突
 
    atim_timx_npwm_chy_init(5000 -1, 7200 - 1);
    
    atim_timx_npwm_chy_set(5); 

     
    while(1)
    {
        key = key_scan(0);
        
        if(key == 4)
        {
            atim_timx_npwm_chy_set(6);
        }
        
        t++;
        if(t > 50)
        {
            t = 0;
            LED0_TOGGLE();
        }
        delay_ms(10);
    }
}  

控制寄存器1（TIMx_CR1）

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

捕获/比较使能寄存器（TIMx_CCER）

捕获/比较寄存器1/2/3/4（TIMx_CCR1/2/3/4）

TIM1/TIM8断路和死区寄存器（TIMx_BDTR）

具体函数功能

功能：

使用输出比较模式的翻转功能，通过定时器8的4路通道输出占空比固定为50%、相位分别是25%、50%、75%和100%的PWM。

高级定时器输出比较初始化

void atim_timx_comp_pwm_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef timx_oc_comp_pwm = {0};
    
    g_timx_comp_pwm_handle.Instance = TIM8;
    g_timx_comp_pwm_handle.Init.Prescaler = psc;
    g_timx_comp_pwm_handle.Init.CounterMode = TIM_COUNTERMODE_UP;  //向上计数模式
    g_timx_comp_pwm_handle.Init.Period = arr;
    g_timx_comp_pwm_handle.Init.RepetitionCounter = 0;  //重复计数器初始值
    HAL_TIM_PWM_Init(&g_timx_comp_pwm_handle);
    
    timx_oc_comp_pwm.OCMode = TIM_OCMODE_TOGGLE;  //模式选择翻转
    timx_oc_comp_pwm.OCPolarity = TIM_OCPOLARITY_HIGH;   //极性选择高电平
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &timx_oc_comp_pwm, TIM_CHANNEL_1);
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &timx_oc_comp_pwm, TIM_CHANNEL_2);
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &timx_oc_comp_pwm, TIM_CHANNEL_3);
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &timx_oc_comp_pwm, TIM_CHANNEL_4);
    
    //使能通道预装载
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_1);
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_2);
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_3);
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_4);
    
    //使能输出、主输出、计数器
    HAL_TIM_OC_Start(&g_timx_comp_pwm_handle, TIM_CHANNEL_1);
    HAL_TIM_OC_Start(&g_timx_comp_pwm_handle, TIM_CHANNEL_2);
    HAL_TIM_OC_Start(&g_timx_comp_pwm_handle, TIM_CHANNEL_3);
    HAL_TIM_OC_Start(&g_timx_comp_pwm_handle, TIM_CHANNEL_4);
}

定时器输出比较MSP函数

void HAL_TIM_OC_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM8)
    {
        GPIO_InitTypeDef gpio_init_struct;
        
        __HAL_RCC_TIM8_CLK_ENABLE();
        __HAL_RCC_GPIOC_CLK_ENABLE();
               
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;  //推挽复用
        gpio_init_struct.Pin = GPIO_PIN_6;
        gpio_init_struct.Pull = GPIO_NOPULL;      //没有上下拉
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
        
        gpio_init_struct.Pin = GPIO_PIN_7;
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
        
        gpio_init_struct.Pin = GPIO_PIN_8;
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
        
        gpio_init_struct.Pin = GPIO_PIN_9;
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
    }
}

主函数

int main(void)
{
    uint8_t t = 0;
 
    
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    key_init();
 
    atim_timx_comp_pwm_init(1000 - 1, 72 - 1);
    
    __HAL_TIM_SET_COMPARE(&g_timx_comp_pwm_handle, TIM_CHANNEL_1, 250 - 1);
    __HAL_TIM_SET_COMPARE(&g_timx_comp_pwm_handle, TIM_CHANNEL_2, 500 - 1);
    __HAL_TIM_SET_COMPARE(&g_timx_comp_pwm_handle, TIM_CHANNEL_3, 750 - 1);
    __HAL_TIM_SET_COMPARE(&g_timx_comp_pwm_handle, TIM_CHANNEL_3, 1000 - 1);
   
    while(1)
    {     
        t++;
        if(t > 50)
        {
            t = 0;
            LED0_TOGGLE();
        }
        delay_ms(10);
    }
}  

程序运行结果

带死区控制的互补输出

CH1输出的PWM和CH1N输出的PWM在高低电平转换期间，插入了一段时间才实现互补输出。这段时间称为死区时间。上图箭头所指的区域就是死区时间，两段时间相同。

死区互补控制H桥

死区时间计算

控制寄存器1（TIMx_CR1）

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

捕获/比较使能寄存器（TIMx_CCER）

捕获/比较寄存器1/2/3/4（TIMx_CCR1/2/3/4）

TIM1/TIM8断路和死区寄存器（TIMx_BDTR）

对应的结构框图

刹车断路功能

发生刹车后：

相关函数功能

功能：

1. 利用TIM1_CH1(PE9)输出70%占空比的PWM波，它的互补输出通道(PE8)则是输出30%占空比的PWM波。
2. 刹车功能，当给刹车输入引脚(PE15)输入高电平时，进行刹车，即PE8和PE9停止输出PWM波。
3. LED0闪烁指示程序运行。

高级定时器互补输出初始化函数

void atim_timx_cplm_pwm_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef timx_oc_cplm_pwm = {0};
    
    g_timx_cplm_pwm_handle.Instance = TIM1;                       //定时器选择
    g_timx_cplm_pwm_handle.Init.Prescaler = psc;                  //定时器分频
    g_timx_cplm_pwm_handle.Init.Period = arr;
    g_timx_cplm_pwm_handle.Init.CounterMode = TIM_COUNTERMODE_UP; //定时器计数模式
    g_timx_comp_pwm_handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4;  //CKD[1:0] = 10
    HAL_TIM_PWM_Init(&g_timx_cplm_pwm_handle);   //初始化PWM
    
    
    timx_oc_cplm_pwm.OCMode = TIM_OCMODE_PWM1;             //模式选择PWM模式1
    timx_oc_cplm_pwm.OCPolarity = TIM_OCPOLARITY_HIGH;     //OC1高电平有效
    timx_oc_cplm_pwm.OCNPolarity = TIM_OCPOLARITY_HIGH;    //OC1N高电平有效
    timx_oc_cplm_pwm.OCIdleState = TIM_OCIDLESTATE_RESET;  //当MOE = 0, OC1 = 1;
    timx_oc_cplm_pwm.OCNIdleState = TIM_OCNIDLESTATE_RESET;//当MOE = 0, OC1x = 1;
    HAL_TIM_PWM_ConfigChannel(&g_timx_cplm_pwm_handle, &timx_oc_cplm_pwm, TIM_CHANNEL_1);
    
    //设置死区参数
    g_sbreak_dead_time_config.OffStateRunMode = TIM_OSSR_DISABLE;           //运行模式下的关闭状态选择
    g_sbreak_dead_time_config.OffStateIDLEMode = TIM_OSSI_DISABLE;          //空闲模式下的关闭状态选择
    g_sbreak_dead_time_config.LockLevel = TIM_LOCKLEVEL_OFF;                //寄存器锁定配置
    g_sbreak_dead_time_config.BreakState = TIM_BREAK_ENABLE;                //断路输入使能控制
    g_sbreak_dead_time_config.BreakPolarity = TIM_BREAKPOLARITY_HIGH;       //断路输入极性
    g_sbreak_dead_time_config.AutomaticOutput = TIM_AUTOMATICOUTPUT_ENABLE; //自动恢复输出使能控制
    HAL_TIMEx_ConfigBreakDeadTime(&g_timx_cplm_pwm_handle, &g_sbreak_dead_time_config);
    
    HAL_TIM_PWM_Start(&g_timx_cplm_pwm_handle, TIM_CHANNEL_1);    //启动定时器的正常输出
    HAL_TIMEx_PWMN_Start(&g_timx_cplm_pwm_handle, TIM_CHANNEL_1); //启动定时器的互补输出
}

定时器设置输出比较值死区时间

void atim_timx_cplm_pwm_set(uint16_t ccr, uint8_t dtg)
{
    //设置比较寄存器的值
    __HAL_TIM_SET_COMPARE(&g_timx_cplm_pwm_handle, TIM_CHANNEL_1, ccr);
    
    //单独进行死区时间的设置
    g_sbreak_dead_time_config.DeadTime = dtg;
    HAL_TIMEx_ConfigBreakDeadTime(&g_timx_cplm_pwm_handle, &g_sbreak_dead_time_config);
}

主函数

int main(void)
{
    uint8_t t = 0;
 
    
    HAL_Init();                             /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);     /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                     /* 串口初始化为115200 */
    led_init();                             /* 初始化LED */
    key_init();
 	
    //设置1khz的周期
    atim_timx_cplm_pwm_init(1000 - 1, 72 - 1);
    
    //设置TIM捕获比较寄存器值,从而控制占空比为70%
    atim_timx_cplm_pwm_set(700 - 1, 100);
   
    while(1)
    {     
        t++;
        if(t > 50)
        {
            t = 0;
            LED0_TOGGLE();
        }
        delay_ms(10);
    }
}  

程序运行流程

程序运行结果

从模式控制寄存器（TIMx_SMCR）

捕获/比较模式寄存器1/2（TIMx_CCMR1/2）

捕获/比较使能寄存器（TIMx_CCER）

捕获/比较寄存器1/2/3/4（TIMx_CCR1/2/3/4）

DMA中断使能寄存器（TIMx_DIER）

函数具体功能

功能：

首先通过TM3_CH2(PB5)输出PWM波。然后把PB5输出的PWM波用杜邦线接入PC6(定时器8通道1)，最后通过串口打印PWM波的脉宽和频率等信息。通过LED1闪烁来提示程序正在运行。

通用定时器PWM输出初始化函数

void gtim_timx_pwm_chy_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef timx_oc_pwm_chy;
    
    g_timx_pwm_chy_handle.Instance = TIM3;
    g_timx_pwm_chy_handle.Init.Prescaler = psc;
    g_timx_pwm_chy_handle.Init.Period = arr;
    g_timx_pwm_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
    HAL_TIM_PWM_Init(&g_timx_pwm_chy_handle);
    
    timx_oc_pwm_chy.OCMode = TIM_OCMODE_PWM1;
    timx_oc_pwm_chy.Pulse = arr / 2;
    timx_oc_pwm_chy.OCPolarity = TIM_OCPOLARITY_LOW;
    HAL_TIM_PWM_ConfigChannel(&g_timx_pwm_chy_handle, &timx_oc_pwm_chy, TIM_CHANNEL_2);
    HAL_TIM_PWM_Start(&g_timx_pwm_chy_handle, TIM_CHANNEL_2);
}

定时器输出PWM MSP初始化函数

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM3)
    {
        GPIO_InitTypeDef gpio_init_struct;
        __HAL_RCC_GPIOB_CLK_ENABLE();
        __HAL_RCC_TIM3_CLK_ENABLE();

        gpio_init_struct.Pin = GPIO_PIN_5;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;            /* 推挽复用 */
        gpio_init_struct.Pull = GPIO_PULLUP;                /* 上拉 */
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;      /* 高速 */
        HAL_GPIO_Init(GPIOB, &gpio_init_struct);
        
        __HAL_RCC_AFIO_CLK_ENABLE();
        __HAL_AFIO_REMAP_TIM3_PARTIAL();
    }
}

PWM输入模式初始化函数

void atim_timx_pwmin_chy_init(void)
{
    TIM_SlaveConfigTypeDef slave_config = {0};
    TIM_IC_InitTypeDef tim_ic_pwmin_chy = {0};

    g_timx_pwmin_chy_handle.Instance = TIM8;                        /* 定时器8 */
    g_timx_pwmin_chy_handle.Init.Prescaler = 0;                     /* 定时器预分频系数 */
    g_timx_pwmin_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;  /* 递增计数模式 */
    g_timx_pwmin_chy_handle.Init.Period = 65535;                    /* 自动重装载值 */
    HAL_TIM_IC_Init(&g_timx_pwmin_chy_handle);
    
    /* 从模式配置，IT1触发更新 */
    slave_config.SlaveMode = TIM_SLAVEMODE_RESET;                   /* 从模式：复位模式 */
    slave_config.InputTrigger = TIM_TS_TI1FP1;                      /* 定时器输入触发源：TI1FP1 */
    slave_config.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;      /* 上升沿检测 */
    slave_config.TriggerFilter = 0;                                 /* 不滤波 */
    HAL_TIM_SlaveConfigSynchro(&g_timx_pwmin_chy_handle, &slave_config);

    /* IC1捕获：上升沿触发TI1FP1 */
    tim_ic_pwmin_chy.ICPolarity = TIM_ICPOLARITY_RISING;            /* 上升沿检测 */
    tim_ic_pwmin_chy.ICSelection = TIM_ICSELECTION_DIRECTTI;        /* 选择输入端IC1映射到TI1 */
    tim_ic_pwmin_chy.ICPrescaler = TIM_ICPSC_DIV1;                  /* 不分频 */
    tim_ic_pwmin_chy.ICFilter = 0;                                  /* 不滤波 */
    HAL_TIM_IC_ConfigChannel(&g_timx_pwmin_chy_handle, &tim_ic_pwmin_chy, TIM_CHANNEL_1);

    /* IC2捕获：下降沿触发TI1FP2 */
    tim_ic_pwmin_chy.ICPolarity = TIM_ICPOLARITY_FALLING;           /* 下降沿检测 */
    tim_ic_pwmin_chy.ICSelection = TIM_ICSELECTION_INDIRECTTI;      /* 选择输入端IC2映射到TI1 */
    HAL_TIM_IC_ConfigChannel(&g_timx_pwmin_chy_handle, &tim_ic_pwmin_chy, TIM_CHANNEL_2);

    HAL_TIM_IC_Start_IT(&g_timx_pwmin_chy_handle, TIM_CHANNEL_1);
    HAL_TIM_IC_Start(&g_timx_pwmin_chy_handle, TIM_CHANNEL_2);
}

定时器输入捕获MSP初始化函数

void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM8)
    {
        GPIO_InitTypeDef gpio_init_struct = {0};

        __HAL_RCC_TIM8_CLK_ENABLE();
        __HAL_RCC_GPIOC_CLK_ENABLE();

        gpio_init_struct.Pin = GPIO_PIN_6;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;
        gpio_init_struct.Pull = GPIO_PULLDOWN;
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
        
        /* TIM1/TIM8有独立的输入捕获中断服务函数 */
        HAL_NVIC_SetPriority(TIM8_CC_IRQn, 1, 3);
        HAL_NVIC_EnableIRQ(TIM8_CC_IRQn);
    }
}

定时器8输入捕获中断服务函数

void TIM8_CC_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&g_timx_pwmin_chy_handle); /* 定时器共用处理函数 */
}

PWM输入模式重新启动捕获函数

void atim_timx_pwmin_chy_restart(void)
{
    sys_intx_disable();                     /* 关闭中断 */

    g_timxchy_pwmin_sta = 0;                /* 清零状态,重新开始检测 */
    g_timxchy_pwmin_hval=0;
    g_timxchy_pwmin_cval=0;

    sys_intx_enable();                      /* 打开中断 */
}

定时器输入捕获中断处理回调函数

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM8)
    {
        if(g_timxchy_pwmin_sta == 0)
        {
            if(htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)
            {
                g_timxchy_pwmin_hval = HAL_TIM_ReadCapturedValue(&g_timx_pwmin_chy_handle, TIM_CHANNEL_2) + 1 + 1;
                g_timxchy_pwmin_cval = HAL_TIM_ReadCapturedValue(&g_timx_pwmin_chy_handle, TIM_CHANNEL_1) + 1 + 1;
                g_timxchy_pwmin_sta = 1;
            }
        }
    }
}

主函数

int main(void)
{
    uint8_t t = 0;
    double ht, ct, f, tpsc;

    HAL_Init();                                 /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9);         /* 设置时钟, 72Mhz */
    delay_init(72);                             /* 延时初始化 */
    usart_init(115200);                         /* 串口初始化为115200 */
    led_init();                                 /* 初始化LED */
    gtim_timx_pwm_chy_init(10 - 1, 72 - 1);
    
    TIM3->CCR2 = 3;
    
    atim_timx_pwmin_chy_init();
    
    while (1)
    {
        delay_ms(10);
        t++;

        if (t >= 20)    /* 每200ms输出一次结果,并闪烁LED0,提示程序运行 */
        {
            if (g_timxchy_pwmin_sta)    /* 捕获了一次数据 */
            {
                printf("\r\n");                                     /* 输出空,另起一行 */
                printf("PWM PSC  :%d\r\n", g_timxchy_pwmin_psc);    /* 打印分频系数 */
                printf("PWM Hight:%d\r\n", g_timxchy_pwmin_hval);   /* 打印高电平脉宽 */
                printf("PWM Cycle:%d\r\n", g_timxchy_pwmin_cval);   /* 打印周期 */
                tpsc = ((double)g_timxchy_pwmin_psc + 1) / 72;      /* 得到PWM采样时钟周期时间 */ 
                ht = g_timxchy_pwmin_hval * tpsc;                   /* 计算高电平时间 */
                ct = g_timxchy_pwmin_cval * tpsc;                   /* 计算周期长度 */
                f = (1 / ct) * 1000000;                             /* 计算频率 */
                printf("PWM Hight time:%.3fus\r\n", ht);            /* 打印高电平脉宽长度 */
                printf("PWM Cycle time:%.3fus\r\n", ct);            /* 打印周期时间长度 */
                printf("PWM Frequency :%.3fHz\r\n", f);             /* 打印频率 */ 
                atim_timx_pwmin_chy_restart(); /* 重启PWM输入检测 */
            } 

            LED1_TOGGLE();  /* LED1（GREEN）闪烁 */
            t = 0;
        }
    }
}