【STM32】_03_分享个定时器板级驱动包，一个驱动包适用于所有定时器

已于 2024-05-12 14:51:30 修改
阅读量450 收藏
点赞数 12
分类专栏： 嵌入式外设 文章标签： stm32 单片机 嵌入式硬件 笔记 c语言
于 2024-04-06 18:44:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W99BJX/article/details/137434836
版权

前言

笔者使用的是STM32F103系列，使用的是标准库编程，此驱动包，可以实现设置定时器中断，设置PWM输出、PWM互补输出，参考的是安富莱教程。
先贴一个F103系列的时钟树图。对理解后面的程序有帮助。（PS:在CubeMX,可以很容易查到ST系列芯片的最新数据手册）
在这里插入图片描述

废话不多说，直接放源码

#ifndef __TIM_PWM_H
#define __TIM_PWM_H

#include "stm32f10x.h"

static uint32_t get_rcc_gpio(GPIO_TypeDef *GPIOx);
static uint32_t get_rcc_tim(TIM_TypeDef *TIMx);
static void config_tim_gpio(GPIO_TypeDef *GPIOx, uint16_t GPIO_PinX, TIM_TypeDef *TIMx);
static void config_gpio_out(GPIO_TypeDef *GPIOx, uint16_t GPIO_PinX);                            


/* 设置定时器引脚输出PWM */
void set_tim_out_pwm(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, TIM_TypeDef *TIMx, uint8_t _ucChannel,
                      uint32_t _ulFreq, uint32_t _ulDutyCycle);

/* 设置定时器 互补 引脚输出PWM */
void set_tim_out_pwm_n(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, TIM_TypeDef *TIMx, uint8_t _ucChannel,
                        uint32_t _ulFreq, uint32_t _ulDutyCycle);

/* 配置定时器进行简单的定时中断 */
void set_tim_int(TIM_TypeDef *TIMx, uint32_t _ulFreq, uint8_t _PreemptionPriority, uint8_t _SubPriority);



#endif /* __TIM_PWM_H */



/**
******************************************************************************
* @file     tim_pwm.c
* @author   BJX
* @version  V1.0
* @date     2024-04-xx
* @brief    TIM基本定时中断和PWM驱动模块
******************************************************************************
* @attention
*
*   APB1 定时器有 TIM2, TIM3 ,TIM4, TIM5, TIM6, TIM7, TIM12, TIM13, TIM14      ---- 72M
*   APB2 定时器有 TIM1, TIM8 ,TIM9, TIM10, TIM11                               ---- 72M
*
******************************************************************************
*/

#include "./tim/tim_pwm.h"


/**
 * @brief  根据GPIO 得到RCC寄存器
 * @param  GPIOx: 选择GPIO外设
 * @retval GPIO外设时钟名
 */
static uint32_t get_rcc_gpio(GPIO_TypeDef *GPIOx)
{
    uint32_t rcc = 0;

    if (GPIOx == GPIOA)
    {
        rcc = RCC_APB2Periph_GPIOA;
    }
    else if (GPIOx == GPIOB)
    {
        rcc = RCC_APB2Periph_GPIOB;
    }
    else if (GPIOx == GPIOC)
    {
        rcc = RCC_APB2Periph_GPIOC;
    }
    else if (GPIOx == GPIOD)
    {
        rcc = RCC_APB2Periph_GPIOD;
    }
    else if (GPIOx == GPIOE)
    {
        rcc = RCC_APB2Periph_GPIOE;
    }
    else if (GPIOx == GPIOF)
    {
        rcc = RCC_APB2Periph_GPIOF;
    }
    else if (GPIOx == GPIOG)
    {
        rcc = RCC_APB2Periph_GPIOG;
    }

    return rcc;
}

/**
 * @brief  根据TIM 得到RCC寄存器
 * @param  TIMx： 选则TIMX外设
 * @retval TIM外设时钟名
 */
static uint32_t get_rcc_tim(TIM_TypeDef *TIMx)
{
    uint32_t rcc = 0;

    /*
        APB1 定时器有 TIM2, TIM3 ,TIM4, TIM5, TIM6, TIM7, TIM12, TIM13, TIM14
        APB2 定时器有 TIM1, TIM8 ,TIM9, TIM10, TIM11
    */
    if (TIMx == TIM1)
    {
        rcc = RCC_APB2Periph_TIM1;
    }
    else if (TIMx == TIM8)
    {
        rcc = RCC_APB2Periph_TIM8;
    }
    else if (TIMx == TIM9)
    {
        rcc = RCC_APB2Periph_TIM9;
    }
    else if (TIMx == TIM10)
    {
        rcc = RCC_APB2Periph_TIM10;
    }
    else if (TIMx == TIM11)
    {
        rcc = RCC_APB2Periph_TIM11;
    }
    /* 下面是 APB1时钟 */
    else if (TIMx == TIM2)
    {
        rcc = RCC_APB1Periph_TIM2;
    }
    else if (TIMx == TIM3)
    {
        rcc = RCC_APB1Periph_TIM3;
    }
    else if (TIMx == TIM4)
    {
        rcc = RCC_APB1Periph_TIM4;
    }
    else if (TIMx == TIM5)
    {
        rcc = RCC_APB1Periph_TIM5;
    }
    else if (TIMx == TIM6)
    {
        rcc = RCC_APB1Periph_TIM6;
    }
    else if (TIMx == TIM7)
    {
        rcc = RCC_APB1Periph_TIM7;
    }
    else if (TIMx == TIM12)
    {
        rcc = RCC_APB1Periph_TIM12;
    }
    else if (TIMx == TIM13)
    {
        rcc = RCC_APB1Periph_TIM13;
    }
    else if (TIMx == TIM14)
    {
        rcc = RCC_APB1Periph_TIM14;
    }

    return rcc;
}

/**
 * @brief  配置GPIO和TIM时钟， GPIO连接到TIM输出通道
 * @param  GPIOx： 选则GPIOx外设
 * @param  GPIO_PinX 选则GPIOx外设的引脚
 * @param  TIMx： 选则TIMX外设
 * @retval 无
 */
static void config_tim_gpio(GPIO_TypeDef *GPIOx, uint16_t GPIO_PinX, TIM_TypeDef *TIMx)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    /* 使能GPIO时钟 */
    RCC_APB2PeriphClockCmd(get_rcc_gpio(GPIOx), ENABLE);

    /* 使能TIM时钟 */
    if ((TIMx == TIM1) || (TIMx == TIM8))
    {
        RCC_APB2PeriphClockCmd(get_rcc_tim(TIMx), ENABLE);
    }
    else
    {
        RCC_APB1PeriphClockCmd(get_rcc_tim(TIMx), ENABLE);
    }

    /* 配置GPIO */
    GPIO_InitStructure.GPIO_Pin = GPIO_PinX;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; /* 复用功能 */
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOx, &GPIO_InitStructure);
}

/**
 * @brief  配置GPIO为推挽输出。主要用于PWM输出，占空比为0和100的情况。
 * @param  GPIOx： 选则GPIOx外设
 * @param  GPIO_PinX 选则GPIOx外设的引脚
 * @retval 无
 */
static void config_gpio_out(GPIO_TypeDef *GPIOx, uint16_t GPIO_PinX)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    /* 使能GPIO时钟 */
    RCC_APB2PeriphClockCmd(get_rcc_gpio(GPIOx), ENABLE);

    /* 配置GPIO */
    GPIO_InitStructure.GPIO_Pin = GPIO_PinX;         /* 带入的形参 */
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; /* 推挽输出 */
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOx, &GPIO_InitStructure);
}

/**
 * @brief  设置引脚输出的PWM信号的频率和占空比.  当频率为0，并且占空为0时，关闭定时器，GPIO输出0。
 *                                            当频率为0，占空比为100%时，GPIO输出1。
 * @param  GPIOx        选则GPIOx外设
 * @param  GPIO_PinX    选则GPIOx外设的引脚
 * @param  TIMx         选则TIMX外设
 * @param  _ucChannel   选则TIMX外设PWM输出通道
 * @param  _ulFreq      PWM频率    0 表示禁止输出
 * @param  _ulDutyCycle PWM占空比  单位：万分之一。如5000，表示50.00%的占空比
 * @retval 无
 */
void set_tim_out_pwm(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, TIM_TypeDef *TIMx, uint8_t _ucChannel,
                      uint32_t _ulFreq, uint32_t _ulDutyCycle)
{
    uint16_t usPeriod;
    uint16_t usPrescaler;
    uint32_t uiTIMxCLK;
    
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    TIM_OCInitTypeDef TIM_OCInitStructure;
    
    if ((_ulFreq == 0) && (_ulDutyCycle == 0))
    {
        TIM_Cmd(TIMx, DISABLE);                    /* 关闭PWM输出，可能对其它通道有影响 */

        config_gpio_out(GPIOx, GPIO_Pin);          /* 配置GPIO为推挽输出 */
        GPIO_WriteBit(GPIOx, GPIO_Pin, Bit_RESET); /* PWM = 0 */
        return;
    }
    else if ((_ulFreq == 0) && (_ulDutyCycle == 10000))
    {
        TIM_Cmd(TIMx, DISABLE);                  /* 关闭PWM输出 */

        config_gpio_out(GPIOx, GPIO_Pin);        /* 配置GPIO为推挽输出 */
        GPIO_WriteBit(GPIOx, GPIO_Pin, Bit_SET); /* PWM = 1 */
        return;
    }

    config_tim_gpio(GPIOx, GPIO_Pin, TIMx);     /* 使能GPIO和TIM时钟*/

    if ((TIMx == TIM1) || (TIMx == TIM8) || (TIMx == TIM9) || (TIMx == TIM10) || (TIMx == TIM11))
    {
        /* APB2 定时器 */
        uiTIMxCLK = SystemCoreClock;    /* 当系统时钟为 72M 时，APB1、APB2 总线上挂载的时钟都为 72M */
    }
    else /* APB1 定时器 */
    {
        uiTIMxCLK = SystemCoreClock; // SystemCoreClock / 2;
    }

    if (_ulFreq < 100)
    {
        usPrescaler = 10000 - 1;                      /* 分频比 = 10000 */
        usPeriod = (uiTIMxCLK / 10000) / _ulFreq - 1; /* 自动重装的值 */
    }
    else if (_ulFreq < 3000)
    {
        usPrescaler = 100 - 1;                      /* 分频比 = 100 */
        usPeriod = (uiTIMxCLK / 100) / _ulFreq - 1; /* 自动重装的值 */
    }
    else /* 大于4K的频率，无需分频 */
    {
        usPrescaler = 0;                    /* 分频比 = 1 */
        usPeriod = uiTIMxCLK / _ulFreq - 1; /* 自动重装的值 */
    }

    /* 时基配置*/
    TIM_TimeBaseStructure.TIM_Period = usPeriod;                /* 自动重装载寄存器值(周期) */
    TIM_TimeBaseStructure.TIM_Prescaler = usPrescaler;          /* 预分频器 */
    TIM_TimeBaseStructure.TIM_ClockDivision = 0;                /* 时钟分频， */
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; /* 定时器计数方式 */
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;            /* 重复计数器 */
    TIM_TimeBaseInit(TIMx, &TIM_TimeBaseStructure);

    /* PWM1 模式配置：Channel1*/
    TIM_OCStructInit(&TIM_OCInitStructure);                     /* 初始化结构体成员为默认值 */

    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                  /* 比较输出模式 */
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;      /* 比较输出使能 */
    TIM_OCInitStructure.TIM_Pulse = (_ulDutyCycle * usPeriod) / 10000; /* 脉冲宽度)(占空比) */
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;          /* 比较输出极性 */

    /* 仅适用于 TIM1 和 TIM8。*/
    TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Disable; /* 比较互补输出使能. */
    TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;      /* 比较互补输出极性 */
    TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;     /* 空闲状态时通道输出电平设置 */
    TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;   /* 空闲状态时互补通道输出电平设置 */

    if (_ucChannel == 1)
    {
        TIM_OC1Init(TIMx, &TIM_OCInitStructure);
        TIM_OC1PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }
    else if (_ucChannel == 2)
    {
        TIM_OC2Init(TIMx, &TIM_OCInitStructure);
        TIM_OC2PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }
    else if (_ucChannel == 3)
    {
        TIM_OC3Init(TIMx, &TIM_OCInitStructure);
        TIM_OC3PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }
    else if (_ucChannel == 4)
    {
        TIM_OC4Init(TIMx, &TIM_OCInitStructure);
        TIM_OC4PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }

    TIM_ARRPreloadConfig(TIMx, ENABLE);

    /* TIMx 使能计数器*/
    TIM_Cmd(TIMx, ENABLE);

    /* 下面这句话对于TIM1和TIM8是必须的，对于TIM2-TIM6则不必要 */
    if ((TIMx == TIM1) || (TIMx == TIM8))
    {
        TIM_CtrlPWMOutputs(TIMx, ENABLE);
    }
}

/**
 * @brief  设置TIM8_CH1N 等反相引脚输出的PWM信号的频率和占空比. 当频率为0，并且占空为0时，关闭定时器，GPIO输出0。
 *                                            当频率为0，占空比为100%时，GPIO输出1。
 * @param  GPIOx        选则GPIOx外设
 * @param  GPIO_PinX    选则GPIOx外设的引脚
 * @param  TIMx         选则TIMX外设
 * @param  _ucChannel   选则TIMX外设PWM输出通道
 * @param  _ulFreq      PWM频率 单位Hz   0 表示禁止输出
 * @param  _ulDutyCycle PWM占空比 单位：万分之一。如5000，表示50.00%的占空比
 * @retval 无
 */
void set_tim_out_pwm_n(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin, TIM_TypeDef *TIMx, uint8_t _ucChannel,
                        uint32_t _ulFreq, uint32_t _ulDutyCycle)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    TIM_OCInitTypeDef TIM_OCInitStructure;
    uint16_t usPeriod;
    uint16_t usPrescaler;
    uint32_t uiTIMxCLK;

   if ((_ulFreq == 0) && (_ulDutyCycle == 0))
    {
        TIM_Cmd(TIMx, DISABLE);                    /* 关闭PWM输出 */

        config_gpio_out(GPIOx, GPIO_Pin);          /* 配置GPIO为推挽输出 */
        GPIO_WriteBit(GPIOx, GPIO_Pin, Bit_RESET); /* PWM = 0 */
        return;
    }
    else if ((_ulFreq == 0) && (_ulDutyCycle == 10000))
    {
        TIM_Cmd(TIMx, DISABLE);                  /* 关闭PWM输出 */

        config_gpio_out(GPIOx, GPIO_Pin);        /* 配置GPIO为推挽输出 */
        GPIO_WriteBit(GPIOx, GPIO_Pin, Bit_SET); /* PWM = 1 */
        return;
    }

    config_tim_gpio(GPIOx, GPIO_Pin, TIMx);     /* 使能GPIO和TIM时钟，并连接TIM通道到GPIO */

    if ((TIMx == TIM1) || (TIMx == TIM8) || (TIMx == TIM9) || (TIMx == TIM10) || (TIMx == TIM11))
    {
        /* APB2 定时器 */
        uiTIMxCLK = SystemCoreClock;    /* 当系统时钟为 72M 时，APB1、APB2 总线上挂载的时钟都为 72M */
    }
    else /* APB1 定时器 */
    {
        uiTIMxCLK = SystemCoreClock; // SystemCoreClock / 2;
    }

    if (_ulFreq < 100)
    {
        usPrescaler = 10000 - 1;                      /* 分频比 = 10000 */
        usPeriod = (uiTIMxCLK / 10000) / _ulFreq - 1; /* 自动重装的值 */
    }
    else if (_ulFreq < 3000)
    {
        usPrescaler = 100 - 1;                      /* 分频比 = 100 */
        usPeriod = (uiTIMxCLK / 100) / _ulFreq - 1; /* 自动重装的值 */
    }
    else /* 大于4K的频率，无需分频 */
    {
        usPrescaler = 0;                    /* 分频比 = 1 */
        usPeriod = uiTIMxCLK / _ulFreq - 1; /* 自动重装的值 */
    }

    /* Time base configuration */
    TIM_TimeBaseStructure.TIM_Period = usPeriod;
    TIM_TimeBaseStructure.TIM_Prescaler = usPrescaler;
    TIM_TimeBaseStructure.TIM_ClockDivision = 0;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIMx, &TIM_TimeBaseStructure);

    /* PWM1 模式配置：Channel1*/
    TIM_OCStructInit(&TIM_OCInitStructure); /* 初始化结构体成员 */

    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Disable;  /* 和 set_tim_out_pwm() 不同 */
    TIM_OCInitStructure.TIM_Pulse = (_ulDutyCycle * usPeriod) / 10000;
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

    TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable; /* 仅适用于 TIM1 和 TIM8。*/
    TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;     /* only for TIM1 and TIM8. */
    TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;    /* only for TIM1 and TIM8. */
    TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;  /* only for TIM1 and TIM8. */

    if (_ucChannel == 1)
    {
        TIM_OC1Init(TIMx, &TIM_OCInitStructure);
        TIM_OC1PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }
    else if (_ucChannel == 2)
    {
        TIM_OC2Init(TIMx, &TIM_OCInitStructure);
        TIM_OC2PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }
    else if (_ucChannel == 3)
    {
        TIM_OC3Init(TIMx, &TIM_OCInitStructure);
        TIM_OC3PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }
    else if (_ucChannel == 4)
    {
        TIM_OC4Init(TIMx, &TIM_OCInitStructure);
        TIM_OC4PreloadConfig(TIMx, TIM_OCPreload_Enable);
    }

    TIM_ARRPreloadConfig(TIMx, ENABLE);

    /* TIMx 使能计数器*/
    TIM_Cmd(TIMx, ENABLE);

    /* 下面这句话对于TIM1和TIM8是必须的，对于TIM2-TIM6则不必要 */
    if ((TIMx == TIM1) || (TIMx == TIM8))
    {
        TIM_CtrlPWMOutputs(TIMx, ENABLE);
    }
}

/**
 * @brief  配置TIM和NVIC，用于简单的定时中断. 开启定时中断。 中断服务程序由应用程序实现。
 * @param  TIMx                 选则TIMX外设
 * @param  _ulFreq              定时频率 （Hz）。 0 表示关闭。
 * @param  _PreemptionPriority  抢占优先级
 * @param  _SubPriority         子优先级
 * @retval 无
 */
void set_tim_int(TIM_TypeDef *TIMx, uint32_t _ulFreq, uint8_t _PreemptionPriority, uint8_t _SubPriority)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    uint16_t usPeriod;
    uint16_t usPrescaler;
    uint32_t uiTIMxCLK;

    /* 使能TIM时钟 */
    if ((TIMx == TIM1) || (TIMx == TIM8))
    {
        RCC_APB2PeriphClockCmd(get_rcc_tim(TIMx), ENABLE);
    }
    else
    {
        RCC_APB1PeriphClockCmd(get_rcc_tim(TIMx), ENABLE);
    }

    if (_ulFreq == 0)
    {
        TIM_Cmd(TIMx, DISABLE); /* 关闭定时输出 */

        /* 关闭TIM定时更新中断 (Update) */
        {
            NVIC_InitTypeDef NVIC_InitStructure; /* 中断结构体在 misc.h 中定义 */
            uint8_t irq = 0;                     /* 中断号, 定义在 stm32f10x.h */

            if (TIMx == TIM1)
                irq = TIM1_UP_IRQn;
            else if (TIMx == TIM2)
                irq = TIM2_IRQn;
            else if (TIMx == TIM3)
                irq = TIM3_IRQn;
            else if (TIMx == TIM4)
                irq = TIM4_IRQn;
                
#ifdef STM32F10X_HD     

            else if (TIMx == TIM5)
                irq = TIM5_IRQn;
            else if (TIMx == TIM6)
                irq = TIM6_IRQn;
            else if (TIMx == TIM7)
                irq = TIM7_IRQn;
            else if (TIMx == TIM8)
                irq = TIM8_UP_IRQn;
#endif                

            NVIC_InitStructure.NVIC_IRQChannel = irq;
            NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = _PreemptionPriority;
            NVIC_InitStructure.NVIC_IRQChannelSubPriority = _SubPriority;
            NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
            NVIC_Init(&NVIC_InitStructure);
        }
        return;
    }

    if ((TIMx == TIM1) || (TIMx == TIM8) || (TIMx == TIM9) || (TIMx == TIM10) || (TIMx == TIM11))
    {
        /* APB2 定时器 */
        uiTIMxCLK = SystemCoreClock;    /* 当系统时钟为 72M 时，APB1、APB2 总线上挂载的时钟都为 72M */
    }
    else /* APB1 定时器 .  */
    {
        uiTIMxCLK = SystemCoreClock; // SystemCoreClock / 2;
    }

    if (_ulFreq < 100)
    {
        usPrescaler = 10000 - 1;                      /* 分频比 = 1000 */
        usPeriod = (uiTIMxCLK / 10000) / _ulFreq - 1; /* 自动重装的值 */
    }
    else if (_ulFreq < 3000)
    {
        usPrescaler = 100 - 1;                      /* 分频比 = 100 */
        usPeriod = (uiTIMxCLK / 100) / _ulFreq - 1; /* 自动重装的值 */
    }
    else /* 大于4K的频率，无需分频 */
    {
        usPrescaler = 0;                    /* 分频比 = 1 */
        usPeriod = uiTIMxCLK / _ulFreq - 1; /* 自动重装的值 */
    }

    /* 时基配置*/
    TIM_TimeBaseStructure.TIM_Period = usPeriod;                /* 定时器周期(设定自动重载寄存器 ARR 的值) */
    TIM_TimeBaseStructure.TIM_Prescaler = usPrescaler;          /* 预分频器 */
    TIM_TimeBaseStructure.TIM_ClockDivision = 0;                /* 时钟分频 */
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; /* 计数模式 */
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;            /* 重复计数器（只存在于高级定时器） */

    TIM_TimeBaseInit(TIMx, &TIM_TimeBaseStructure);

    TIM_ARRPreloadConfig(TIMx, ENABLE);

    /* TIM 中断启用*/
    TIM_ITConfig(TIMx, TIM_IT_Update, ENABLE);

    /* TIMx 使能计数器*/
    TIM_Cmd(TIMx, ENABLE);

    /* 配置TIM定时更新中断 (Update) */
    {
        NVIC_InitTypeDef NVIC_InitStructure; /* 中断结构体在 misc.h 中定义 */
        uint8_t irq = 0;                     /* 中断号, 定义在 stm32f10x.h */

        if (TIMx == TIM1)
            irq = TIM1_UP_IRQn;
        else if (TIMx == TIM2)
            irq = TIM2_IRQn;
        else if (TIMx == TIM3)
            irq = TIM3_IRQn;
        else if (TIMx == TIM4)
            irq = TIM4_IRQn;

#ifdef STM32F10X_HD

        else if (TIMx == TIM5)
            irq = TIM5_IRQn;
        else if (TIMx == TIM6)
            irq = TIM6_IRQn;
        else if (TIMx == TIM7)
            irq = TIM7_IRQn;
        else if (TIMx == TIM8)
            irq = TIM8_UP_IRQn;
#endif

        NVIC_InitStructure.NVIC_IRQChannel = irq;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = _PreemptionPriority; /* 抢占优先级 */
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = _SubPriority;               /* 子优先级 */
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);
    }
}

/****************************** END OF FILE ******************************/
W99BJX
关注
  • 12
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
linux定时器驱动
01-05
这是一个Linux下定时器驱动的标准模板,以极其精简的代码讲述最清楚的例子
STM32_EVAL.rar_STM32 板级驱动
09-21
STM32_EVAL.rar 是一个与STM32微控制器相关的资源包，主要包含了STM32的板级驱动程序，尤其关注于基本的IO操作和LED闪烁功能。STM32是一款基于ARM Cortex-M内核的微控制器，由意法半导体（STMicroelectronics）生产...
linux内核驱动之定时器
最新发布
wanghongshuai1的博客
03-17 1221
linux内核驱动之定时器
定时器驱动
sinat_42650353的博客
09-11 404
想要每次进tick的时间相同如，每秒进100次tick： Tick想要100次/秒，那一个tick就是1ms，而系统时钟频率是12 000 000 ； 12 000 000Hz/100Hz, 就是时钟频率除以tick频率，翻译过来就是每秒的时钟滴答次数/每秒的tick次数等于一个tick多少次时钟滴答， 然后计算每秒有多少的纳秒1s = 1 000 000 000ns，除以tick的频率就是一个tick多少ns， 一个tick的 ns数除以一个tick的时钟滴答数就是一个时钟滴答多少ns 一个t.
内核定时器驱动实验
weixin_42482191的博客
05-23 239
本篇文章讲述了内核定时器的使用过程。
linux驱动-定时器
qq_37932504的博客
02-03 1115
1、设置系统节拍率 在编译 Linux 内核的时候可以通过图形化界面设置系统节拍率。 -> Kernel Features -> Timer frequency CONFIG_HZ Linux 内核会使用 CONFIG_HZ 来设置自己的系统时钟。打开文件 include/asm-generic/param.h #undef HZ #define HZ CONFIG_HZ #define USER_HZ 100 #define CLOCKS_PER_SEC (US.....
STM32F407实现高级定时器输出比较驱动【支持STM32F4系列单片机】.zip
02-20
总的来说，STM32F407的高级定时器输出比较驱动程序涉及了定时器的时钟配置、工作模式设置、输出比较模式配置、中断处理等多个方面。通过合理的编程和调试，可以充分利用高级定时器的强大功能，实现精准的定时和控制...
无源蜂鸣器驱动_stm32_驱动定时器_无源蜂鸣器_无源蜂鸣器驱动_
09-28
在STM32中，驱动无源蜂鸣器的关键是配置一个定时器来生成所需的方波信号。STM32内含有多个定时器，如TIM1、TIM2、TIM3等，它们可以工作在多种模式，包括计数器模式、PWM模式等。对于蜂鸣器驱动，我们通常选择PWM模式...
STM32F407实现高级定时器互补输出带死区刹车驱动【支持STM32F4系列单片机】.zip
02-20
本项目主要涉及STM32F407如何利用高级定时器实现互补输出带死区刹车驱动，适用于STM32F4系列单片机的调测和移植。 高级定时器在STM32F407中通常有TIM1和TIM8两个，它们支持多种工作模式，如通用定时器模式、PWM输入...
TIM_test.rar_STM32 TIM_STM32 定时器_TIM_Test
09-21
在“TIM_test.rar_STM32 TIM_STM32 定时器_TIM_Test”这个压缩包中，包含了一个基于STM32的定时器测试程序，该程序设计为可直接移植到STM32系统中，并能方便地调用函数进行操作。 STM32定时器主要有以下几类： 1. *...
驱动中定时器，taskle，工作队列编程
jianjian的博客
11-17 3021
一、定时器 1.内核时间相关转换函数 unsigned long usecs_to_jiffies(const unsigned int u) 功能： 把微秒转换成时钟节拍 参数： u 时间微秒 返回： 对应的时钟节拍数量 unsigned long msecs_to_jiffies(const unsigned int m) 功能： 把毫秒转换成时钟节拍 参数： m 时间毫秒 返回： 对应的...
驱动定时器
My classmates
10-03 461
#include&amp;lt;ntddk.h&amp;gt; KTIMER Ktimer; KDPC Kdpc; LARGE_INTEGER Time; typedef struct MyStruct { int a; }context,*Pcontext; VOID PassObj( __in struct _KDPC *Dpc, __in_opt PVOID DeferredContex...
手把手教你写Linux设备驱动---定时器(一)(基于友善之臂4412开发板)
weixin_34279579的博客
04-02 350
这个专题我们来说下Linux中的定时器。 在Linux内核中，有这样的一个定时器，叫做内核定时器，内核定时器用于控制某个函数，也就是定时器将要处理的函数在未来的某个特定的时间内执行。内核定时器注册的处理函数只执行一次，即不是循环执行的。 如果对延迟的精度要求不高的话，最简单的实现方法如下---忙等待： Unsigned long j = jif...
实现一个简单的定时器驱动代码
jinron10的专栏
03-06 537
屏亮无操作，按键灯5s 后自动熄灭 实现场景： 1）按下按键后检测到按键中断，在中断函数中点亮按键灯并且启动定时器定时五秒，时间到关闭按键灯。 2）当点亮屏幕后，点亮按键灯并且启动定时器定时五秒，时间到关闭按键灯。 @ \kernel\drivers\input\keyboard\aw9523.c #include <linux/jiffies.h>//jiffies调用头文件 #in...
linux驱动之内核定时器驱动设计-- timer
banbenggang9818的博客
11-24 366
定时器在linux内核中主要是采用一个结构体实现的。但是需要注意定时器是一个只运行一次的对象，也就是当一个定时器结束以后，还需要重现添加定时器。但是可以采用mod_timer()函数动态的改变定时器到达时间。这个驱动主要实现内核定时器的基本操作。内核定时器主要是是通过下面的结构体struct timer_list实现。需要的头文件包括#include<linux/timer.h&g...
linux内核定时器驱动一个简单例子
u012590688的专栏
05-28 2339
linux内核定时器  A 使用步骤： 1 定义定时器结构体变量 struct  timer_list    timer; 2  初始化内核定时器 init_timer(struct  timer_list *timer) 3  对timer_list成员变量进一步初始化  timer.function=&fun();  timer.expires
驱动中定时器例子
森子格
05-20 461
驱动代码 #include <linux/module.h> #include <linux/types.h> #include <linux/fs.h> #include <linux/errno.h> #include <linux/mm.h> #include <linux/sched.h> #include &lt...
SylixOS x86 HPET 定时器驱动
stone8761的专栏
01-06 644
HPET(High Precision Event Timer) 俗称高精度定时器，最低时钟频率为10MHZ，而且定义了比较严格的精确度（间隔 >= 1 毫秒的允许 +-0.05% 的误差，间隔 <=100 微妙的允许 +-0.2% 的误差）。x86 架构中一般支持 HPET 定时器。在 HPET 体系结构中规定 32 个定时器组成一个定时器块，最多可支持 8 个块，也就是 256 个定时器。实际设备中可使用的定时器数量可以从相关寄存器中查询。每个定时器均可以单独配置成一个中断。 在 x86
STM32定时器与GPIO配置详解
"这篇文档主要介绍了在STM32单片机中如何开启定时器的时钟信号，并且回顾了流水灯的基本原理以及STM32 GPIO的配置方法。内容包括GPIO的结构体定义、时钟使能、电平翻转速度和不同工作模式的选择。" 在STM32微控制器...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值