STM32——TIMER（定时器）篇_stm32 timer

技术笔记！

1.   定时器概述（了解）

1.1  软件定时器原理

使用纯软件（CPU死等）的方式实现定时（延时）功能

缺点：1. 延时不准确        2. CPU死等。      

1.2  定时器定时原理

1.3  STM32定时器分类

1.4  STM32定时器特性表（F1为例）

可参考芯片数据手册或者各个开发板对应的开发指南

1.5  STM32定时器之间的区别

2.  基本定时器（掌握）

基础定时器 通用定时器 没有输入输出通道，常用作时基，即定时功能

2.1  基本定时器简介（了解）

主要特性：

16位递增计数器（计数值：0~65535）

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

可用于触发DAC

在更新事件（计数器溢出）时，会产生中断/DMA请求

2.2  基本定时器框图（熟悉）

2.3  定时器计数模式及溢出条件（熟悉）

2.4  定时器中断实验相关寄存器（了解）F1为例

1.  TIM6和TIM7控制寄存器1（TIMx_CR1)

2.  TIM6 和TIM7 DMA/中断使能寄存器(TIMx_DIER)

3.  TIM6 和TIM7 状态寄存器(TIMx_SR)

4.  TIM6 和TIM7 计数器(TIMx_CNT)

5.   TIM6 和TIM7 预分频器(TIMx_PSC)

6.  TIM6 和TIM7 自动重装载寄存器(TIMx_ARR)

2.5  定时器溢出时间计算方法（掌握）

2.6  定时器中断实验配置步骤（掌握）

2.7  基础定时器实验

使用定时器6，实现500ms定时器更新中断，在中断里翻转LED0

btim.c

#include "./BSP/LED/led.h"
#include "btim.h"
 
TIM_HandleTypeDef g_timx_handle;
 
/* 定时器中断初始化函数 */
void btim_timx_int_init(uint16_t arr, uint16_t psc)
{
    g_timx_handle.Instance = TIM6;              //基地址
    g_timx_handle.Init.Prescaler = psc;         //预分频系数
    g_timx_handle.Init.Period = arr;            //预加载值
    
    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(void)
{
    HAL_TIM_IRQHandler(&g_timx_handle);
}
 
/* 定时器溢出中断中断回调函数 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM6)
    {
        LED0_TOGGLE();
    }
}

main.c

#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "./BSP/BTIM/btim.h"
 
 
int main(void)
{
    HAL_Init();                         /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
    delay_init(72);                     /* 延时初始化 */
    led_init();                         /* LED初始化 */
    btim_timx_int_init(5000-1, 7200 -1);/* 10Khz的计数频率，计数5K次为500ms */
    
    while(1)
    { 
 
        delay_ms(500);
    }
}

实验小结：

        首先通过自定义的中断初始化函数对基础定时器进行初始化，配置定时器句柄结构体的相关成员变量赋值，通过基础时钟初始化函数对基础时钟初始化，通过基础时钟中断并启动计数器函数进行使能该基础时钟，再通过定时器基础msp初始化函数对时钟和中断进行使能及配置，最后通过对应定时器中断服务函数进行中断处理。

3.  通用计时器（掌握）

3.1  通用计时器简介（了解）

主要特性：

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

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

可用于触发DAC、ADC 在更新事件、触发事件、输入捕获、输出比较时，会产生中断/DMA请求

4个独立通道，可用于：输入捕获、输出比较、输出PWM、单脉冲模式 使用外部信号控制定时器且可实现多个定时器互连的同步电路 支持编码器和霍尔传感器电路等

3.2  通用定时器框图（熟悉）

3.3  计数器时钟源（掌握）

3.4  通用定时器PWM输出实验（掌握）

脉冲宽度调制(PWM)，是英文“Pulse Width Modulation”的缩写，简称脉宽调制，是利用微 处理器的数字输出来对模拟电路进行控制的一种非常有效的技术

3.4.1  通用定时器输出比较部分框图介绍（熟悉）

3.4.2  通用定时器输出PWM原理（掌握）

        让定时器产生PWM， 在计数器频率固定时，PWM 频率或者周期由自动重载寄存（TIMx_ARR）的值决定，其占空 比由捕获/比较寄存器（TIMx_CCRx）的值决定。

        当 CNT=CCRx 时，IO 输出高电平（逻辑 1）；当 CNT=ARR 时，定时器溢出，CNT 的值被清零，然后继续递增，依次循环。

        在这个循环中，改 变 CCRx 的值，就可以改变 PWM 的占空比，改变 ARR 的值，就可以改变 PWM 的频率，这就 是 PWM 输出的原理。

3.4.3  PWM模式（熟悉）

3.4.4  通用定时器PWM输出实验配置步骤（掌握）

相关寄存器讲解：

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

        TIM2/TIM3/TIM4/TIM5 的捕获/比较模式寄存器（TIMx_CCMR1/2），该寄存器一般有 2 个TIMx _CCMR1 和 TIMx _CCMR2。TIMx_CCMR1 控制 CH1 和 CH2，而 TIMx_CCMR2 控制 CH3 和 CH4。TIMx_CCMR1 寄存器描述如图 21.3.1.1 所示：

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

        TIM2/TIM3/TIM4/TIM5 的捕获/比较使能寄存器，该寄存器控制着各个输入输出通道的开 关和极性。TIMx_CCER 寄存器描述如图 21.3.1.2 所示：

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

        捕获/比较寄存器（TIMx_CCR1/2/3/4），该寄存器总共有 4 个，对应 4 个通道 CH1~CH4。 我们使用的是通道 2，所以来看看 TIMx_CCR2 寄存器，描述如图 21.3.1.3 所示

3.4.5  通用定时器PWM输出实验（掌握）

pwm.c

#include "./BSP/LED/led.h"
#include "./BSP/PWM/pwm.h"
 
TIM_HandleTypeDef g_timx_pwm_chy_handle;
TIM_OC_InitTypeDef g_timx_oc_pwm_chy_handle;
 
 
void gtim_timx_pwm_chy_init(uint16_t arr, uint16_t psc)
{
    g_timx_pwm_chy_handle.Instance = TIM3 ;                     /* 定时器 x */
    g_timx_pwm_chy_handle.Init.Prescaler = psc;                 /* 定时器分频 */
    g_timx_pwm_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;/* 递增计数模式 */
    g_timx_pwm_chy_handle.Init.Period = arr;                    /* 自动重装载值 */
    HAL_TIM_PWM_Init(&g_timx_pwm_chy_handle);                   /* 初始化 PWM */
    
    g_timx_oc_pwm_chy_handle.OCMode = TIM_OCMODE_PWM1;          /* 模式选择 PWM1 */
    /* 设置比较值,此值用来确定占空比，默认比较值为自动重装载值的一半,即占空比为 50% */
    g_timx_oc_pwm_chy_handle.Pulse = arr/2;
    g_timx_oc_pwm_chy_handle.OCPolarity = TIM_OCNPOLARITY_LOW;  /* 输出比较极性为低 */
 
    
    HAL_TIM_PWM_ConfigChannel(&g_timx_pwm_chy_handle, &g_timx_oc_pwm_chy_handle, TIM_CHANNEL_2);/* 配置 TIMx 通道 y */
    HAL_TIM_PWM_Start(&g_timx_pwm_chy_handle, TIM_CHANNEL_2);               /*开启 PWM 通道*/
    
}
 
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM3)
    {
        GPIO_InitTypeDef gpio_init_struct;
        __HAL_RCC_GPIOB_CLK_ENABLE();                   /* 开启通道 y 的 CPIO 时钟 */
        __HAL_RCC_TIM3_CLK_ENABLE();
        
        gpio_init_struct.Pin = GPIO_PIN_5;              /* 通道 y 的 CPIO 口 */
        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);
        GTIM_TIMX_PWM_CHY_GPIO_REMAP();                 /* IO 口 REMAP 设置，设置重映射 */
    }
}

main.c

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);                     /* 延时初始化 */
    led_init();                         /* LED初始化 */
    /* 72M/72=1M 的计数频率，自动重装载为 500，那么 PWM 频率为 1M/500=2kHZ */
    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);
 
        
    }
}

3.5  通用定时器输入捕获实验（掌握）

3.5.1  通用定时器输入捕获部分框图介绍（熟悉）

3.5.2  通用定时器输入捕获脉宽测量原理（掌握）

3.5.3  通用定时器输入捕获实验配置步骤（掌握）

3.5.4  通用定时器输入捕获实验（掌握）

tim.c

#include "./BSP/LED/led.h"
#include "tim.h"
 
TIM_HandleTypeDef g_timx_cap_chy_handle;        /* 定时器x句柄 */
/* 通用定时器通道y 输入捕获 初始化函数 */
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;          /* 映射到TI1上 */
    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);  /* 配置TIM5通道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 */
}
 
/* 定时器 输入捕获 MSP初始化函数 */
void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM5)                              /*输入通道捕获*/
    {                                                       
        GPIO_InitTypeDef gpio_init_struct;                  
        __HAL_RCC_TIM5_CLK_ENABLE();                        /* 使能TIM5时钟 */
        __HAL_RCC_GPIOA_CLK_ENABLE();                       /* 开启捕获IO的时钟 */
                                                            
        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);              /* 抢占1，子优先级3 */
        HAL_NVIC_EnableIRQ(TIM5_IRQn);                      /* 开启ITMx中断 */
        
    }
}
 
/* 输入捕获状态(g_timxchy_cap_sta)
 * [7]  :0,没有成功的捕获;1,成功捕获到一次.
 * [6]  :0,还没捕获到高电平;1,已经捕获到高电平了.
 * [5:0]:捕获高电平后溢出的次数,最多溢出63次,所以最长捕获值 = 63*65536 + 65535 = 4194303
 *       注意:为了通用,我们默认ARR和CCRy都是16位寄存器,对于32位的定时器(如:TIM5),也只按16位使用
 *       按1us的计数频率,最长溢出时间为:4194303 us, 约4.19秒
 *
 *      (说明一下：正常32位定时器来说,1us计数器加1,溢出时间:4294秒)
 */
 
uint8_t g_timxchy_cap_sta = 0;              /* 输入捕获状态 */
uint16_t g_timxchy_cap_val = 0;             /* 输入捕获值 */
 
 /* 定时器5中断服务函数 */
void TIM5_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&g_timx_cap_chy_handle);  /* 定时器HAL库共用处理函数 */
}
 
 /* 定时器输入捕获中断处理回调函数 */
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;                  /* 标记成功捕获到一次高电平脉宽 */
                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_FALLING);      /* 配置TIM5通道1上升沿捕获 */
                __HAL_TIM_ENABLE(&g_timx_cap_chy_handle);           /* 使能定时器5 */
            }
        }
    }
}
 
 /* 定时器更新中断回调函数 */
void HAL_TIM_PeriorElapsedCallback(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);  /* 配置TIM5通道1上升沿捕获 */
                    g_timxchy_cap_sta |= 0x80;          /* 标记成功捕获了一次 */
                    g_timxchy_cap_val = 0XFFFF;
                }
                else      /* 累计定时器溢出次数 */
                {
                    g_timxchy_cap_sta++;
                }
            }
        }
    }
}

main.c

extern uint8_t  g_timxchy_cap_sta;  /* 输入捕获状态 */
extern uint16_t g_timxchy_cap_val;  /* 输入捕获值 */
 
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);                     /* 延时初始化 */
    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 *= 65536;                  /* 溢出时间总和 */
            temp += g_timxchy_cap_val;      /* 得到总的高电平时间 */
            printf("HIGH:%d us\r\n", temp); /* 打印总的高点平时间 */
            g_timxchy_cap_sta = 0;          /* 开启下一次捕获*/
        }
 
        t++;
 
        if (t > 20)         /* 200ms进入一次 */
        {
            t = 0;
            LED0_TOGGLE();  /* LED0闪烁 ,提示程序运行 */
        }
        delay_ms(10);
 
        
    }
}

3.6  通用定时器脉冲计数实验（掌握）

3.6.1  脉冲计数实验原理（熟悉）

3.6.2  通用定时器脉冲计数实验配置步骤（掌握）

3.6.3  通用定时器脉冲计数实验（掌握）

tim.c

#include "./BSP/LED/led.h"
#include "tim.h"
 
TIM_HandleTypeDef g_timx_cnt_chy_handle;        /* 定时器x句柄 */
 
 /* 通用定时器通道y 脉冲计数 初始化函数 */
void gtim_timx_cnt_chy_init(uint16_t psc)
{
    TIM_SlaveConfigTypeDef tim_salve_config = {0};
    
    g_timx_cnt_chy_handle.Instance = TIM2;
    g_timx_cnt_chy_handle.Init.Prescaler = psc;
    g_timx_cnt_chy_handle.Init.CounterMode = TIM_COUNTERMODE_UP;
    g_timx_cnt_chy_handle.Init.Period = 65535;
    HAL_TIM_IC_Init(&g_timx_cnt_chy_handle);
    
    tim_salve_config.SlaveMode = TIM_SLAVEMODE_EXTERNAL1;
    tim_salve_config.InputTrigger = TIM_TS_TI1F_ED;
    tim_salve_config.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;
    tim_salve_config.TriggerFilter = 0;
    HAL_TIM_SlaveConfigSynchro(&g_timx_cnt_chy_handle, &tim_salve_config);
 
    HAL_TIM_IC_Start(&g_timx_cnt_chy_handle, TIM_CHANNEL_1);
}
 
/* 定时器 输入捕获 MSP初始化函数 */
void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == TIM2)
    {
        GPIO_InitTypeDef gpio_init_struct;
        __HAL_RCC_GPIOA_CLK_ENABLE();
        __HAL_RCC_TIM2_CLK_ENABLE();
 
        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);
    }
    
}

key.c

#include "key.h"
#include "./SYSTEM/delay/delay.h"
 
/*按键初始化函数*/
 
void key_init(void)
{
    GPIO_InitTypeDef gpio_init_struct;
    KEY0_GPIO_CLK_ENABLE();                                     /* KEY0时钟使能 */
    KEY1_GPIO_CLK_ENABLE();                                     /* KEY1时钟使能 */
    WKUP_GPIO_CLK_ENABLE();                                     /* WKUP时钟使能 */
    
    
    gpio_init_struct.Pin = KEY0_GPIO_PIN;                       /* KEY0引脚 */
    gpio_init_struct.Mode = GPIO_MODE_INPUT;                    /* 输入 */
    gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    HAL_GPIO_Init(KEY0_GPIO_PORT, &gpio_init_struct);           /* KEY0引脚模式设置,上拉输入 */
 
    gpio_init_struct.Pin = KEY1_GPIO_PIN;                       /* KEY1引脚 */
    gpio_init_struct.Mode = GPIO_MODE_INPUT;                    /* 输入 */
    gpio_init_struct.Pull = GPIO_PULLUP;                        /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    HAL_GPIO_Init(KEY1_GPIO_PORT, &gpio_init_struct);           /* KEY1引脚模式设置,上拉输入 */
 
    gpio_init_struct.Pin = WKUP_GPIO_PIN;                       /* WKUP引脚 */
    gpio_init_struct.Mode = GPIO_MODE_INPUT;                    /* 输入 */
    gpio_init_struct.Pull = GPIO_PULLDOWN;                      /* 下拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;              /* 高速 */
    HAL_GPIO_Init(WKUP_GPIO_PORT, &gpio_init_struct);           /* WKUP引脚模式设置,下拉输入 */
 
}
 
/**
 * @brief       按键扫描函数
 * @note        该函数有响应优先级(同时按下多个按键): WK_UP > KEY1 > KEY0!!
 * @param       mode:0 / 1, 具体含义如下:
 *   @arg       0,  不支持连续按(当按键按下不放时, 只有第一次调用会返回键值,
 *                  必须松开以后, 再次按下才会返回其他键值)
 *   @arg       1,  支持连续按(当按键按下不放时, 每次调用该函数都会返回键值)
 * @retval      键值, 定义如下:
 *              KEY0_PRES, 1, KEY0按下
 *              KEY1_PRES, 2, KEY1按下
 *              WKUP_PRES, 4, WKUP按下
 */
uint8_t key_scan(uint8_t mode)
{
    static uint8_t key_up = 1;  /* 按键按松开标志 */
    uint8_t keyval = 0;
 
    if (mode) key_up = 1;       /* 支持连按 */
 
    if (key_up && (KEY0 == 0 || KEY1 == 0 || WK_UP == 1))  /* 按键松开标志为1, 且有任意一个按键按下了 */
    {
        delay_ms(10);           /* 去抖动 */
        key_up = 0;
 
        if (KEY0 == 0)  keyval = KEY0_PRES;
 
        if (KEY1 == 0)  keyval = KEY1_PRES;
 
 
        if (WK_UP == 1) keyval = WKUP_PRES;
    }
    else if (KEY0 == 1 && KEY1 == 1 && WK_UP == 0) /* 没有任何按键按下, 标记按键松开 */
    {
        key_up = 1;
    }
 
    return keyval;              /* 返回键值 */
}
 

main.c

extern TIM_HandleTypeDef g_timx_cnt_chy_handle;        /* 定时器x句柄 */
 
 
int main(void)
{
    uint16_t curcnt;
    uint16_t oldcnt;
    uint8_t key;
    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();                                 /* 初始化按键 */
    gtim_timx_cnt_chy_init(0);
    
    while(1)
    { 
       key = key_scan(0);
        if(key == KEY0_PRES)
        {
            __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);
        
    }
}

4.  高级定时器 （掌握）

4.1  高级定时器简介（了解）

主要特性：

16位递增、递减、中心对齐计数器（计数值：0~65535）
16位预分频器（分频系数：1~65536）
可用于触发DAC、ADC
在更新事件、触发事件、输入捕获、输出比较时，会产生中断/DMA请求
4个独立通道，可用于：输入捕获、输出比较、输出PWM、单脉冲模式
使用外部信号控制定时器且可实现多个定时器互连的同步电路
支持编码器和霍尔传感器电路等
重复计数器
死区时间带可编程的互补输出
断路输入，用于将定时器的输出信号置于用户可选的安全配置中

4.2  高级定时器框图（熟悉）

4.3  高级定时器输出指定个数PWM实验（掌握）

4.3.1  重复计数器特性（熟悉）

4.3.2  高级定时器输出指定个数PWM实验原理（掌握）

4.3.3  高级定时器输出指定个数PWM实验配置步骤（掌握）

相关寄存器：

1.  控制寄存器 1（TIMx_CR1）

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

3.  捕获/比较使能寄存器（TIMx_ CCER）

4.  事件产生寄存器（TIMx_ EGR）

5.  重复计数器寄存器（TIMx_ RCR）

重复计数器寄存器用于设置重复计数器值，因为它具有影子寄存器，所以它本身只是起缓 冲作用。

6.  断路和死区寄存器（TIMx_ BDTR）

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

4.3.4  实战

gtim.c

#include "./BSP/LED/led.h"
#include "tim.h"
 
TIM_HandleTypeDef g_timx_npwm_chy_handle;     /* 定时器x句柄 */
 
static uint8_t g_npwm_remain = 0;
 
  /* 高级定时器TIMX 通道Y 输出指定个数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;                            /* 定时器x */
    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;                 /* 重复计数器初始值 */
    HAL_TIM_PWM_Init(&g_timx_npwm_chy_handle);                         /* 初始化PWM */
    timx_oc_npwm_chy.OCMode = TIM_OCMODE_PWM1;                         /* 模式选择PWM 1*/
    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输出 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.Mode = GPIO_MODE_AF_PP;        /* 推挽式复用功能 */
        gpio_init_struct.Pull = GPIO_PULLUP;            /* 上拉 */
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;  /* 高速 */
        HAL_GPIO_Init(GPIOC, &gpio_init_struct);
        
        HAL_NVIC_SetPriority(TIM8_UP_IRQn, 1, 3);
        HAL_NVIC_EnableIRQ(TIM8_UP_IRQn);
    }
}
  
  /* 高级定时器TIMX NPWM设置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);
}
 
/* 定时器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);
        }
    }
}

main.c

extern TIM_HandleTypeDef g_timx_cnt_chy_handle;        /* 定时器x句柄 */
 
 
int main(void)
{
    uint8_t key;
    uint8_t t = 0;
    GPIO_InitTypeDef gpio_init_struct;
 
    HAL_Init();                         /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
    delay_init(72);                     /* 延时初始化 */
    usart_init(115200);                         /* 串口初始化为115200 */
    led_init();                         /* LED初始化 */
    key_init();                                 /* 初始化按键 */
 
        /* 把PE5设置为输入，避免与PC6冲突 */
    __HAL_RCC_GPIOE_CLK_ENABLE();
    gpio_init_struct.Pin = GPIO_PIN_5;
    gpio_init_struct.Mode = GPIO_MODE_INPUT;                /* 输入 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;          /* 高速 */
    HAL_GPIO_Init(GPIOE, &gpio_init_struct);
    atim_timx_npwm_chy_init(5000 - 1, 7200 - 1);
    
    atim_timx_npwm_chy_set(5);
    
    while (1)
    {
        key = key_scan(0);
        if(key == KEY0_PRES)
        {
            atim_timx_npwm_chy_set(6);
        }
 
        t++;
        delay_ms(10);
 
        if (t > 50)                    /* 控制LED0闪烁, 提示程序运行状态 */
        {
            t = 0;
            LED0_TOGGLE();
        }
    }
}

4.4  高级定时器输出比较模式实验（掌握）

4.4.1  高级定时器输出比较模式实验原理（掌握）

总结：PWM波周期或频率由ARR决定，占空比固定50%，相位由CCRx决定

4.4.2  高级定时器输出比较模式实验配置步骤（掌握）

4.4.3  ，编程实战：高级定时器输出比较模式实验（掌握）

tim.c

#include "./BSP/LED/led.h"
#include "tim.h"
 
/**
* @brief 高级定时器 TIMX 输出比较模式 初始化函数（使用输出比较模式）
* @note
* 配置高级定时器 TIMX 4 路输出比较模式 PWM 输出,实现 50%占空比,不同相位控制
* 注意,本例程输出比较模式,每 2 个计数周期才能完成一个 PWM 输出,因此输出频率减半
* 另外,我们还可以开启中断在中断里面修改 CCRx,从而实现不同频率/不同相位的控制
* 但是我们不推荐这么使用,因为这可能导致非常频繁的中断,从而占用大量 CPU 资源
*
* 高级定时器的时钟来自 APB2, 而 PCLK2 = 72Mhz, 我们设置 PPRE2 不分频, 因此
* 高级定时器时钟 = 72Mhz
* 定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
* Ft=定时器工作频率,单位:Mhz
* @param arr: 自动重装值。
* @param psc: 时钟预分频数
* @retval 无
*/
TIM_HandleTypeDef g_timx_comp_pwm_handle;
 
void atim_timx_comp_pwm_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef timx_oc_comp_pwm = {0};
    TIM_OC_InitTypeDef tim_oc_handle = {0};
    
    g_timx_comp_pwm_handle.Instance = ATIM_TIMX_COMP; /* 定时器 x */
    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.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; /* 使能影子寄存器 TIMx_ARR */
    HAL_TIM_OC_Init(&g_timx_comp_pwm_handle); /* 输出比较模式初始化 */
 
    timx_oc_comp_pwm.OCMode = TIM_OCMODE_TOGGLE; /* 比较输出模式翻转功能 */
    timx_oc_comp_pwm.Pulse = 250 - 1; /* 设置输出比较寄存器的值 */
    timx_oc_comp_pwm.OCPolarity = TIM_OCPOLARITY_HIGH;/* 输出比较极性为高 */
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &timx_oc_comp_pwm, \
    TIM_CHANNEL_1); /* 初始化定时器的输出比较通道 1 */
    
    /* CCR1 寄存器预装载使能 */
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_1);
    tim_oc_handle.Pulse = 500;
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle, \
    TIM_CHANNEL_2); /* 初始化定时器的输出比较通道 2 */
 
    /* CCR2 寄存器预装载使能 */
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_2);
    tim_oc_handle.Pulse = 750;
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle,TIM_CHANNEL_3); /* 初始化定时器的输出比较通道 3 */
    /* CCR3 寄存器预装载使能 */
    __HAL_TIM_ENABLE_OCxPRELOAD(&g_timx_comp_pwm_handle, TIM_CHANNEL_3);
    tim_oc_handle.Pulse = 1000;
    HAL_TIM_OC_ConfigChannel(&g_timx_comp_pwm_handle, &tim_oc_handle,
    TIM_CHANNEL_4); /* 初始化定时器的输出比较通道 4 */
    /* CCR4 寄存器预装载使能 */ 
    __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);
    
}
 
/**
* @brief 定时器底层驱动，时钟使能，引脚配置
 此函数会被 HAL_TIM_OC_Init()调用
* @param htim:定时器句柄
* @retval 无
*/
void HAL_TIM_OC_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == ATIM_TIMX_COMP)
    {
        GPIO_InitTypeDef gpio_init_struct;
        
        ATIM_TIMX_COMP_CLK_ENABLE();
        
        ATIM_TIMX_COMP_CH1_GPIO_CLK_ENABLE();
        ATIM_TIMX_COMP_CH2_GPIO_CLK_ENABLE();
        ATIM_TIMX_COMP_CH3_GPIO_CLK_ENABLE();
        ATIM_TIMX_COMP_CH4_GPIO_CLK_ENABLE();
        
        gpio_init_struct.Pin = ATIM_TIMX_COMP_CH1_GPIO_PIN;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;
        gpio_init_struct.Pull = GPIO_NOPULL;
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(ATIM_TIMX_COMP_CH1_GPIO_PORT, &gpio_init_struct);
        
        gpio_init_struct.Pin = ATIM_TIMX_COMP_CH2_GPIO_PIN;
        HAL_GPIO_Init(ATIM_TIMX_COMP_CH2_GPIO_PORT, &gpio_init_struct);
        
        gpio_init_struct.Pin = ATIM_TIMX_COMP_CH3_GPIO_PIN;
        HAL_GPIO_Init(ATIM_TIMX_COMP_CH3_GPIO_PORT, &gpio_init_struct);
        
        gpio_init_struct.Pin = ATIM_TIMX_COMP_CH4_GPIO_PIN;
        HAL_GPIO_Init(ATIM_TIMX_COMP_CH4_GPIO_PORT, &gpio_init_struct);
 
    }
    
 
}

mian.c

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初始化 */
    atim_timx_comp_pwm_init(1000 - 1, 72 - 1); /* 1Mhz 的计数频率 1Khz 的周期. */
    ATIM_TIMX_COMP_CH1_CCRX = 250 - 1; /* 通道 1 相位 25% */
    ATIM_TIMX_COMP_CH2_CCRX = 500 - 1; /* 通道 2 相位 50% */
    ATIM_TIMX_COMP_CH3_CCRX = 750 - 1; /* 通道 3 相位 75% */
    ATIM_TIMX_COMP_CH4_CCRX = 1000 - 1; /* 通道 4 相位 100% */
 
  
    
    while (1)
    {
 
         delay_ms(10);
         t++;
         if (t >= 20)
         {
         LED0_TOGGLE(); /* LED0(RED)闪烁 */
         t = 0;
         }
         
    }
 
}

4.5  高级定时器互补输出带死区控制实验（掌握）

4.5.1  互补输出，还带死区控制，什么意思？（了解）

上图中，CH1 输出黄色的 PWM，它的互补通道 CH1N 输出绿色的 PWM。通过对比，可以 知道这两个 PWM 刚好是反过来的，CH1 的 PWM 为高电平期间，CH1N 的 PWM 则是低电平， 反之亦然，这就是互补输出。

4.5.2  带死区控制的互补输出应用之H桥（了解）

4.5.3  捕获/比较通道的输出部分(通道1至3)（熟悉）

4.5.4  死区时间计算（掌握）

4.5.5  刹车(断路)功能（熟悉）

4.5.6  高级定时器互补输出带死区控制实验配置步骤（掌握）

4.5.7  编程实战：高级定时器互补输出带死区控制实验（掌握）

tim.c

#include "./BSP/LED/led.h"
#include "tim.h"
 
/* @brief 高级定时器 TIMX 互补输出 初始化函数（使用 PWM 模式 1）
* @note
* 配置高级定时器 TIMX 互补输出, 一路 OCy 一路 OCyN, 并且可以设置死区时间
*
* 高级定时器的时钟来自 APB2, 而 PCLK2 = 72Mhz, 我们设置 PPRE2 不分频, 因此
* 高级定时器时钟 = 72Mhz
* 定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
* Ft=定时器工作频率,单位:Mhz
*
* @param arr: 自动重装值。
* @param psc: 时钟预分频数
* @retval 无
*/
 
TIM_OC_InitTypeDef tim_oc_cplm_pwm;
TIM_HandleTypeDef g_timx_cplm_pwm_handle;
TIM_BreakDeadTimeConfigTypeDef g_sbreak_dead_time_config;
 
void atim_timx_cplm_pwm_init(uint16_t arr, uint16_t psc)
{
    GPIO_InitTypeDef gpio_init_struct = {0};
    TIM_OC_InitTypeDef tim_oc_cplm_pwm = {0};
    
    ATIM_TIMX_CPLM_CLK_ENABLE(); /* TIMx 时钟使能 */
    ATIM_TIMX_CPLM_CHY_GPIO_CLK_ENABLE(); /* 通道 X 对应 IO 口时钟使能 */
    ATIM_TIMX_CPLM_CHYN_GPIO_CLK_ENABLE(); /* 通道 X 互补通道对应 IO 口时钟使能 */
    ATIM_TIMX_CPLM_BKIN_GPIO_CLK_ENABLE(); /* 通道 X 刹车输入对应 IO 口时钟使能 */
    
    gpio_init_struct.Pin = ATIM_TIMX_CPLM_CHY_GPIO_PIN;
    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(ATIM_TIMX_CPLM_CHY_GPIO_PORT, &gpio_init_struct);
 
    gpio_init_struct.Pin = ATIM_TIMX_CPLM_CHYN_GPIO_PIN;
    HAL_GPIO_Init(ATIM_TIMX_CPLM_CHYN_GPIO_PORT, &gpio_init_struct);
    gpio_init_struct.Pin = ATIM_TIMX_CPLM_BKIN_GPIO_PIN;
    HAL_GPIO_Init(ATIM_TIMX_CPLM_BKIN_GPIO_PORT, &gpio_init_struct);
    
    /* 重映射定时器 IO */
    __HAL_RCC_AFIO_CLK_ENABLE();
    __HAL_AFIO_REMAP_TIM1_ENABLE();
    
    g_timx_cplm_pwm_handle.Instance = ATIM_TIMX_CPLM; /* 定时器 x */
    g_timx_cplm_pwm_handle.Init.Prescaler = psc; /* 定时器预分频系数 */
    g_timx_cplm_pwm_handle.Init.CounterMode = TIM_COUNTERMODE_UP;/* 递增计数 */
    g_timx_cplm_pwm_handle.Init.Period = arr; /* 自动重装载值 */
    /* CKD[1:0] = 10, tDTS = 4 * tCK_INT = Ft / 4 = 18Mhz */
    g_timx_cplm_pwm_handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4;
    g_timx_cplm_pwm_handle.Init.AutoReloadPreload =\
    TIM_AUTORELOAD_PRELOAD_ENABLE; /* 使能影子寄存器 TIMx_ARR */
    HAL_TIM_PWM_Init(&g_timx_cplm_pwm_handle);
 
    tim_oc_cplm_pwm.OCMode = TIM_OCMODE_PWM1; /* PWM 模式 1 */
    tim_oc_cplm_pwm.OCPolarity = TIM_OCPOLARITY_LOW; /* OCy 低电平有效 */
    tim_oc_cplm_pwm.OCNPolarity = TIM_OCNPOLARITY_LOW; /* OCyN 低电平有效 */
    tim_oc_cplm_pwm.OCIdleState = TIM_OCIDLESTATE_SET; /* 当 MOE=0，OCx=1 */
    tim_oc_cplm_pwm.OCNIdleState = TIM_OCNIDLESTATE_SET;/* 当 MOE=0，OCxN=1 */
    HAL_TIM_PWM_ConfigChannel(&g_timx_cplm_pwm_handle, &tim_oc_cplm_pwm,
    ATIM_TIMX_CPLM_CHY);
 
    /* 设置死区参数，开启死区中断 */
    /* 运行模式的关闭输出状态 */
    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; 
    /* 使能 AOE 位，允许刹车结束后自动恢复输出 */
    g_sbreak_dead_time_config.AutomaticOutput = TIM_AUTOMATICOUTPUT_ENABLE;
    HAL_TIMEx_ConfigBreakDeadTime(&g_timx_cplm_pwm_handle,
    &g_sbreak_dead_time_config);
    
    /* 使能 OCy 输出 */
    HAL_TIM_PWM_Start(&g_timx_cplm_pwm_handle, ATIM_TIMX_CPLM_CHY);
    /* 使能 OCyN 输出 */
    HAL_TIMEx_PWMN_Start(&g_timx_cplm_pwm_handle, ATIM_TIMX_CPLM_CHY);
}
 
/**
* @brief 定时器 TIMX 设置输出比较值 & 死区时间
* @param ccr: 输出比较值
* @param dtg: 死区时间
* @arg dtg[7:5]=0xx 时, 死区时间 = dtg[7:0] * tDTS
* @arg dtg[7:5]=10x 时, 死区时间 = (64 + dtg[6:0]) * 2 * tDTS
* @arg dtg[7:5]=110 时, 死区时间 = (32 + dtg[5:0]) * 8 * tDTS
* @arg dtg[7:5]=111 时, 死区时间 = (32 + dtg[5:0]) * 16 * tDTS
* @note tDTS = 1 / (Ft / CKD[1:0]) = 1 / 18M = 55.56ns
* @retval 无
*/
void atim_timx_cplm_pwm_set(uint16_t ccr, uint8_t dtg)
{
    g_sbreak_dead_time_config.DeadTime = dtg; /* 死区时间设置 */
    HAL_TIMEx_ConfigBreakDeadTime(&g_timx_cplm_pwm_handle,
    &g_sbreak_dead_time_config); /*重设死区时间*/
    __HAL_TIM_MOE_ENABLE(&g_timx_cplm_pwm_handle); /* MOE=1,使能主输出 */
    ATIM_TIMX_CPLM_CHY_CCRY = ccr; /* 设置比较寄存器 */
}
 

tim.h

#ifndef __TIM_H__
#define __TIM_H__
 
#include "./SYSTEM/sys/sys.h"
#include "stm32f1xx_hal_gpio_ex.h"
 
/* TIMX 互补输出模式 定义
* 这里设置互补输出相关硬件配置, CHY 即正常输出, CHYN 即互补输出
* 修改 CCRx 可以修改占空比.
* 默认是针对 TIM1
* 注意: 通过修改这些宏定义,可以支持 TIM1/TIM8 定时器, 任意一个 IO 口输出互补 PWM(前提是必须有
互补输出功能)
*/
/* 输出通道引脚 */
#define ATIM_TIMX_CPLM_CHY_GPIO_PORT GPIOE
#define ATIM_TIMX_CPLM_CHY_GPIO_PIN GPIO_PIN_9
#define ATIM_TIMX_CPLM_CHY_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOE_CLK_ENABLE(); \
}while(0) /* PE 口时钟使能 */
/* 互补输出通道引脚 */
#define ATIM_TIMX_CPLM_CHYN_GPIO_PORT GPIOE
#define ATIM_TIMX_CPLM_CHYN_GPIO_PIN GPIO_PIN_8
#define ATIM_TIMX_CPLM_CHYN_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOE_CLK_ENABLE();\
}while(0) /* PE 口时钟使能 */
/* 刹车输入引脚 */
#define ATIM_TIMX_CPLM_BKIN_GPIO_PORT GPIOE
#define ATIM_TIMX_CPLM_BKIN_GPIO_PIN GPIO_PIN_15
#define ATIM_TIMX_CPLM_BKIN_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOE_CLK_ENABLE();\
}while(0) /* PE 口时钟使能 */
 
/* TIMX REMAP 设置
* 因为 PE8/PE9/PE15, 默认并不是 TIM1 的复用功能脚, 必须开启完全重映射, 才可以将: 
TIM1_CH1->PE9; TIM1_CH1N->PE8; TIM1_BKIN->PE15;
* 这样, PE8/PE9/PE15, 才能用作 TIM1 的 CH1N/CH1/BKIN 功能.
* 因此必须实现 ATIM_TIMX_CPLM_CHYN_GPIO_REMAP, 通过 sys_gpio_remap_set 函数设置重映射
* 如果我们使用默认的复用功能输出, 则不用设置重映射, 是可以不需要该函数的! 根据具体需要来实现.
*/
 
 
 /* 互补输出使用的定时器 */
#define ATIM_TIMX_CPLM TIM1 
#define ATIM_TIMX_CPLM_CHY TIM_CHANNEL_1 
#define ATIM_TIMX_CPLM_CHY_CCRY ATIM_TIMX_CPLM->CCR1 
#define ATIM_TIMX_CPLM_CLK_ENABLE() do{ __HAL_RCC_TIM1_CLK_ENABLE(); }while(0) 
 
void atim_timx_cplm_pwm_set(uint16_t ccr, uint8_t dtg);
void atim_timx_cplm_pwm_init(uint16_t arr, uint16_t psc);
 
 
#endif
 

main.c

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初始化 */
    atim_timx_cplm_pwm_init(1000 - 1, 72 - 1); /* 1Mhz 的计数频率 1Khz 的周期. */
    atim_timx_cplm_pwm_set(300, 100); /* 占空比:7:3, 死区时间 100*tDTS */
     while (1)
     {
         delay_ms(10);
         t++;
         if (t >= 20)
         {
            LED0_TOGGLE(); /* LED0(RED)闪烁 */
            t = 0;
         }
     }
}

4.6  高级定时器PWM输入模式实验（掌握）

4.6.1  PWM输入模式工作原理（熟悉）

4.6.2  PWM输入模式时序（熟悉）

4.6.3  高级定时器PWM输入模式实验配置步骤（掌握)

4.6.4  编程实战：高级定时器PWM输入模式实验（掌握）

tim.c

#include "./BSP/TIMER/atim.h"
 
 
TIM_HandleTypeDef g_timx_pwmin_chy_handle;   /* 定时器x句柄 */
 
/* PWM输入状态(g_timxchy_cap_sta)
 * 0,没有成功捕获.
 * 1,已经成功捕获了
 */
uint8_t g_timxchy_pwmin_sta  = 0;   /* PWM输入状态 */
uint16_t g_timxchy_pwmin_psc  = 0;  /* PWM输入分频系数 */
uint32_t g_timxchy_pwmin_hval = 0;  /* PWM的高电平脉宽 */
uint32_t g_timxchy_pwmin_cval = 0;  /* PWM的周期宽度 */
 
/* PWM输入模式 初始化函数，采样时钟频率为72Mhz,精度约13.8ns */
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 输入捕获 中断服务函数，仅TIM1/TIM8有这个函数,其他普通定时器没有这个中断服务函数! */
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;
            }
        }
    }
}

main.c

#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "./BSP/TIMER/atim.h"
#include "./BSP/TIMER/gtim.h"
 
 
extern uint16_t g_timxchy_pwmin_sta;    /* PWM输入状态 */
extern uint16_t g_timxchy_pwmin_psc;    /* PWM输入分频系数 */
extern uint32_t g_timxchy_pwmin_hval;   /* PWM的高电平脉宽 */
extern uint32_t g_timxchy_pwmin_cval;   /* PWM的周期宽度 */
 
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;
        }
    }
}