呼吸灯是灯从渐亮到渐灭周而复始形成的一个效果。由于51没有PWM所以需要定时器模拟PWM才能实现呼吸灯的效果，但是stm32的通用定时器是有PWM模式的，所以不需要再用软件模拟，精准度也高。
本实验用的基于stm32f103C8t6。在PB8引脚上接了一个led, led的另一端接到vcc上。
PB8除了是一个GPIO功能，还有一个复用功能即定时器4的channel 3功能。可以通过参考手册知晓。
一、利用CubeMX生成代码
具体配置就不细说了，这里将TIM4的关键配置标了出来
记得选中PWM 的模式1 和使能比较输出，CH Polarity设置Low 和 High 在呼吸灯这里无影响。
1.1、计数器配置
时钟的溢出配置公式如下：
这里将定时器设置为500ms，即Tout = 500ms，同时PSC = 71，ARR = 499, Tclk = 72MHZ。根据公式计算出Tout = (71 + 1) * (499 + 1) / 72000000 = 500ms。
1.2、main函数代码配置
cpp
int main(void)
{
uint16_t pwmVal = 0;
uint8_t dir = 1;
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_TIM4_Init();
/* USER CODE BEGIN 2 */
// 开启定时器4
HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_3);
while (1)
{
HAL_Delay(1);
if(dir) {
pwmVal ++;
} else {
pwmVal--;
}
if(pwmVal > 500) {
dir = 0;
} else if(pwmVal <= 0) {
dir = 1;
}
__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, pwmVal);
/*
// 常亮
__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 0);
// 常灭
__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 500);
*/
}
}二、PWM分析
输出比较就是通过定时器的外部引脚对外输出控制信号，有八种模式，由寄存器 CCMRx 的位 OCxM[2:0]控制。
- 000：冻结。输出比较寄存器TIMx_CCR1与计数器TIMx_CNT间的比较对OC1REF不起作用；
- 001 ：匹配时设置通道 1 为有效电平。当计数器 TIMx_CNT 的值与TIMx_CCR1相同时，强制OC1REF为高。
- 010 ：匹配时设置通道 1 为无效电平。当计数器 TIMx_CNT 的值与TIMx_CCR1相同时，强制OC1REF为低。
- 011：翻转。当TIMx_CCR1=TIMx_CNT时，翻转OC1REF的电平。
- 100：强制为无效电平。强制OC1REF为低。
- 101：强制为有效电平。强制OC1REF为高。
- 110：PWM模式1－ 在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为有效电平，否则为无效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为无效电(OC1REF=0)，否则为有效电平(OC1REF=1)。
- 111：PWM模式2－ 在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为无效电平，否则为有效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为有效电平，否则为无效电平。
其中 PWM 模式是输出比较中的特例，使用的也最多。在PWM的模式1或2下，会一直进行 TIMx_CNT和TIMx_CCRx的比较。
- PWM中GPIO引脚电平输出是由OCx来决定的而不是由OCxREF来决定的。
- 正常GPIO的引脚电平输出由寄存器ODR来决定的(可以配置BSRR来决定ODR的输出)
下图是捕获/比较的输出阶段：
根据上图可以推出四种结果分别是
2.1、有效电平
PWM模式1
- 在向上计数时，一旦TIMx_CNT < TIMx_CCR1时通道1为有效电平，否则为无效电平；
- 在向下计数时，一旦TIMx_CNT > TIMx_CCR1时通道1为无效电平(OC1REF=0)，否则为有效电平(OC1REF=1)
- TIMx_CCRx > TIMx_ARR时 OCxREF = 1
- TIMx_CCRx = 0时OCxREF = 0
PWM模式2
- 在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为无效电平，否则为有效电平
- 在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为有效电平，否则为无效电平
上图中绿框部分是有效的电平。这里有有效电平是OCxREF 参考电平。
OCx有效电平
手册中还有另外一个描述就是：
The output stage generates an intermediate waveform which is then used for reference:
OCxRef (active high). The polarity acts at the end of the chain.
翻译一下就是：
输出部分产生一个中间波形OCxRef(高有效)作为基准，链的末端决定最终输出信号的极性。
++"链的末端决定最终输出信号的极性"++怎么解释，这个可以通过CCIP位的说明可以看出来。
CC1P : Capture/Compare 1 output polarity
CC1 channel configured as output:
- 0: OC1 active high.
- 1: OC1 active low.
CC1通道作为输出模式
- 当CCIP = 0时，OC1 = 1是有效电平，
- 当CCIP = 1时，OC1 = 0是有效电平
2.2、PWM功能下GPIO引脚输出电平
在参考文档中有这样一个表格：
CCxE = 0时，禁止OCx输出，CCxE = 1时，OCx = OCxREF + Polarity
这里的OCxREF + Polarity是什么意思。这里先说明下这里是xor（异或）的意思。
我们可以从以下分析出：
在参考文档中的TIM1定时器章节有这样一个表格:
红色框中圈住的部分写出了OCx = OCxREF xor CCxP，当然这个表格是在TIM1和TIM8里出现的，像表格中的MOE,OSSI,OSSR,CCxNE,都是在TIM1和TIM8寄存器中存在的，在通用定时器里是没有的。
MOE,OSSI,OSSR存在于TIM1和TIM8寄存器中的BDTR，CCxNP和CCxNE也只存在于TIM1和TIM8定时器中的CCER寄存器。
TIM1和TIM8中的CCER 
通用定时器中的CCER （reserved部分要保持为0，即保持reset时的值）
在通用定时器里面，OSSR 无效, CCxNE = 0, OSSI无效，MOE 无效，所以异或操作还是适用的。
由
- 当CCIP = 0时，OC1 = 1是有效电平，
- 当CCIP = 1时，OC1 = 0是有效电平
和 OCx = OCxREF xor CCxP
得出以下最终结果（绿色部分为有效输出）：
总结：
- 1、PWM的模式用来区分有效电平在哪个区间输出 ，并不能区分是有效电平是高还是低
- 2、有效的电平的输出OCx由CCER寄存器的CCxP位来决定。
- 3、CCxP = 0时（默认），输出与OCxREF相同的波
- 4、CCxP = 1时，输出与OCxREF相反的波
三、代码分析
PWM的主要流程大致如下：
- 初始化TIM4
- 开启TIM4的PWM模式
- 设置CCR1用于动态配置PWM波形的输出
代码主要是根据 定时器4的channel 3 + 向上计数模式 + 500ms 定时周期这个为中心产生的。定时器涉及的寄存器比较多，定时总共有20种寄存器，在PWM输出模式下，用到的其实并不多。涉及的寄存器如下：
CR1 (control register)
CR2 (control register)
SMCR ( slave mode control register**)**
EGR ( event generation register**)**
CCMR ( capture/compare mode register 2**)**
CCER ( capture/compare enable register**)**
下面三个主要用来装载数据和配置无关
CNT ( counter**)**
ARR ( auto-reload register**)**
CCR3 ( capture/compare register 3**)**
3.1、MX_TIM4_Init
函数比较长，大致将功能分了下类，具体函数如下：
cpp
void MX_TIM4_Init(void)
{
// 这里主要是根据功能将寄存器分成几个模块进行配置
// 时钟相关配置
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
// 主从模式配置
TIM_MasterConfigTypeDef sMasterConfig = {0};
// 定时器输出捕获常规配置
TIM_OC_InitTypeDef sConfigOC = {0};
htim4.Instance = TIM4;
htim4.Init.Prescaler = 71;
htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
htim4.Init.Period = 499;
htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
// 1、定时器常规初始化
if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
{
Error_Handler();
}
// 2、定时器时钟配置
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
// 3、定时器PWM初始化
if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
{
Error_Handler();
}
// 4、定时器主从模式配置
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
// 5、定时器channel配置
if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
{
Error_Handler();
}
// 6、定时器主栈地址初始化
HAL_TIM_MspPostInit(&htim4);
}上面主要做了下面几件事
- 1、定时器常规初始化（时基单元相关）
- 2、定时器时钟配置
- 3、定时器PWM初始化
- 4、定时器主从模式配置
- 5、定时器channel配置
- 6、定时器主栈地址初始化（实际上就是使能定时器）
下面主要针对上面的过程进行描述
3.1.1、定时器相关类型
TIM_TypeDef
cpp
typedef struct
{
__IO uint32_t CR1; /*!< TIM control register 1, Address offset: 0x00 */
__IO uint32_t CR2; /*!< TIM control register 2, Address offset: 0x04 */
__IO uint32_t SMCR; /*!< TIM slave Mode Control register, Address offset: 0x08 */
__IO uint32_t DIER; /*!< TIM DMA/interrupt enable register, Address offset: 0x0C */
__IO uint32_t SR; /*!< TIM status register, Address offset: 0x10 */
__IO uint32_t EGR; /*!< TIM event generation register, Address offset: 0x14 */
__IO uint32_t CCMR1; /*!< TIM capture/compare mode register 1, Address offset: 0x18 */
__IO uint32_t CCMR2; /*!< TIM capture/compare mode register 2, Address offset: 0x1C */
__IO uint32_t CCER; /*!< TIM capture/compare enable register, Address offset: 0x20 */
__IO uint32_t CNT; /*!< TIM counter register, Address offset: 0x24 */
__IO uint32_t PSC; /*!< TIM prescaler register, Address offset: 0x28 */
__IO uint32_t ARR; /*!< TIM auto-reload register, Address offset: 0x2C */
__IO uint32_t RCR; /*!< TIM repetition counter register, Address offset: 0x30 */
__IO uint32_t CCR1; /*!< TIM capture/compare register 1, Address offset: 0x34 */
__IO uint32_t CCR2; /*!< TIM capture/compare register 2, Address offset: 0x38 */
__IO uint32_t CCR3; /*!< TIM capture/compare register 3, Address offset: 0x3C */
__IO uint32_t CCR4; /*!< TIM capture/compare register 4, Address offset: 0x40 */
__IO uint32_t BDTR; /*!< TIM break and dead-time register, Address offset: 0x44 */
__IO uint32_t DCR; /*!< TIM DMA control register, Address offset: 0x48 */
__IO uint32_t DMAR; /*!< TIM DMA address for full transfer register, Address offset: 0x4C */
__IO uint32_t OR; /*!< TIM option register, Address offset: 0x50 */
}TIM_TypeDef;TIM_TypeDef 结构体包括了定时器所有的寄存器，通过操作结构体就可以操作寄存器。在初始化的时候有这样一句代码 htim4.Instance = TIM4 这里的TIM4就是定时器4在外设中的地址，TIM4也是一个宏，具体就不展开了，它的定义和 GPIO类似，可参考GPIO，或自行在代码中查看。
TIM_HandleTypeDef
cpp
typedef struct
{
uint32_t Prescaler; // 配置时基单元中的预分频器
uint32_t CounterMode; // 计数模式（向上/向下/中央对齐）
uint32_t Period; // 定时周期（period + 1）
uint32_t ClockDivision; // 时钟分频因子
uint32_t RepetitionCounter; // 重复定时器（高级定时器中用）
uint32_t AutoReloadPreload; // 是否自动重装初值
} TIM_Base_InitTypeDef;HAL_TIM_ActiveChannel （选中的channel）
cpp
typedef enum
{
HAL_TIM_ACTIVE_CHANNEL_1 = 0x01U, /*!< The active channel is 1 */
HAL_TIM_ACTIVE_CHANNEL_2 = 0x02U, /*!< The active channel is 2 */
HAL_TIM_ACTIVE_CHANNEL_3 = 0x04U, /*!< The active channel is 3 */
HAL_TIM_ACTIVE_CHANNEL_4 = 0x08U, /*!< The active channel is 4 */
HAL_TIM_ACTIVE_CHANNEL_CLEARED = 0x00U /*!< All active channels cleared */
} HAL_TIM_ActiveChannel;TIM_HandleTypeDef(保存定时器相关配置，状态和方法，下面进行了精简)
cpp
{
TIM_TypeDef *Instance; // 定时器寄存器集合
TIM_Base_InitTypeDef Init; // 定时器基本配置
HAL_TIM_ActiveChannel Channel; //使用的channel
DMA_HandleTypeDef *hdma[7];
HAL_LockTypeDef Lock; //是否进行锁定，配置完成之后都要进行锁定
__IO HAL_TIM_StateTypeDef State; //定时器状态
__IO HAL_TIM_ChannelStateTypeDef ChannelState[4]; // channel的状态，总共有四个channel
__IO HAL_TIM_ChannelStateTypeDef ChannelNState[4];
__IO HAL_TIM_DMABurstStateTypeDef DMABurstState;
// 函数指针就写了一个，其它的看源码哈
void (* Base_MspInitCallback)(struct __TIM_HandleTypeDef *htim);
} TIM_HandleTypeDef;3.1.2、定时器常规初始化
下面的代码也进行了精简，方便看主要的过程。
cpp
HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
{
/* Check the TIM handle allocation */
if (htim == NULL)
{
return HAL_ERROR;
}
// 结构体初始化时未设置，默认是RESET状态
if (htim->State == HAL_TIM_STATE_RESET)
{
htim->Lock = HAL_UNLOCKED;
// 由于未注册定时器回调，这里把回调相关的方法删除了
HAL_TIM_Base_MspInit(htim);
}
// 设置busy状态，防止操作定时器
htim->State = HAL_TIM_STATE_BUSY;
// 将Init中的配置同步到Tim4的寄存器中
TIM_Base_SetConfig(htim->Instance, &htim->Init);
// 未涉及DMA
htim->DMABurstState = HAL_DMA_BURST_STATE_READY;
//将四个channel设置成ready
TIM_CHANNEL_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
//将四个互补channel设置成ready（暂时无用）
TIM_CHANNEL_N_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
// 设置就绪状态
htim->State = HAL_TIM_STATE_READY;
return HAL_OK;
}初始化核心代码是TIM_Base_SetConfig这个函数，具体实现如下：
cpp
void TIM_Base_SetConfig(TIM_TypeDef *TIMx, const TIM_Base_InitTypeDef *Structure)
{
uint32_t tmpcr1;
tmpcr1 = TIMx->CR1;
// 只要是TIM1-4 就会成立（这是一个简单的宏）
if (IS_TIM_COUNTER_MODE_SELECT_INSTANCE(TIMx))
{
// 清除CR1寄存器中的DIR 和CMS位
// DIR是CR1中的第4位，CMS是5 6 位
// DIR = 10000b CMS = 1100000
// 下面的意思是将DIR和CMS清0
tmpcr1 &= ~(TIM_CR1_DIR | TIM_CR1_CMS);
// 重新设置计数模式， 这里只设置了DIR，CMS保持00，00状态就是边沿对齐模式（向上或向下）
// 下面的意思就是设置了边沿对齐的向上计数模式
tmpcr1 |= Structure->CounterMode;
}
// 只要是TIM1-4 就会成立（这是一个简单的宏）
if (IS_TIM_CLOCK_DIVISION_INSTANCE(TIMx))
{
// 清除时钟分频因子TIM_CR1_CKD = 1100000000b，下面就是清除CKD
tmpcr1 &= ~TIM_CR1_CKD;
// 重新配置时钟分频因子，本安全中外部传入的是0
tmpcr1 |= (uint32_t)Structure->ClockDivision;
}
// 这里先清除CR1中ARPE位，然后根据AutoReloadPreload配置，就是是否使能自动重装初值
MODIFY_REG(tmpcr1, TIM_CR1_ARPE, Structure->AutoReloadPreload);
// 配置CR1 寄存器
TIMx->CR1 = tmpcr1;
// 配置ARR自动重装寄存器
TIMx->ARR = (uint32_t)Structure->Period ;
// 配置PSC寄存器
TIMx->PSC = Structure->Prescaler;
//TIM1 才有效
if (IS_TIM_REPETITION_COUNTER_INSTANCE(TIMx))
{
/* Set the Repetition Counter value */
TIMx->RCR = Structure->RepetitionCounter;
}
// 配置事件产生寄存器UG代码第0位，数值1代表定时器溢出时会产生更新事件
TIMx->EGR = TIM_EGR_UG;
}上面的代码主要是设置CR1、ARR、PSC、EGR和RCR（TIM1才有效）寄存器。
3.1.3、定时器时钟配置
项目中用到的是内部时钟，所以代码简化如下，这个函数主要处理SMCR寄存器的配置。
cpp
HAL_StatusTypeDef HAL_TIM_ConfigClockSource(TIM_HandleTypeDef *htim, const TIM_ClockConfigTypeDef *sClockSourceConfig)
{
HAL_StatusTypeDef status = HAL_OK;
uint32_t tmpsmcr;
__HAL_LOCK(htim);
htim->State = HAL_TIM_STATE_BUSY;
tmpsmcr = htim->Instance->SMCR;
// 下面的意思重置从模式寄存器所有位除了MSM位，
tmpsmcr &= ~(TIM_SMCR_SMS | TIM_SMCR_TS);
tmpsmcr &= ~(TIM_SMCR_ETF | TIM_SMCR_ETPS | TIM_SMCR_ECE | TIM_SMCR_ETP);
htim->Instance->SMCR = tmpsmcr;
htim->State = HAL_TIM_STATE_READY;
__HAL_UNLOCK(htim);
return status;
}3.1.4、定时器PWM初始化
由于未开启PWM回调， 这里的操作和定时器常规初始化几乎一样
cpp
HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
{
if (htim->State == HAL_TIM_STATE_RESET)
{
htim->Lock = HAL_UNLOCKED;
// 这里的条件不成立
#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
/* Reset interrupt callbacks to legacy weak callbacks */
TIM_ResetCallback(htim);
if (htim->PWM_MspInitCallback == NULL)
{
htim->PWM_MspInitCallback = HAL_TIM_PWM_MspInit;
}
htim->PWM_MspInitCallback(htim);
#else
/* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
// 这里是一个空操作
HAL_TIM_PWM_MspInit(htim);
#endif /* USE_HAL_TIM_REGISTER_CALLBACKS */
}
/* Set the TIM state */
htim->State = HAL_TIM_STATE_BUSY;
// 重新走了一下定时器的配置
TIM_Base_SetConfig(htim->Instance, &htim->Init);
htim->DMABurstState = HAL_DMA_BURST_STATE_READY;
TIM_CHANNEL_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
TIM_CHANNEL_N_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
htim->State = HAL_TIM_STATE_READY;
return HAL_OK;
}3.1.5、定时器主从模式配置
代表也非常简单，大致如下：
cpp
HAL_StatusTypeDef HAL_TIMEx_MasterConfigSynchronization(TIM_HandleTypeDef *htim,
const TIM_MasterConfigTypeDef *sMasterConfig)
{
uint32_t tmpcr2;
uint32_t tmpsmcr;
__HAL_LOCK(htim);
htim->State = HAL_TIM_STATE_BUSY;
tmpcr2 = htim->Instance->CR2;
tmpsmcr = htim->Instance->SMCR;
// 清除CR2寄存器中的MMS位，即 4 5 6 都是0
tmpcr2 &= ~TIM_CR2_MMS;
// 设置新的MMS主模式选择
tmpcr2 |= sMasterConfig->MasterOutputTrigger;
// 将CR2配置到寄存器中
htim->Instance->CR2 = tmpcr2;
if (IS_TIM_SLAVE_INSTANCE(htim->Instance))
{
// 清除SMCR中的msm(主从模式选择)
tmpsmcr &= ~TIM_SMCR_MSM;
// 外部传入的是DISABLE = 0,0代表无作用
tmpsmcr |= sMasterConfig->MasterSlaveMode;
// 设置回寄存器
htim->Instance->SMCR = tmpsmcr;
}
htim->State = HAL_TIM_STATE_READY;
__HAL_UNLOCK(htim);
return HAL_OK;
}3.1.6、定时器主从模式配置
选调用 HAL_TIM_PWM_ConfigChannel，内部对channel3的处理如下
cpp
TIM_OC3_SetConfig(htim->Instance, sConfig);
/* Set the Preload enable bit for channel3 */
htim->Instance->CCMR2 |= TIM_CCMR2_OC3PE;
/* Configure the Output Fast mode */
htim->Instance->CCMR2 &= ~TIM_CCMR2_OC3FE;
htim->Instance->CCMR2 |= sConfig->OCFastMode;
break;核心代码 是TIM_OC3_SetConfig函数
cpp
static void TIM_OC3_SetConfig(TIM_TypeDef *TIMx, const TIM_OC_InitTypeDef *OC_Config)
{
uint32_t tmpccmrx;
uint32_t tmpccer;
uint32_t tmpcr2;
tmpccer = TIMx->CCER;
// 清除CCE使能位
TIMx->CCER &= ~TIM_CCER_CC3E;
tmpcr2 = TIMx->CR2;
tmpccmrx = TIMx->CCMR2;
// 清除CCMR2(输入捕获寄存器)0C3M(输出比较3模式),CC3S（捕获比较3选择）
tmpccmrx &= ~TIM_CCMR2_OC3M;
tmpccmrx &= ~TIM_CCMR2_CC3S;
// 外部设置的 TIM_OCMODE_PWM1即110 0000（向上计数模式）
tmpccmrx |= OC_Config->OCMode;
// 清除CCER(输入捕获寄存器)极性位
tmpccer &= ~TIM_CCER_CC3P;
// 外部传入的HIGH = 0,CC3E = 0 禁止输出
tmpccer |= (OC_Config->OCPolarity << 8U);
/* Write to TIMx CR2 */
TIMx->CR2 = tmpcr2;
/* Write to TIMx CCMR2 */
TIMx->CCMR2 = tmpccmrx;
/* Set the Capture Compare Register value */
TIMx->CCR3 = OC_Config->Pulse;
/* Write to TIMx CCER */
TIMx->CCER = tmpccer;
}3.1.7、主栈地址初始化
里面就是就是使能了一下timer定时器
cpp
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{
if(tim_baseHandle->Instance==TIM4)
{
/* TIM4 clock enable */
__HAL_RCC_TIM4_CLK_ENABLE();
}
}3.2、开启TIM4的PWM模式
cpp
HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
{
uint32_t tmpsmcr;
/* Check the parameters */
assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
/* Check the TIM channel state */
if (TIM_CHANNEL_STATE_GET(htim, Channel) != HAL_TIM_CHANNEL_STATE_READY)
{
return HAL_ERROR;
}
// 将channel设置成busy（这里传入的是channel3）
TIM_CHANNEL_STATE_SET(htim, Channel, HAL_TIM_CHANNEL_STATE_BUSY);
// 使能channel 3
TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
// TIM1才会进
if (IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
{
/* Enable the main output */
__HAL_TIM_MOE_ENABLE(htim);
}
/* Enable the Peripheral, except in trigger mode where enable is automatically done with trigger */
if (IS_TIM_SLAVE_INSTANCE(htim->Instance))
{
// 获取SMCR 中0-2位(SMS) ，外部SMS是关闭的即0
tmpsmcr = htim->Instance->SMCR & TIM_SMCR_SMS;
// 这个比较不成功 000 != 110
if (!IS_TIM_SLAVEMODE_TRIGGER_ENABLED(tmpsmcr))
{
// 使能CR1的第0位CEN开启计数
__HAL_TIM_ENABLE(htim);
}
}
else
{
__HAL_TIM_ENABLE(htim);
}
/* Return function status */
return HAL_OK;
}核心代码就是使能通道3
cpp
void TIM_CCxChannelCmd(TIM_TypeDef *TIMx, uint32_t Channel, uint32_t ChannelState)
{
uint32_t tmp;
/* Check the parameters */
assert_param(IS_TIM_CC1_INSTANCE(TIMx));
assert_param(IS_TIM_CHANNELS(Channel));
// 外部是Channel3 = 1000 ，Channel & 0x1FU = 1000，
tmp = TIM_CCER_CC1E << (Channel & 0x1FU); /* 0x1FU = 31 bits max shift */
// 清除CC3E
TIMx->CCER &= ~tmp;
// 这里ChannelState = Enable = 1, 使能CC3E
TIMx->CCER |= (uint32_t)(ChannelState << (Channel & 0x1FU)); /* 0x1FU = 31 bits max shift */
}3.3、设置CCR1用于动态配置PWM波形的输出
更改CCR3，来设置占空比。
cpp
#define __HAL_TIM_SET_COMPARE(__HANDLE__, __CHANNEL__, __COMPARE__) \
(((__CHANNEL__) == TIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCR1 = (__COMPARE__)) :\
((__CHANNEL__) == TIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCR2 = (__COMPARE__)) :\
((__CHANNEL__) == TIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCR3 = (__COMPARE__)) :\
((__HANDLE__)->Instance->CCR4 = (__COMPARE__)))
#define __HAL_TIM_SetCompare __HAL_TIM_SET_COMPARE
__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, pwmVal);四、总结
1、HAL 中每次在设置相应的位时都会先清除一下，清除时设置的宏对应位是1。
cpp
tmpcr1 &= ~TIM_CR1_CKD;
tmpcr1 |= (uint32_t)Structure->ClockDivision;2、定时器单线程初始化时通常会加锁，完成之后解锁（别忘解锁）。
cpp
__HAL_LOCK(htim);
__HAL_UNLOCK(htim);
// 加锁时会判断有没有锁住，没有锁住再加锁，有锁就直接返回
#define __HAL_LOCK(__HANDLE__) \
do{ \
if((__HANDLE__)->Lock == HAL_LOCKED) \
{ \
return HAL_BUSY; \
} \
else \
{ \
(__HANDLE__)->Lock = HAL_LOCKED; \
} \
}while (0U)
// 返回时直接解锁
#define __HAL_UNLOCK(__HANDLE__) \
do{ \
(__HANDLE__)->Lock = HAL_UNLOCKED; \
}while (0U)