STM32hal库学习（F1）-TIMER

定时器概述

软件定时原理

void delay_us(uint32_t us)
{
    us *= 72;
    while(us--);
}
//有明显的缺点：
//延时不精准，
//CPU死等
//例如函数调用压栈出栈需要时间，ARM流水线导致时间不确定，只是大概的延时

定时器定时原理

定时器的核心就是计数器

STM32定时器分类

实时定时器指的是RTC

定时器特性表（F1）

计数器位数0-65535，也就是65536 2^16

常规定时器功能区别

定时器类型	主要功能
基本定时器	没有输入输出通道，常用作时基，即定时功能
通用定时器	具有多路独立通道，可用于输入捕获/输出比较，也可用作时基
高级定时器	除具备通用定时器所有功能外， 还具备带死区控制的互补信号输出、刹车输入等功能 (可用于电机控制、数字电源设计等）

基本定时器

基本定时器简介

基本定时器：

TIM6/TIM7

主要特性：

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

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

可用于触发DAC

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

基本定时器框图

ARR和PSC具有缓冲，转移到影子寄存器才能生效改变后的ARR和PSC.

同时ARR还有一位ARPE专门决定是否有缓冲

缓冲的意思是在更新事件或者中断/DMA请求后生效

简单来说ARR有立即重装载和更新后重装载的区别

这里举个例子充分理解一下缓冲

如果我们让灯亮1s，灭2s，这时我们在1s后改变ARR需要时间执行，这时会导致不精准

那如果我让灯亮1s，灭1s，我们不需要改变ARR，所以也就可以不需要缓冲

STM32定时器计数模式及溢出条件

计数器模式	溢出条件
递增计数模式	CNT==ARR
递减计数模式	CNT==0
中心对齐模式	CNT==ARR-1、CNT==1

递增计数模式实例

递减计数模式实例

中心对齐计数模式实例

定时器相关寄存器

TIMx_CR1 （TIM6和TIM7控制寄存器）

该寄存器用于设置ARR寄存器是否具有缓冲，使能/关闭计数器

TIMx_DIER (TIM6和TIM7 DMA/中断使能寄存器）

该寄存器用于使能更新中断

TIMx_SR (TIM6和TIM7状态寄存器）

该寄存器用于判断是否发生了更新中断，由硬件置1，软件清0

TIMx_CNT（TIM6和TIM7计数器）

该寄存器用于设置计时器初始值，范围：0~65535

TIMx_PSC（TIM6和TIM7预分频器）

该寄存器用于设置预分频系数，范围：0~65535；

实际预分频系数等于PSC+1

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

该寄存器用于设置自动重装载值，范围：0~65535

定时器溢出时间计算方法

定时器中断配置步骤

相关函数介绍

函数	主要寄存器	主要功能
HAL_TIM_Base_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_Base_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_Base_Start_IT()	DIER、CR1	使能更新中断并启动计数器
HAL_TIM_IRQHandler()	SR	定时器中断处理公用函数，处理各种中断
HAL_TIM_PeriodElapsedCallback()	无	定时器更新中断回调函数，由用户重定义

//TIM_HandleTypedef* htim  先打开句柄

//相关结构体
typedef struct 
{ 
    TIM_TypeDef *Instance;            /* 外设寄存器基地址 */  //stm32f103xe.h查找及地址 
    TIM_Base_InitTypeDef Init;        /* 定时器初始化结构体*/
     ...
}TIM_HandleTypeDef;

typedef struct 
{ 
    uint32_t Prescaler;               /* 预分频系数PSC */ 
    uint32_t CounterMode;             /* 计数模式：基本定时器只有一种*/ 
    uint32_t Period;                  /* 自动重载值 ARR */ 
    uint32_t ClockDivision;           /* 时钟分频因子：通用和高级才有 */ 
    uint32_t RepetitionCounter;       /* 重复计数器寄存器的值:高级才有*/ 
    uint32_t AutoReloadPreload;       /* 自动重载预装载使能：设置缓冲ARR*/
} TIM_Base_InitTypeDef;

//Timer.c

#include "Timer.h"
#include "led.h"

TIM_HandleTypeDef Timer6_handler; // 定时器句柄

/* 定时器中断初始化函数 */
void TIM_Init(uint16_t psc, uint16_t arr)
{
    Timer6_handler.Instance = TIM6;      // 基地址：TIM6
    Timer6_handler.Init.Prescaler = psc; // 预分频系数：psc，实际分频系数psc+1；
    Timer6_handler.Init.Period = arr;    // 自动重装载值:arr，计数值为arr+1
    HAL_TIM_Base_Init(&Timer6_handler);  // 初始化实际单元，调用HAL_TIM_Base_MspInit()

    HAL_TIM_Base_Start_IT(&Timer6_handler); // 使能计数器，开启定时器中断
}

/* 定时器基础MSP初始化函数 */
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM6) // 判断是不是定时器6回调
    {
        __HAL_RCC_TIM6_CLK_ENABLE();           // 使能定时器6时钟
        HAL_NVIC_SetPriority(TIM6_IRQn, 1, 3); // 设置TIM6定时器中断，抢占优先级1，响应优先级3
        HAL_NVIC_EnableIRQ(TIM6_IRQn);         // 使能定时器6中断，调用void TIM6_IRQHandler()
    }
}

/* 定时器6中断服务函数 */
void TIM6_IRQHandler()
{
    HAL_TIM_IRQHandler(&Timer6_handler); // 定时器公共处理函数，调用void HAL_TIM_PeriodElapsedCallback(),同时自动清除标志位
}

/* 定时器溢出中断中断回调函数 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM6) // 判断是不是定时器6回调
    {
        LED0 = !LED0; // 中断内容，可以自己写其他的
    }
}

#ifndef __TIMER_H
#define __TIMER_H

#include "sys.h"
void TIM_Init(uint16_t psc, uint16_t arr);

#endif 

//main.c
//本例程是每0.5秒进一次中断然后翻转LED电平，使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//	HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	TIM_Init(7199, 4999);
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "Timer.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16,"YMZ ^_^");
	TIM_Init(7199, 4999);
	while (1)
	{
	}
}

通用定时器

通用定时器简介

通用定时器：

TIM2/TIM3 /TIM4 /TIM5

主要特性：

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

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

可用于触发DAC、ADC

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

4个独立通道，可用于：输入捕获、输出比较、输出PWM、单脉冲模式

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

支持编码器和霍尔传感器电路等

通用定时器框图

时钟源选择

时钟源寄存器设置

计数器时钟选择类型	设置方法
内部时钟(CK_INT)	设置TIMx_SMCR的SMS=000 ,(ECE=0但ECE默认是0,所以不需要配置)
外部时钟模式1： 外部输入引脚(TIx)	设置TIMx_SMCR的SMS=111,(ECE=0,但ECE默认是0,所以不需要配置)
外部时钟模式2： 外部触发输入(ETR)	设置TIMx_SMCR的ECE=1 (或者SMS=111和TS=111,不过这里选择的线路是ETRF） IO口复用
内部触发输入(ITRx)	使用一个定时器作为另一个定时器的预分频器， 如可以配置一个定时器Timer1而作为另一个定时器Timer2的预分频器。 设置可参考STM32F10xxx参考手册_V10（中文版）.pdf，14.3.15节

外部时钟模式1

外部时钟模式2

内部触发输入（ITRx）

使用一个定时器作为另一个定时器的预分频器

通用定时器PWM输出

框图

捕获/比较通道1的主电路---输出部分

捕获/比较通道的输出部分

PWM输出原理

PWM配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_PWM_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_PWM_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_PWM_ConfigChannel()	CCMRx、CCRx、CCER	配置PWM模式、比较值、输出极性等
HAL_TIM_PWM_Start()	CCER、CR1	使能输出比较并启动计数器
__HAL_TIM_SET_COMPARE()	CCRx	修改比较值
__HAL_TIM_ENABLE_OCxPRELOAD()	CCER	使能通道预装载

//相关结构体
typedef struct 
{ 
   uint32_t OCMode; 	  /* 输出比较模式选择 */
   uint32_t Pulse; 	      /* 设置比较值 */
   uint32_t OCPolarity;   /* 设置输出比较极性 */
   uint32_t OCNPolarity;  /* 设置互补输出比较极性 */
   uint32_t OCFastMode;   /* 使能或失能输出比较快速模式 */
   uint32_t OCIdleState;  /* 空闲状态下OC1输出 */
   uint32_t OCNIdleState; /* 空闲状态下OC1N输出 */ 
} TIM_OC_InitTypeDef;

//PWM.c
#include "PWM.h"

uint16_t ledrpwmval = 0;
uint8_t dir = 1;

TIM_HandleTypeDef Tim_PWM_Handler; // 定时器时基单元句柄
TIM_OC_InitTypeDef TIM_OC_Handler; // 定时器输出句柄
void PWM_Init(uint16_t psc, uint16_t arr)
{
    Tim_PWM_Handler.Instance = TIM3;                       // 定时器基地址：PWM3
    Tim_PWM_Handler.Init.Prescaler = psc;                  // 定时器预分频系数:psc，实际分频系数：psc+1
    Tim_PWM_Handler.Init.Period = arr;                     // 自动重装载值：arr，实际计数个数:arr+1
    Tim_PWM_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式（通用定时器有三种模式，所以需要选择）
    HAL_TIM_PWM_Init(&Tim_PWM_Handler);                    // 定时器时基单元初始化，调用HAL_TIM_PWM_MspInit

    TIM_OC_Handler.OCMode = TIM_OCMODE_PWM1;                                    // 输出模式：PWM模式1，CNTCCR,无效电平
    TIM_OC_Handler.Pulse = 0;                                             // 比较值：CCR,设置为arr/2，则占空比为50%
    TIM_OC_Handler.OCPolarity = TIM_OCPOLARITY_LOW;                             // 有效电平为低电平
    HAL_TIM_PWM_ConfigChannel(&Tim_PWM_Handler, &TIM_OC_Handler, TIM_CHANNEL_2); // 定时器PWM通道配置函数

    HAL_TIM_PWM_Start(&Tim_PWM_Handler, TIM_CHANNEL_2); // 使能输出并启动计数器
}

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM3) // 判断基地址是不是TIM3
    {
        GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化句柄

        __HAL_RCC_TIM3_CLK_ENABLE();  // 使能定时器3时钟
        __HAL_RCC_GPIOB_CLK_ENABLE(); // 使能GPIOB的时钟

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;       // PB5复用定时器3通道2
        GPIO_InitStructure.Pin = GPIO_PIN_5;             // PB5
        GPIO_InitStructure.Pull = GPIO_PULLUP;           // 上拉,这里随便配置不影响
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
        HAL_GPIO_Init(GPIOB,&GPIO_InitStructure);              // GPIO初始化

        __HAL_RCC_AFIO_CLK_ENABLE();    // 使用复用功能IO
        __HAL_AFIO_REMAP_TIM3_PARTIAL(); // 使能AFIO到TIM3的重映射
    }
}

void TIM_PWM_LED_Breath()
{
    delay_ms(5);
    if (dir)
        ledrpwmval++; /* dir==1 ledrpwmval递增 */
    else
        ledrpwmval--; /* dir==0 ledrpwmval递减 */

    if (ledrpwmval ==500)
        dir = 0; /* ledrpwmval到达300后，方向为递减 */
    if (ledrpwmval == 0)
        dir = 1; /* ledrpwmval递减到0后，方向改为递增 */
    /* 修改比较值控制占空比 */
    __HAL_TIM_SET_COMPARE(&Tim_PWM_Handler, TIM_CHANNEL_2, ledrpwmval);
}

//PWM.h
#ifndef __PWM_H
#define __PWM_H

#include "sys.h"
#include "delay.h"
void PWM_Init(uint16_t psc, uint16_t arr);
void TIM_PWM_LED_Breath();

#endif 

//main.c
//本例程是2KHZ PWM输出PB5，使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//	HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	PWM_Init(72 - 1, 500 - 1);		// psc：71，实际分频系数72，arr：499，实际计数个数500；
									// 计数频率72M/72=1M
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "PWM.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	PWM_Init(72 - 1, 500 - 1);		// psc：71，实际分频系数72，arr：499，实际计数个数500；
									// 计数频率72M/72=1M
									// PWM波频率：1M/500=2000HZ
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");
	while (1)
	{
		TIM_PWM_LED_Breath();//调用呼吸灯函数
	}
}

输入捕获

框图

捕获/比较通道的输入部分

捕获/比较通道的主电路

输入捕获脉宽测量原理

输入捕获配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_IC_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_IC_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_IC_ConfigChannel()	CCMRx、CCER	配置通道映射、捕获边沿、分频、滤波等
__HAL_TIM_ENABLE_IT()	DIER	使能更新中断等
HAL_TIM_IC_Start_IT()	CCER、DIER、CR1	使能输入捕获、捕获中断并启动计数器
HAL_TIM_IRQHandler()	SR	定时器中断处理公用函数，处理各种中断
HAL_TIM_PeriodElapsedCallback()	无	定时器更新中断回调函数，由用户重定义
HAL_TIM_IC_CaptureCallback()	无	定时器输入捕获回调函数，由用户重定义

//相关结构体
typedef struct
{ 
    uint32_t ICPolarity;       /* 输入捕获触发方式选择，比如上升、下降沿捕获 */ 
    uint32_t ICSelection;      /* 输入捕获选择，用于设置映射关系 */ 
    uint32_t ICPrescaler;      /* 输入捕获分频系数 */ 
    uint32_t ICFilter;         /* 输入捕获滤波器设置 */ 
} TIM_IC_InitTypeDef;

//IC.c
#include "IC.h"

TIM_HandleTypeDef TIM_IC_Handler;        // 定时器实际单元句柄
TIM_IC_InitTypeDef TIM_IC_InitStructure; // 定时器输入捕获句柄

void IC_Init(uint16_t psc, uint16_t arr)
{
    TIM_IC_Handler.Instance = TIM5;                       // 定时器基地址：TIM5
    TIM_IC_Handler.Init.Prescaler = psc;                  // 预分频系数：psc；分频系数psc+1
    TIM_IC_Handler.Init.Period = arr;                     // 自动重装载值：arr，实际计数值arr+1
    TIM_IC_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式
    HAL_TIM_IC_Init(&TIM_IC_Handler);                     // 定时器时基单元初始化，调用HAL_TIM_IC_MspInit()

    TIM_IC_InitStructure.ICPolarity = TIM_ICPOLARITY_RISING;                         // 上升沿捕获
    TIM_IC_InitStructure.ICPrescaler = TIM_ICPSC_DIV1;                               // 捕获信号不分频
    TIM_IC_InitStructure.ICSelection = TIM_ICSELECTION_DIRECTTI;                     // 通道映射TI1FP1
    TIM_IC_InitStructure.ICFilter = 0;                                               // 不滤波
    HAL_TIM_IC_ConfigChannel(&TIM_IC_Handler, &TIM_IC_InitStructure, TIM_CHANNEL_1); // 定时器输入捕获通道配置

    __HAL_TIM_ENABLE_IT(&TIM_IC_Handler, TIM_IT_UPDATE);
    HAL_TIM_IC_Start_IT(&TIM_IC_Handler, TIM_CHANNEL_1);
}

void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM5) // 判断基地址是不是TIM5
    {
        __HAL_RCC_TIM5_CLK_ENABLE();  // 使能TIM5
        __HAL_RCC_GPIOA_CLK_ENABLE(); // 使能GPIOA

        GPIO_InitTypeDef GPIO_InitStructure;             // GPIO初始化句柄
        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;       // 复用推挽输出模式，这里注意只要是复用模式都行
        GPIO_InitStructure.Pin = GPIO_PIN_0;             // PA0
        GPIO_InitStructure.Pull = GPIO_PULLDOWN;         // 下拉，由于PA0按键一端接3.3，所以另一端接下拉电阻
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
        HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);       // GPIO初始化

        HAL_NVIC_SetPriority(TIM5_IRQn, 1, 3); // 设置TIM5中断，抢占1，响应3
        HAL_NVIC_EnableIRQ(TIM5_IRQn);         // 使能TIM5中断
    }
}

void TIM5_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&TIM_IC_Handler); // 调用中断公共处理函数，自动清除标志位，
    // 且会调用HAL_TIM_IC_CaptureCallback()捕获中断
    //  HAL_TIM_PeriodElapsedCallback()溢出中断
}

/* 输入捕获状态(IC_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 IC_sta = 0;  /* 输入捕获状态 */
uint16_t IC_val = 0; /* 输入捕获值 */
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM5) // 判断基地址是不是TIM5
    {
        if ((IC_sta & 0X80) == 0) /* 还没有成功捕获 */
        {
            if (IC_sta & 0X40) /*[6]=1捕获到一个下降沿 */
            {
                IC_sta |= 0X80;                                                                 /* 标记成功捕获到一次高电平脉宽 */
                IC_val = HAL_TIM_ReadCapturedValue(&TIM_IC_Handler, TIM_CHANNEL_1);             /* 获取当前的捕获值 */
                TIM_RESET_CAPTUREPOLARITY(&TIM_IC_Handler, TIM_CHANNEL_1);                      /* 一定要先清除原来的设置 */
                TIM_SET_CAPTUREPOLARITY(&TIM_IC_Handler, TIM_CHANNEL_1, TIM_ICPOLARITY_RISING); /* 配置TIM5通道1上升沿捕获 */
            }
            else /* 还未开始,第一次捕获上升沿 */
            {
                IC_sta = 0; /* 清空 */
                IC_val = 0;
                IC_sta |= 0X40;                                                                  /* 标记捕获到了上升沿 */
                __HAL_TIM_DISABLE(&TIM_IC_Handler);                                              /* 关闭定时器5 */
                __HAL_TIM_SET_COUNTER(&TIM_IC_Handler, 0);                                       /* 定时器5计数器清零 */
                TIM_RESET_CAPTUREPOLARITY(&TIM_IC_Handler, TIM_CHANNEL_1);                       /* 一定要先清除原来的设置！！ */
                TIM_SET_CAPTUREPOLARITY(&TIM_IC_Handler, TIM_CHANNEL_1, TIM_ICPOLARITY_FALLING); /* 定时器5通道1设置为下降沿捕获 */
                __HAL_TIM_ENABLE(&TIM_IC_Handler);                                               /* 使能定时器5 */
            }
        }
    }
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM5)
    {
        if ((IC_sta & 0X80) == 0) /* 还未成功捕获 */
        {
            if (IC_sta & 0X40) /* 已经捕获到高电平了 */
            {
                if ((IC_sta & 0X3F) == 0X3F) /* 高电平太长了 */
                {
                    TIM_RESET_CAPTUREPOLARITY(&TIM_IC_Handler, TIM_CHANNEL_1);                      /* 一定要先清除原来的设置 */
                    TIM_SET_CAPTUREPOLARITY(&TIM_IC_Handler, TIM_CHANNEL_1, TIM_ICPOLARITY_RISING); /* 配置TIM5通道1上升沿捕获 */
                    IC_sta |= 0X80;                                                                 /* 标记成功捕获了一次 */
                    IC_val = 0XFFFF;
                }
                else /* 累计定时器溢出次数 */
                {
                    IC_sta++;
                }
            }
        }
    }
}

void IC_GetTime()
{
    uint32_t temp = 0;
    if (IC_sta & 0X80) /* 成功捕获到了一次高电平 */
    {
        temp = IC_sta & 0X3F;
        temp *= 65536;                  /* 溢出时间总和 */
        temp += IC_val;                 /* 得到总的高电平时间 */
        printf("HIGH:%d us\r\n", temp); /* 打印总的高点平时间 */
        IC_sta = 0;                     /* 开启下一次捕获*/
    }
}

//IC.h
#ifndef __IC_H
#define __IC_H

#include "sys.h"
#include 
void IC_Init(uint16_t psc, uint16_t arr);
void IC_GetTime();

#endif // __IC_H

//main.c
//本例程是1MHZ PA0捕获按键高电平时长，并在串口上打印高电平时长，使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//  HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	delay_init(72);					// 初始化延时函数
//	uart_init(115200);				// 初始化串口
//	LED_Init();						// 初始化LED
//	IC_Init(72 - 1, 65536 - 1);     // psc:72-1,实际分频系数72
								    // arr：65535，实际计数个数65536
								    //以1M频率计数


#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "IC.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");
	IC_Init(72 - 1, 65536 - 1); // psc:72-1,实际分频系数72
								// arr：65535，实际计数个数65536
								//以1M频率计数
	while (1)
	{
		//这里可以LED0每10ms闪烁用来提示程序运行
		IC_GetTime();
		LED0 = !LED0;
		delay_ms(10);
	}
}

脉冲计数

框图

应选择外部时钟模式1

配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_IC_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_IC_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_SlaveConfigSynchro()	SMCR、CCMRx、CCER	配置定时器从模式、触发选择、分频、滤波等
HAL_TIM_IC_Start()	CCER、CR1	使能输入捕获、启动计数器
__HAL_TIM_GET_COUNTER()	CNT	获取计数器当前值
__HAL_TIM_SET_COUNTER()	CNT	设置计数器的值

//相关结构体
typedef struct 
{ 
    uint32_t SlaveMode;         /* 从模式选择 */ 
    uint32_t InputTrigger;      /* 输入触发源选择 */ 
    uint32_t TriggerPolarity;   /* 输入触发极性 */ 
    uint32_t TriggerPrescaler;  /* 输入触发预分频 */ 
    uint32_t TriggerFilter;     /* 输入滤波器设置 */ 
} TIM_SlaveConfigTypeDef;

//IC.c
#include "IC.h"

TIM_HandleTypeDef TIM_IC_Handler;                 // 定时器时基单元句柄
TIM_SlaveConfigTypeDef TIM_SLAVE_ConfigStructure; // 定时器从模式配置句柄

void IC_Init(uint16_t psc, uint16_t arr)
{
    TIM_IC_Handler.Instance = TIM2;                       // 定时器基地址：TIM2
    TIM_IC_Handler.Init.Prescaler = psc;                  // 预分频系数：psc；实际分频系数psc+1
    TIM_IC_Handler.Init.Period = arr;                     // 自动重装载值：arr；实际计数值arr+1
    TIM_IC_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式
    HAL_TIM_IC_Init(&TIM_IC_Handler);                     // 定时器时基单元初始化，回调HAL_TIM_IC_MspInit()

    TIM_SLAVE_ConfigStructure.SlaveMode = TIM_SLAVEMODE_EXTERNAL1;           // 外部时钟模式1
    TIM_SLAVE_ConfigStructure.InputTrigger = TIM_TS_TI1FP1;                  // TI1FP1
    TIM_SLAVE_ConfigStructure.TriggerFilter = 0;                             // 不滤波
    TIM_SLAVE_ConfigStructure.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;  // 上升沿触发
    HAL_TIM_SlaveConfigSynchro(&TIM_IC_Handler, &TIM_SLAVE_ConfigStructure); // 配置TIM从模式

    HAL_TIM_IC_Start(&TIM_IC_Handler, TIM_CHANNEL_1); // 使能输入捕获，计数器
}

void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2) // 判断是不是TIM2
    {
        GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化结构体

        __HAL_RCC_GPIOA_CLK_ENABLE(); // 使能GPIOA时钟
        __HAL_RCC_TIM2_CLK_ENABLE();  // 使能TIM2时钟

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;       // 复用推挽输出，这里只要是复用都行
        GPIO_InitStructure.Pin = GPIO_PIN_0;             // PA0
        GPIO_InitStructure.Pull = GPIO_PULLDOWN;         // 由于PA0一端接3.3V，所以我们这里接下拉电阻
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
        HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);       // GPIO结构体初始化
    }
}

void IC_Pulse_Get_Counter()
{
    static uint16_t Pulse_cnt = 0;    // 每次获得的脉冲数
    static uint16_t Pulse_oldcnt = 0; // 上一次获得的脉冲数
    static uint8_t key = 0;

    key = KEY_Scan(0);
    if (key == KEY0_PRES) // 如果按下KEY0
    {
        __HAL_TIM_SET_COUNTER(&TIM_IC_Handler, 0); // 清除所有脉冲数，重新计数
    }

    Pulse_cnt = __HAL_TIM_GET_COUNTER(&TIM_IC_Handler); // 获得脉冲数
    if (Pulse_oldcnt != Pulse_cnt)                      // 如果这次与上次的脉冲数不同时
    {
        Pulse_oldcnt = Pulse_cnt;           // 将每次获得的脉冲数赋给上一次获得的脉冲数，及时进行下一次的获取
        printf("CNT:%d\r\n", Pulse_oldcnt); //  打印脉冲数
    }
}

//IC.h
#ifndef __IC_H
#define __IC_H

#include "sys.h"
#include "KEY.h"
#include 
void IC_Init(uint16_t psc, uint16_t arr);
void IC_Pulse_Get_Counter();

#endif

//main.c
//本例程是用外部模式1捕获按键KEY_UP的脉冲个数，并在串口上打印脉冲个数，KEY0清除脉冲个数
//使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//  HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	uart_init(115200);				// 初始化串口
//	KEY_Init();						// 按键初始化
//	IC_Init(0, 65535);				// 预分频系数psc，实际分频系数psc+1 1
									// 自动重装载值arr，实际可以记得的脉冲数65536

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "IC.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	KEY_Init();						// 按键初始化
	LCD_Init();						// 初始化LCD FSMC接口
	IC_Init(0, 65535);				// 预分频系数psc，实际分频系数psc+1 1
									// 自动重装载值arr，实际可以记得的脉冲数65536
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");

	while (1)
	{
		IC_Pulse_Get_Counter();
	}
}

高级定时器

高级定时器简介

高级定时器：

TIM1/TIM8

主要特性：

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

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

可用于触发DAC、ADC

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

4个独立通道，可用于：输入捕获、输出比较、输出PWM、单脉冲模式

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

支持编码器和霍尔传感器电路等

重复计数器

死区时间带可编程的互补输出

断路输入，用于将定时器的输出信号置于用户可选的安全配置中

高级定时器框图：

重复计数器的特性

输出指定个数PWM

框图

配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_PWM_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_PWM_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_PWM_ConfigChannel()	CCMRx、CCRx、CCER	配置PWM模式、比较值、输出极性等
__HAL_TIM_ENABLE_IT()	CCER	使能更新中断等
HAL_TIM_PWM_Start()	CCER、CR1	使能输出、主输出、启动计数器
HAL_TIM_IRQHandler()	SR	定时器中断处理公用函数，处理各种中断
HAL_TIM_PeriodElapsedCallback()	无	定时器更新中断回调函数，由用户重定义
HAL_TIM_GenerateEvent()	EGR	通过软件产生事件
__HAL_TIM_ENABLE()	CR1	启动计数器

//相关结构体
typedef struct 
{ 
   uint32_t OCMode; 	  /* 输出比较模式选择 */
   uint32_t Pulse; 	      /* 设置比较值 */
   uint32_t OCPolarity;   /* 设置输出比较极性 */
   uint32_t OCNPolarity;  /* 设置互补输出比较极性 */
   uint32_t OCFastMode;   /* 使能或失能输出比较快速模式 */
   uint32_t OCIdleState;  /* 空闲状态下OC1输出 */
   uint32_t OCNIdleState; /* 空闲状态下OC1N输出 */ 
} TIM_OC_InitTypeDef;

//PWM.c
#include "PWM.h"

TIM_HandleTypeDef TIM_PWM_Handler;       // 定时器时基单元初始化句柄
TIM_OC_InitTypeDef TIM_OC_InitStructure; // 定时器输出比较结构体

void PWM_Init(uint16_t psc, uint16_t arr)
{
    TIM_PWM_Handler.Instance = TIM8;                       // 定时器基地址：TIM8
    TIM_PWM_Handler.Init.Prescaler = psc;                  // 预分频系数psc，实际分频系数psc+1
    TIM_PWM_Handler.Init.Period = arr;                     // 自动重装载值arr，实际计数值arr+1
    TIM_PWM_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式
    TIM_PWM_Handler.Init.RepetitionCounter = 0;            // 重复计数器值先初始化为0
    HAL_TIM_PWM_Init(&TIM_PWM_Handler);                    // 定时器时基单元初始化，回调HAL_TIM_PWM_MspInit()

    TIM_OC_InitStructure.OCMode = TIM_OCMODE_PWM1;                                     // PWM1模式
    TIM_OC_InitStructure.Pulse = arr / 2;                                              // 占空比50%
    TIM_OC_InitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;                             // 有效电平：高电平
    HAL_TIM_PWM_ConfigChannel(&TIM_PWM_Handler, &TIM_OC_InitStructure, TIM_CHANNEL_1); // 定时器输出PWM通道配置

    __HAL_TIM_ENABLE_IT(&TIM_PWM_Handler, TIM_IT_UPDATE); // 使能定时器更新中断
    HAL_TIM_PWM_Start(&TIM_PWM_Handler, TIM_CHANNEL_1);   // 使能PWM输出，主输出，启动计数器
}

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM8) // 判断是不是TIM8
    {
        GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化结构体

        __HAL_RCC_TIM8_CLK_ENABLE();  // 使能TIM8时钟
        __HAL_RCC_GPIOC_CLK_ENABLE(); // 使能GPIOC时钟

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;       // 复用推挽输出模式
        GPIO_InitStructure.Pin = GPIO_PIN_6;             // PC6-TIM8CH1
        GPIO_InitStructure.Pull = GPIO_PULLUP;           // 上拉，这里PWM输出无影响
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
        HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);       // GPIO初始化

        HAL_NVIC_SetPriority(TIM8_UP_IRQn, 1, 3); // 设置TIM8更新中断，抢占优先级1，响应优先级3
        HAL_NVIC_EnableIRQ(TIM8_UP_IRQn);         // 使能TIM8,NVIC中断
    }
}

void TIM8_UP_IRQHandler()
{
    HAL_TIM_IRQHandler(&TIM_PWM_Handler); // 定时器公共处理函数，自动清除标志位，回调HAL_TIM_PeriodElapsedCallback()
}

static uint8_t PWMn_remain = 0;

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM8) // 判断是不是TIM8
    {
        if (PWMn_remain) // 判断PWM执行标志
        {
            TIM8->RCR = PWMn_remain - 1;                                     // 往RCR寄存器写n-1，则会输出n个pwm波
            HAL_TIM_GenerateEvent(&TIM_PWM_Handler, TIM_EVENTSOURCE_UPDATE); // 软件触发更新事件
            __HAL_TIM_ENABLE(&TIM_PWM_Handler);                              // 启动计数器，这里其实可以不需要，因为PWMn_SET()设置时就已经启动了计数器
            PWMn_remain = 0;                                                 // 执行n个PWM波
        }
        else
        {
            TIM8->CR1 &= ~(1 << 0); // 关闭计数器
        }
    }
}

/* 高级定时器TIMX pwmn设置PWM个数函数 */
void PWMn_SET(uint8_t pwmn)
{
    if (pwmn == 0)
        return;
    PWMn_remain = pwmn; // 将pwm个数存到另一个变量
    HAL_TIM_GenerateEvent(&TIM_PWM_Handler, TIM_EVENTSOURCE_UPDATE); // 软件触发更新事件
    __HAL_TIM_ENABLE(&TIM_PWM_Handler); // 启动计数器
}

void PWM_LED_Input()
{
    GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化结构体

    __HAL_RCC_GPIOE_CLK_ENABLE(); // 使能GPIO时钟

    GPIO_InitStructure.Mode = GPIO_MODE_INPUT;       // 输入模式
    GPIO_InitStructure.Pin = GPIO_PIN_5;             // PE5,LED1
    GPIO_InitStructure.Pull = GPIO_PULLUP;           // 上拉，
    GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
    HAL_GPIO_Init(GPIOE, &GPIO_InitStructure);       // GPIO初始化
}

//PWM.h
#ifndef __PWM_H
#define __PWM_H

#include "sys.h"
void PWM_Init(uint16_t psc, uint16_t arr);
void PWMn_SET(uint8_t pwmn);
void PWM_LED_Input();

#endif

//main.c
//本例程是用TIM8 CH1,即PC6,输出指定个数PWM到PE5(LED1),用杜邦线连接,这里注意PE5需要改成输入模式
//使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//  HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	LED_Init();						// 初始化LED
//	KEY_Init();						// 按键初始化
//	PWM_LED_Input();			  // LED1设置输入模式
//	PWM_Init(7200 - 1, 5000 - 1); // 计数频率10000HZ，溢出频率2HZ

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "PWM.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	KEY_Init();						// 按键初始化
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");
	PWM_LED_Input();			  // LED1设置输入模式
	PWM_Init(7200 - 1, 5000 - 1); // 计数频率10000HZ，溢出频率2HZ
	PWMn_SET(5);				  // 设置5个pwm
	uint8_t key;

	while (1)
	{
		key = KEY_Scan(0);
		if (key == KEY0_PRES)//按下KEY0
		{
			PWMn_SET(6);//输出6个PWM
		}

		LED0 = 1;
	}
}

输出比较

框图

这里其实跟PWM差不多，重点是死区控制，互补通道输出

配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_OC_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_OC_MspInit	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_OC_ConfigChannel()	CCMRx、CCRx、CCER	设置输出比较模式、比较值、输出极性等
__HAL_TIM_ENABLE_OCxPRELOAD()	CCMRx	使能通道预装载
HAL_TIM_OC_Start()	CR1、CCER、BDTR	使能输出比较、主输出、启动计数器
__HAL_TIM_SET_COMPARE()	CCRx	修改捕获/比较寄存器的值

typedef struct 
{ 
   uint32_t OCMode; 	  /* 输出比较模式选择 */
   uint32_t Pulse; 	      /* 设置比较值 */
   uint32_t OCPolarity;   /* 设置输出比较极性 */
   uint32_t OCNPolarity;  /* 设置互补输出比较极性 */
   uint32_t OCFastMode;   /* 使能或失能输出比较快速模式 */
   uint32_t OCIdleState;  /* 空闲状态下OC1输出 */
   uint32_t OCNIdleState; /* 空闲状态下OC1N输出 */ 
} TIM_OC_InitTypeDef;

//OC.c
#include "OC.h"

TIM_HandleTypeDef TIM_OC_Handler;        // 定时器时基单元初始化句柄
TIM_OC_InitTypeDef TIM_OC_InitStructure; // 定时器输出比较结构体

void OC_Init(uint16_t psc, uint16_t arr)
{
    TIM_OC_Handler.Instance = TIM8;                       // 定时器：TIM8
    TIM_OC_Handler.Init.Prescaler = psc;                  // 预分频系数：psc，实际分频系数:psc+1
    TIM_OC_Handler.Init.Period = arr;                     // 自动重装载值：arr，实际计数个数:arr+1
    TIM_OC_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式
    HAL_TIM_OC_Init(&TIM_OC_Handler);                     // 定时器时基单元初始化，回调HAL_TIM_OC_MspInit()

    TIM_OC_InitStructure.OCMode = TIM_OCMODE_TOGGLE;//输出模式：翻转
    TIM_OC_InitStructure.Pulse = arr;//CCR:arr
    TIM_OC_InitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;//有效电平：高电平
    HAL_TIM_OC_ConfigChannel(&TIM_OC_Handler, &TIM_OC_InitStructure, TIM_CHANNEL_ALL);//定时器输出通道配置

    __HAL_TIM_ENABLE_OCxPRELOAD(&TIM_OC_Handler, TIM_CHANNEL_ALL);//使能通道预装载

    HAL_TIM_OC_Start(&TIM_OC_Handler, TIM_CHANNEL_ALL);//使能输出，启动计数器
}

void HAL_TIM_OC_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM8)//判断是不是TIM8
    {
        GPIO_InitTypeDef GPIO_InitStructure;//GPIO初始化结构体

        __HAL_RCC_GPIOC_CLK_ENABLE();//使能GPIOC时钟
        __HAL_RCC_TIM8_CLK_ENABLE();//使能TIM8时钟

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;//复用推挽输出
        GPIO_InitStructure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9;//PC6,PC7,PC8,PC9-TIM8CHALL
        GPIO_InitStructure.Pull = GPIO_PULLUP;//上拉，这里随便配置无影响
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;//高速
        HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);//GPIO初始化
    }
}


/*将TIM8四个通道配置成相位25%，50%，75%，100%*/
void OC_SET()
{
    __HAL_TIM_SET_COMPARE(&TIM_OC_Handler, TIM_CHANNEL_1, 250 - 1);
    __HAL_TIM_SET_COMPARE(&TIM_OC_Handler, TIM_CHANNEL_2, 500 - 1);
    __HAL_TIM_SET_COMPARE(&TIM_OC_Handler, TIM_CHANNEL_3, 750 - 1);
    __HAL_TIM_SET_COMPARE(&TIM_OC_Handler, TIM_CHANNEL_4, 1000 - 1);
}

//OC.h
#ifndef __OC_H
#define __OC_H

#include "sys.h"
void OC_Init(uint16_t psc, uint16_t arr);
void OC_SET();

#endif 

//main.c
//本例程是用TIM8 CH1,CH2,CH3,CH4输出频率500HZ,占空比为50%的PWM波，采用翻转模式
//相位分别是25%，50%，75%，100%
//使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//  HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//  OC_Init(72 - 1, 1000 - 1);      // 计数频率1M,溢出频率1000HZ,PWM频率500HZ
//	OC_SET();

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "OC.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");

	OC_Init(72 - 1, 1000 - 1); // 计数频率1M,溢出频率1000HZ,PWM频率500HZ
	OC_SET();
	while (1)
	{
		
	}
}

死区控制

框图

死区时间计算

刹车功能（时钟安全系统）

刹车后

死区应用互补输出H桥

配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_PWM_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_PWM_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_PWM_ConfigChannel()	CCMRx、CCRx、CCER	配置PWM模式、比较值、输出极性等
HAL_TIMEx_ConfigBreakDeadTime()	BDTR	配置刹车功能、死区时间等
HAL_TIM_PWM_Start()	CCER、CR1	使能输出、主输出、启动计数器
HAL_TIMEx_PWMN_Start()	CCER、CR1	使能互补输出、主输出、启动计数器

//相关结构体
typedef struct 
{ 
   uint32_t OCMode; 	  /* 输出比较模式选择 */
   uint32_t Pulse; 	      /* 设置比较值 */
   uint32_t OCPolarity;   /* 设置输出比较极性 */
   uint32_t OCNPolarity;  /* 设置互补输出比较极性 */
   uint32_t OCFastMode;   /* 使能或失能输出比较快速模式 */
   uint32_t OCIdleState;  /* 空闲状态下OCx输出 */
   uint32_t OCNIdleState; /* 空闲状态下OCxN输出 */ 
} TIM_OC_InitTypeDef;

//OC.c
#include "OC.h"

TIM_HandleTypeDef TIM_OC_Handler;              // 定时器时基单元初始化句柄
TIM_OC_InitTypeDef TIM_OC_InitStructure;       // 定时器输出比较结构体
TIM_BreakDeadTimeConfigTypeDef TIM_BDT_Config; // 定时器死区配置句柄

void OC_Init(uint16_t psc, uint16_t arr)
{
    TIM_OC_Handler.Instance = TIM1;                             // 定时器：TIM1
    TIM_OC_Handler.Init.Prescaler = psc;                        // 预分频系数:psc,实际分频系数psc+1
    TIM_OC_Handler.Init.Period = arr;                           // 自动重装载值arr，实际计数个数arr+1
    TIM_OC_Handler.Init.CounterMode = TIM_COUNTERMODE_UP;       // 向上计数模式
    TIM_OC_Handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4; // 时钟分频因子4分频
    HAL_TIM_PWM_Init(&TIM_OC_Handler);                          // 定时器时基单元初始化，回调HAL_TIM_PWM_MspInit()

    TIM_OC_InitStructure.OCMode = TIM_OCMODE_PWM1;                                   // 输出模式：PWM1
    TIM_OC_InitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;                           // OC有效电平：高电平
    TIM_OC_InitStructure.OCNPolarity = TIM_OCNPOLARITY_HIGH;                         // OCN有效电平：高电平
    TIM_OC_InitStructure.OCIdleState = TIM_OCIDLESTATE_RESET;                        // 空闲状态：OC低电平
    TIM_OC_InitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;                      // 空闲状态：OCN低电平
    HAL_TIM_OC_ConfigChannel(&TIM_OC_Handler, &TIM_OC_InitStructure, TIM_CHANNEL_1); // 定时器输出配置

    TIM_BDT_Config.OffStateIDLEMode = TIM_OSSI_DISABLE;              // 空闲状态下关闭输出不使能
    TIM_BDT_Config.OffStateRunMode = TIM_OSSR_DISABLE;               // 运行状态下关闭输出不使能
    TIM_BDT_Config.LockLevel = TIM_LOCKLEVEL_OFF;                    // 不使用寄存器锁存功能
    TIM_BDT_Config.BreakPolarity = TIM_BREAKPOLARITY_HIGH;           // 刹车信号高电平
    TIM_BDT_Config.BreakState = TIM_BREAK_ENABLE;                    // 刹车使能
    TIM_BDT_Config.AutomaticOutput = TIM_AUTOMATICOUTPUT_ENABLE;     // AOE位，允许刹车结束后自动恢复输出
    HAL_TIMEx_ConfigBreakDeadTime(&TIM_OC_Handler, &TIM_BDT_Config); // 死区配置
}

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM1) // 判断是不是TIM1
    {
        GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化结构体

        __HAL_RCC_GPIOE_CLK_ENABLE(); // 使能GPIOE时钟
        __HAL_RCC_TIM1_CLK_ENABLE();  // 使能TIM1时钟

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;                      // 复用推挽模式
        GPIO_InitStructure.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_15; // PE8:TIM1_CH1N PE9:TIM1_CH1 PE15:TIM1_BKIN
        GPIO_InitStructure.Pull = GPIO_PULLDOWN;                        // 下拉，我配置了刹车信号高电平，所以选取下拉
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;                // 高速
        HAL_GPIO_Init(GPIOE, &GPIO_InitStructure);                      // GPIO结构体初始化
    }
}

/**
 * @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 TIM_SET(uint16_t ccr, uint8_t dtg)
{
    __HAL_TIM_SET_COMPARE(&TIM_OC_Handler, TIM_CHANNEL_1, ccr);      // 设置CCR
    TIM_BDT_Config.DeadTime = dtg;                                   // 设置死区时间
    HAL_TIMEx_ConfigBreakDeadTime(&TIM_OC_Handler, &TIM_BDT_Config); // 死区配置
}

//OC.h
#ifndef __OC_H
#define __OC_H

#include "sys.h"
void OC_Init(uint16_t psc, uint16_t arr);
void TIM_SET(uint16_t ccr, uint8_t dtg);

#endif 

//main.c
//本例程是用TIM1,CH1,CH1N死区控制输出5.56us死区时间，占空比70%
//使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//  HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	OC_Init(72 - 1, 1000 - 1);      //计数频率1M，溢出频率1000HZ

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "OC.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");

	OC_Init(72 - 1, 1000 - 1);//计数频率1M，溢出频率1000HZ
	TIM_SET(700 - 1, 100);//CCR:700:占空比：70%，死区时间5.56us

	while (1)
	{
		LED0 = 1;
	}
}

PWM输入模式

框图

输入模式时序

配置步骤

相关库函数

函数	主要寄存器	主要功能
HAL_TIM_IC_Init()	CR1、ARR、PSC	初始化定时器基础参数
HAL_TIM_IC_MspInit()	无	存放NVIC、CLOCK、GPIO初始化代码
HAL_TIM_IC_ConfigChannel()	CCMRx、CCER	配置通道映射、捕获边沿、分频、滤波等
HAL_TIM_SlaveConfigSynchro()	SMCR、CCER	配置从模式、触发源、触发边沿等
HAL_TIM_IC_Start_IT()	CCER、DIER、CR1	使能输入捕获、捕获中断并启动计数器
HAL_TIM_IRQHandler()	SR	定时器中断处理公用函数，处理各种中断
HAL_TIM_IC_CaptureCallback()	无	定时器输入捕获回调函数，由用户重定义

//相关结构体
typedef struct
{ 
    uint32_t ICPolarity;    /* 输入捕获触发方式选择，比如上升、下降沿捕获 */ 
    uint32_t ICSelection;   /* 输入捕获选择，用于设置映射关系 */ 
    uint32_t ICPrescaler;   /* 输入捕获分频系数 */ 
    uint32_t ICFilter;      /* 输入捕获滤波器设置 */ 
} TIM_IC_InitTypeDef;


typedef struct 
{ 
    uint32_t SlaveMode;         /* 从模式选择 */ 
    uint32_t InputTrigger;      /* 输入触发源选择 */ 
    uint32_t TriggerPolarity;   /* 输入触发极性 */ 
    uint32_t TriggerPrescaler;  /* 输入触发预分频 */ 
    uint32_t TriggerFilter;     /* 输入滤波器设置 */ 
} TIM_SlaveConfigTypeDef;

//PWM.c
#include "PWM.h"

TIM_HandleTypeDef TIM_PWM_Handler;       // 定时器时基单元初始化句柄
TIM_OC_InitTypeDef TIM_OC_InitStructure; // 定时器输出初始化结构体

void PWM_Init(uint16_t psc, uint16_t arr)
{
    TIM_PWM_Handler.Instance = TIM3;                       // 定时器：TIM3
    TIM_PWM_Handler.Init.Prescaler = psc;                  // 预分频系数：psc,实际分频系数psc+1
    TIM_PWM_Handler.Init.Period = arr;                     // 自动重装载值：arr，实际计数个数：arr+1
    TIM_PWM_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式
    HAL_TIM_PWM_Init(&TIM_PWM_Handler);                    // 定时器时基单元初始化，回调HAL_TIM_PWM_MspInit()

    TIM_OC_InitStructure.Pulse = arr / 2;                                              // CCR:arr/2 占空比50%PWM
    TIM_OC_InitStructure.OCMode = TIM_OCMODE_PWM1;                                     // PWM1模式
    TIM_OC_InitStructure.OCPolarity = TIM_OCPOLARITY_LOW;                              // 有效电平：低电平
    HAL_TIM_PWM_ConfigChannel(&TIM_PWM_Handler, &TIM_OC_InitStructure, TIM_CHANNEL_2); // 定时器PWM通道配置

    HAL_TIM_PWM_Start(&TIM_PWM_Handler, TIM_CHANNEL_2); // 使能PWM输出，开启计数器
}

void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM3) // 判断是不是TIM3
    {
        GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化结构体

        __HAL_RCC_GPIOB_CLK_ENABLE(); // 使能GPIOB时钟
        __HAL_RCC_TIM3_CLK_ENABLE();  // 使能TIM3时钟

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;       // 复用推挽输出
        GPIO_InitStructure.Pin = GPIO_PIN_5;             // PB5——TIM3 CH2
        GPIO_InitStructure.Pull = GPIO_PULLUP;           // 上拉，这里随便配置
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
        HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);       // GPIO初始化

        __HAL_RCC_AFIO_CLK_ENABLE();     // 使能AFIO
        __HAL_AFIO_REMAP_TIM3_PARTIAL(); // 将TIM3CH2重映射到PB5
    }
}

//PWM.h
#ifndef __PWM_H
#define __PWM_H

#include "sys.h"
void PWM_Init(uint16_t psc, uint16_t arr);

#endif 

//IC.c
#include "IC.h"

TIM_HandleTypeDef TIM_IC_Handler;        // 定时器时基单元初始化句柄
TIM_SlaveConfigTypeDef TIM_Slaveconfig;  // 定时器从模式配置句柄
TIM_IC_InitTypeDef TIM_IC_InitStructure; // 定时器输入捕获结构体

/* PWM输入状态(PWM_sta)
 * 0,没有成功捕获.
 * 1,已经成功捕获了
 */
uint8_t PWM_sta = 0;   /* PWM输入状态 */
uint16_t PWM_psc = 0;  /* PWM输入分频系数 */
uint32_t PWM_hval = 0; /* PWM的高电平脉宽 */
uint32_t PWM_cval = 0; /* PWM的周期宽度 */
double ht, ct, f, tpsc;

/* PWM输入模式 初始化函数，采样时钟频率为72Mhz,精度约13.8ns,采样最长PWM周期910.2us*/
void IC_Init()
{
    TIM_IC_Handler.Instance = TIM8;                       // 定时器:TIM8
    TIM_IC_Handler.Init.Prescaler = 0;                    // 不分频，频率越高，采样精度越高
    TIM_IC_Handler.Init.Period = 65535;                   // 自动重装载值设置最大，可采样周期保证尽可能大
    TIM_IC_Handler.Init.CounterMode = TIM_COUNTERMODE_UP; // 向上计数模式
    HAL_TIM_IC_Init(&TIM_IC_Handler);                     // 定时器时基单元初始化，回调HAL_TIM_IC_MspInit()

    TIM_Slaveconfig.SlaveMode = TIM_SLAVEMODE_RESET;               // 从模式：复位模式
    TIM_Slaveconfig.InputTrigger = TIM_TS_TI1FP1;                  // TI1FP1
    TIM_Slaveconfig.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;  // 上升沿触发
    TIM_Slaveconfig.TriggerFilter = 0;                             // 不滤波
    HAL_TIM_SlaveConfigSynchro(&TIM_IC_Handler, &TIM_Slaveconfig); // 定时器从模式配置初始化

    TIM_IC_InitStructure.ICPolarity = TIM_ICPOLARITY_RISING;                         // TI1FP1捕获上升沿
    TIM_IC_InitStructure.ICSelection = TIM_ICSELECTION_DIRECTTI;                     // TI1FP1
    TIM_IC_InitStructure.ICPrescaler = TIM_ICPSC_DIV1;                               // 不分频
    TIM_IC_InitStructure.ICFilter = 0;                                               // 不滤波
    HAL_TIM_IC_ConfigChannel(&TIM_IC_Handler, &TIM_IC_InitStructure, TIM_CHANNEL_1); // 定时器输入捕获通道1配置

    TIM_IC_InitStructure.ICPolarity = TIM_ICPOLARITY_FALLING;                        // TI1FP2捕获下降沿
    TIM_IC_InitStructure.ICSelection = TIM_ICSELECTION_INDIRECTTI;                   // TI1FP2
    HAL_TIM_IC_ConfigChannel(&TIM_IC_Handler, &TIM_IC_InitStructure, TIM_CHANNEL_2); // 定时器输入捕获通道2配置

    HAL_TIM_IC_Start_IT(&TIM_IC_Handler, TIM_CHANNEL_1); // 定时器通道1使能计数器，启动中断
    HAL_TIM_IC_Start(&TIM_IC_Handler, TIM_CHANNEL_2);    // 定时器通道2使能计数器
}

void HAL_TIM_IC_MspInit(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM8) // 判断是不是TIM8
    {
        GPIO_InitTypeDef GPIO_InitStructure; // GPIO初始化结构体

        __HAL_RCC_GPIOC_CLK_ENABLE(); // 使能GPIOC时钟
        __HAL_RCC_TIM8_CLK_ENABLE();  // 使能TIM8

        GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;       // 复用推挽输出，可以输入
        GPIO_InitStructure.Pin = GPIO_PIN_6;             // PC6,TIM8 CH1
        GPIO_InitStructure.Pull = GPIO_PULLDOWN;         // 下拉
        GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH; // 高速
        HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);       // GPIO初始化

        HAL_NVIC_SetPriority(TIM8_CC_IRQn, 1, 3); // 设置TIM8输入捕获中断优先级，抢占优先级1，响应优先级3
        HAL_NVIC_EnableIRQ(TIM8_CC_IRQn);         // 使能TIM8输入捕获中断
    }
}

void TIM8_CC_IRQHandler()
{
    HAL_TIM_IRQHandler(&TIM_IC_Handler); // 定时器公共处理函数，自动清除标志位，回调HAL_TIM_IC_CaptureCallback()
}

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM8) // 判断是不是TIM8
    {
        if (PWM_sta == 0) // 如果还没有捕获
        {
            if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) // TIM8CH1
            {
                PWM_hval = HAL_TIM_ReadCapturedValue(&TIM_IC_Handler, TIM_CHANNEL_2) + 1 + 1; // 高电平读取通道2
                PWM_cval = HAL_TIM_ReadCapturedValue(&TIM_IC_Handler, TIM_CHANNEL_1) + 1 + 1; // 周期读取通道1
                PWM_sta = 1;                                                                  // 输入捕获标志
            }
        }
    }
}

/* PWM输入模式 重新启动捕获 */
void IC_PWM_REST(void)
{
    INTX_DISABLE(); /* 关闭中断 */

    PWM_sta = 0; /* 清零状态,重新开始检测 */
    PWM_hval = 0;
    PWM_cval = 0;

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

void IC_Show()
{
    if (PWM_sta) /* 捕获了一次数据 */
    {
        printf("\r\n");                                   /* 输出空,另起一行 */
        printf("PWM PSC  :%d\r\n", PWM_psc);              /* 打印分频系数 */
        printf("PWM Hight:%d\r\n", PWM_hval);             /* 打印高电平脉宽 */
        printf("PWM Cycle:%d\r\n", PWM_cval);             /* 打印周期 */
        tpsc = ((double)PWM_psc + 1) / 72;                /* 得到PWM采样时钟周期时间 */
        ht = PWM_hval * tpsc;                             /* 计算高电平时间 */
        ct = PWM_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);           /* 打印频率 */
        IC_PWM_REST();                                    /* 重启PWM输入检测 */
    }
}

//IC.h
#ifndef __IC_H
#define __IC_H

#include "sys.h"
#include 
void IC_Init();
void IC_PWM_REST(void);
void IC_Show();

#endif 

//main.c
//本例程是用TIM3 CH2 PB5输入PWM ,TIM8 CH1 PC6捕获占空比，频率等，并将信息打印出来
//使用的是正点原子F1精英开发板
//我这里调用了很多初始化，但其实如果不考虑其他的
//这里必要的只有
//  HAL_Init();						// 初始化HAL库
//	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
//	uart_init(115200);				// 初始化串口
//	PWM_Init(72 - 1, 10 - 1);       // 计数频率1MHZ.溢出频率10^5
//	TIM3->CCR2 = 3;//占空比70%
//	IC_Init();

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "usmart.h"
#include "KEY.h"
#include "led.h"
#include "lcd.h"
#include "PWM.h"
#include "IC.h"

int main(void)
{
	HAL_Init();						// 初始化HAL库
	Stm32_Clock_Init(RCC_PLL_MUL9); // 设置时钟,72M
	delay_init(72);					// 初始化延时函数
	uart_init(115200);				// 初始化串口
	LED_Init();						// 初始化LED
	LCD_Init();						// 初始化LCD FSMC接口
	usmart_dev.init(84);			// 初始化USMART
	POINT_COLOR = RED;				// 画笔颜色：红色
	LCD_ShowString(30, 50, 200, 16, 16, " YMZ ^_^");

	PWM_Init(72 - 1, 10 - 1); // 计数频率1MHZ.溢出频率10^5
	TIM3->CCR2 = 3;//占空比70%
	IC_Init();
	
	while (1)
	{
		IC_Show();
		LED0 = 1;
	}
}