• stm32之PWM呼吸灯

            呼吸灯是灯从渐亮到渐灭周而复始形成的一个效果。由于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函数代码配置

    1. int main(void)
    2. {
    3. 	uint16_t pwmVal = 0;
    4. 	uint8_t dir = 1;
    5.  
    6.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    7.   HAL_Init();
    8.  
    9.   /* Configure the system clock */
    10.   SystemClock_Config();
    11.  
    12.   /* Initialize all configured peripherals */
    13.   MX_GPIO_Init();
    14.   MX_TIM4_Init();
    15.   /* USER CODE BEGIN 2 */	
    16.   // 开启定时器4
    17.   HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_3);
    18.  
    19.   while (1)
    20.   {
    21. 		
    22. 		HAL_Delay(1);
    23. 		if(dir) {
    24. 			pwmVal ++;
    25. 		} else {
    26. 			pwmVal--;
    27. 		}
    28. 		if(pwmVal > 500) {
    29. 			dir = 0;
    30. 		} else if(pwmVal <= 0) {
    31. 			dir = 1;
    32. 		}
    33. 		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, pwmVal);
    34. /*		
    35. 		// 常亮
    36.    __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 0); 
    37. 	 // 常灭
    38. 		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 500); 
    39. 		*/
    40.   }
    41. }

    二、PWM分析

            输出比较就是通过定时器的外部引脚对外输出控制信号，有八种模式，由寄存器 CCMRx 的位 OCxM[2:0]控制。
    1. 000：冻结。输出比较寄存器TIMx_CCR1与计数器TIMx_CNT间的比较对OC1REF不起作用；
    2. 001 ：匹配时设置通道 1 为有效电平。当计数器 TIMx_CNT 的值与TIMx_CCR1相同时，强制OC1REF为高。
    3. 010 ：匹配时设置通道 1 为无效电平。当计数器 TIMx_CNT 的值与TIMx_CCR1相同时，强制OC1REF为低。
    4. 011：翻转。当TIMx_CCR1=TIMx_CNT时，翻转OC1REF的电平。
    5. 100：强制为无效电平。强制OC1REF为低。
    6. 101：强制为有效电平。强制OC1REF为高。
    7. 110：PWM模式1－ 在向上计数时，一旦TIMx_CNT时通道1为有效电平，否则为无效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为无效电(OC1REF=0)，否则为有效电平(OC1REF=1)。
    8. 111：PWM模式2－ 在向上计数时，一旦TIMx_CNT时通道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时通道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的主要流程大致如下：

    1. 初始化TIM4
    2. 开启TIM4的PWM模式
    3. 设置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

    函数比较长，大致将功能分了下类，具体函数如下：

    1. void MX_TIM4_Init(void)
    2. {
    3.  
    4. 	// 这里主要是根据功能将寄存器分成几个模块进行配置
    5. 	// 时钟相关配置
    6.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    7. 	// 主从模式配置
    8.   TIM_MasterConfigTypeDef sMasterConfig = {0};
    9. 	// 定时器输出捕获常规配置
    10.   TIM_OC_InitTypeDef sConfigOC = {0};
    11.  
    12.   htim4.Instance = TIM4;
    13.   htim4.Init.Prescaler = 71;
    14.   htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
    15.   htim4.Init.Period = 499;
    16.   htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    17.   htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    18. 	
    19. 	// 1、定时器常规初始化
    20.   if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
    21.   {
    22.     Error_Handler();
    23.   }
    24. 	
    25. 	// 2、定时器时钟配置
    26.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    27.   if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
    28.   {
    29.     Error_Handler();
    30.   }
    31. 	
    32. 	// 3、定时器PWM初始化
    33.   if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
    34.   {
    35.     Error_Handler();
    36.   }
    37. 	
    38. 	// 4、定时器主从模式配置
    39.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    40.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    41.   if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
    42.   {
    43.     Error_Handler();
    44.   }
    45.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
    46.   sConfigOC.Pulse = 0;
    47.   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    48.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    49. 	// 5、定时器channel配置
    50.   if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
    51.   {
    52.     Error_Handler();
    53.   }
    54. 	
    55. 	// 6、定时器主栈地址初始化
    56.   HAL_TIM_MspPostInit(&htim4);
    57.  
    58. }

    上面主要做了下面几件事

    • 1、定时器常规初始化（时基单元相关）
    • 2、定时器时钟配置
    • 3、定时器PWM初始化
    • 4、定时器主从模式配置
    • 5、定时器channel配置
    • 6、定时器主栈地址初始化（实际上就是使能定时器）

    下面主要针对上面的过程进行描述

    3.1.1、定时器相关类型

    TIM_TypeDef

    1. typedef struct
    2. {
    3.   __IO uint32_t CR1;             /*!< TIM control register 1,                      Address offset: 0x00 */
    4.   __IO uint32_t CR2;             /*!< TIM control register 2,                      Address offset: 0x04 */
    5.   __IO uint32_t SMCR;            /*!< TIM slave Mode Control register,             Address offset: 0x08 */
    6.   __IO uint32_t DIER;            /*!< TIM DMA/interrupt enable register,           Address offset: 0x0C */
    7.   __IO uint32_t SR;              /*!< TIM status register,                         Address offset: 0x10 */
    8.   __IO uint32_t EGR;             /*!< TIM event generation register,               Address offset: 0x14 */
    9.   __IO uint32_t CCMR1;           /*!< TIM  capture/compare mode register 1,        Address offset: 0x18 */
    10.   __IO uint32_t CCMR2;           /*!< TIM  capture/compare mode register 2,        Address offset: 0x1C */
    11.   __IO uint32_t CCER;            /*!< TIM capture/compare enable register,         Address offset: 0x20 */
    12.   __IO uint32_t CNT;             /*!< TIM counter register,                        Address offset: 0x24 */
    13.   __IO uint32_t PSC;             /*!< TIM prescaler register,                      Address offset: 0x28 */
    14.   __IO uint32_t ARR;             /*!< TIM auto-reload register,                    Address offset: 0x2C */
    15.   __IO uint32_t RCR;             /*!< TIM  repetition counter register,            Address offset: 0x30 */
    16.   __IO uint32_t CCR1;            /*!< TIM capture/compare register 1,              Address offset: 0x34 */
    17.   __IO uint32_t CCR2;            /*!< TIM capture/compare register 2,              Address offset: 0x38 */
    18.   __IO uint32_t CCR3;            /*!< TIM capture/compare register 3,              Address offset: 0x3C */
    19.   __IO uint32_t CCR4;            /*!< TIM capture/compare register 4,              Address offset: 0x40 */
    20.   __IO uint32_t BDTR;            /*!< TIM break and dead-time register,            Address offset: 0x44 */
    21.   __IO uint32_t DCR;             /*!< TIM DMA control register,                    Address offset: 0x48 */
    22.   __IO uint32_t DMAR;            /*!< TIM DMA address for full transfer register,  Address offset: 0x4C */
    23.   __IO uint32_t OR;              /*!< TIM option register,                         Address offset: 0x50 */
    24. }TIM_TypeDef;

    TIM_TypeDef 结构体包括了定时器所有的寄存器，通过操作结构体就可以操作寄存器。在初始化的时候有这样一句代码 htim4.Instance = TIM4 这里的TIM4就是定时器4在外设中的地址，TIM4也是一个宏，具体就不展开了，它的定义和 GPIO类似，可参考GPIO，或自行在代码中查看。

    TIM_HandleTypeDef

    1. typedef struct
    2. {
    3.   uint32_t Prescaler;        // 配置时基单元中的预分频器    
    4.   uint32_t CounterMode;      // 计数模式（向上/向下/中央对齐）
    5.   uint32_t Period;           // 定时周期（period + 1）
    6.   uint32_t ClockDivision;    // 时钟分频因子
    7.   uint32_t RepetitionCounter; // 重复定时器（高级定时器中用）
    8.   uint32_t AutoReloadPreload; // 是否自动重装初值
    9. } TIM_Base_InitTypeDef;

    HAL_TIM_ActiveChannel （选中的channel）

    1. typedef enum
    2. {
    3.   HAL_TIM_ACTIVE_CHANNEL_1        = 0x01U,    /*!< The active channel is 1     */
    4.   HAL_TIM_ACTIVE_CHANNEL_2        = 0x02U,    /*!< The active channel is 2     */
    5.   HAL_TIM_ACTIVE_CHANNEL_3        = 0x04U,    /*!< The active channel is 3     */
    6.   HAL_TIM_ACTIVE_CHANNEL_4        = 0x08U,    /*!< The active channel is 4     */
    7.   HAL_TIM_ACTIVE_CHANNEL_CLEARED  = 0x00U     /*!< All active channels cleared */
    8. } HAL_TIM_ActiveChannel;

    TIM_HandleTypeDef(保存定时器相关配置，状态和方法，下面进行了精简)

    1. {
    2.   TIM_TypeDef                        *Instance;  // 定时器寄存器集合       
    3.   TIM_Base_InitTypeDef               Init;       // 定时器基本配置       
    4.   HAL_TIM_ActiveChannel              Channel;     //使用的channel
    5.   DMA_HandleTypeDef                  *hdma[7];          
    6.   HAL_LockTypeDef                    Lock;          //是否进行锁定，配置完成之后都要进行锁定    
    7.   __IO HAL_TIM_StateTypeDef          State;          //定时器状态   
    8.   __IO HAL_TIM_ChannelStateTypeDef   ChannelState[4];   // channel的状态，总共有四个channel
    9.   __IO HAL_TIM_ChannelStateTypeDef   ChannelNState[4];  
    10.   __IO HAL_TIM_DMABurstStateTypeDef  DMABurstState;     
    11.  
    12.   // 函数指针就写了一个，其它的看源码哈
    13.   void (* Base_MspInitCallback)(struct __TIM_HandleTypeDef *htim); 
    14. } TIM_HandleTypeDef;
    3.1.2、定时器常规初始化
    下面的代码也进行了精简，方便看主要的过程。 
    1. HAL_StatusTypeDef HAL_TIM_Base_Init(TIM_HandleTypeDef *htim)
    2. {
    3.   /* Check the TIM handle allocation */
    4.   if (htim == NULL)
    5.   {
    6.     return HAL_ERROR;
    7.   }
    8.  
    9.   // 结构体初始化时未设置，默认是RESET状态
    10.   if (htim->State == HAL_TIM_STATE_RESET)
    11.   {
    12.     htim->Lock = HAL_UNLOCKED;
    13.     // 由于未注册定时器回调，这里把回调相关的方法删除了
    14.     HAL_TIM_Base_MspInit(htim);
    15.   }
    16.     
    17.   // 设置busy状态，防止操作定时器
    18.   htim->State = HAL_TIM_STATE_BUSY;
    19.     
    20.   // 将Init中的配置同步到Tim4的寄存器中
    21.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    22.    
    23.   // 未涉及DMA
    24.   htim->DMABurstState = HAL_DMA_BURST_STATE_READY;
    25.    
    26.   //将四个channel设置成ready
    27.   TIM_CHANNEL_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
    28.   //将四个互补channel设置成ready（暂时无用）
    29.   TIM_CHANNEL_N_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
    30.  
    31.   // 设置就绪状态
    32.   htim->State = HAL_TIM_STATE_READY;
    33.  
    34.   return HAL_OK;
    35. }

    初始化核心代码是TIM_Base_SetConfig这个函数，具体实现如下：

    1. void TIM_Base_SetConfig(TIM_TypeDef *TIMx, const TIM_Base_InitTypeDef *Structure)
    2. {
    3.   uint32_t tmpcr1;
    4.   tmpcr1 = TIMx->CR1;
    5.  
    6.   // 只要是TIM1-4 就会成立（这是一个简单的宏）
    7.   if (IS_TIM_COUNTER_MODE_SELECT_INSTANCE(TIMx))
    8.   {
    9.     // 清除CR1寄存器中的DIR 和CMS位
    10.     // DIR是CR1中的第4位，CMS是5 6 位
    11.     // DIR = 10000b  CMS = 1100000
    12.     // 下面的意思是将DIR和CMS清0
    13.     tmpcr1 &= ~(TIM_CR1_DIR | TIM_CR1_CMS);
    14.     // 重新设置计数模式， 这里只设置了DIR，CMS保持00，00状态就是边沿对齐模式（向上或向下）
    15.     // 下面的意思就是设置了边沿对齐的向上计数模式
    16.     tmpcr1 |= Structure->CounterMode;
    17.   }
    18.  
    19.   // 只要是TIM1-4 就会成立（这是一个简单的宏）
    20.   if (IS_TIM_CLOCK_DIVISION_INSTANCE(TIMx))
    21.   {
    22.     // 清除时钟分频因子TIM_CR1_CKD = 1100000000b，下面就是清除CKD
    23.     tmpcr1 &= ~TIM_CR1_CKD;
    24.     // 重新配置时钟分频因子，本安全中外部传入的是0
    25.     tmpcr1 |= (uint32_t)Structure->ClockDivision;
    26.   }
    27.  
    28.   // 这里先清除CR1中ARPE位，然后根据AutoReloadPreload配置，就是是否使能自动重装初值
    29.   MODIFY_REG(tmpcr1, TIM_CR1_ARPE, Structure->AutoReloadPreload);
    30.   // 配置CR1 寄存器
    31.   TIMx->CR1 = tmpcr1;
    32.  
    33.   // 配置ARR自动重装寄存器
    34.   TIMx->ARR = (uint32_t)Structure->Period ;
    35.  
    36.   // 配置PSC寄存器
    37.   TIMx->PSC = Structure->Prescaler;
    38.   
    39.   //TIM1 才有效
    40.   if (IS_TIM_REPETITION_COUNTER_INSTANCE(TIMx))
    41.   {
    42.     /* Set the Repetition Counter value */
    43.     TIMx->RCR = Structure->RepetitionCounter;
    44.   }
    45.   // 配置事件产生寄存器UG代码第0位，数值1代表定时器溢出时会产生更新事件
    46.   TIMx->EGR = TIM_EGR_UG;
    47. }

    上面的代码主要是设置CR1、ARR、PSC、EGR和RCR（TIM1才有效）寄存器。

    3.1.3、定时器时钟配置

    项目中用到的是内部时钟，所以代码简化如下，这个函数主要处理SMCR寄存器的配置。

    1. HAL_StatusTypeDef HAL_TIM_ConfigClockSource(TIM_HandleTypeDef *htim, const TIM_ClockConfigTypeDef *sClockSourceConfig)
    2. {
    3.   HAL_StatusTypeDef status = HAL_OK;
    4.   uint32_t tmpsmcr;
    5.  
    6.   __HAL_LOCK(htim);
    7.  
    8.   htim->State = HAL_TIM_STATE_BUSY;
    9.  
    10.   tmpsmcr = htim->Instance->SMCR;
    11.   // 下面的意思重置从模式寄存器所有位除了MSM位，
    12.   tmpsmcr &= ~(TIM_SMCR_SMS | TIM_SMCR_TS);
    13.   tmpsmcr &= ~(TIM_SMCR_ETF | TIM_SMCR_ETPS | TIM_SMCR_ECE | TIM_SMCR_ETP);
    14.   htim->Instance->SMCR = tmpsmcr;
    15.  
    16.   htim->State = HAL_TIM_STATE_READY;
    17.  
    18.   __HAL_UNLOCK(htim);
    19.  
    20.   return status;
    21. }
    3.1.4、定时器PWM初始化

    由于未开启PWM回调， 这里的操作和定时器常规初始化几乎一样

    1. HAL_StatusTypeDef HAL_TIM_PWM_Init(TIM_HandleTypeDef *htim)
    2. {
    3.  
    4.   if (htim->State == HAL_TIM_STATE_RESET)
    5.   {
    6.     htim->Lock = HAL_UNLOCKED;
    7.  
    8. // 这里的条件不成立
    9. #if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
    10.     /* Reset interrupt callbacks to legacy weak callbacks */
    11.     TIM_ResetCallback(htim);
    12.  
    13.     if (htim->PWM_MspInitCallback == NULL)
    14.     {
    15.       htim->PWM_MspInitCallback = HAL_TIM_PWM_MspInit;
    16.     }
    17.     htim->PWM_MspInitCallback(htim);
    18. #else
    19.     /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
    20. 		// 这里是一个空操作
    21.     HAL_TIM_PWM_MspInit(htim);
    22. #endif /* USE_HAL_TIM_REGISTER_CALLBACKS */
    23.   }
    24.  
    25.   /* Set the TIM state */
    26.   htim->State = HAL_TIM_STATE_BUSY;
    27.  
    28.   // 重新走了一下定时器的配置
    29.   TIM_Base_SetConfig(htim->Instance, &htim->Init);
    30.  
    31.   htim->DMABurstState = HAL_DMA_BURST_STATE_READY;
    32.  
    33.   TIM_CHANNEL_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
    34.   TIM_CHANNEL_N_STATE_SET_ALL(htim, HAL_TIM_CHANNEL_STATE_READY);
    35.  
    36.   htim->State = HAL_TIM_STATE_READY;
    37.  
    38.   return HAL_OK;
    39. }
    3.1.5、定时器主从模式配置

    代表也非常简单，大致如下：

    1. HAL_StatusTypeDef HAL_TIMEx_MasterConfigSynchronization(TIM_HandleTypeDef *htim,
    2.                                                         const TIM_MasterConfigTypeDef *sMasterConfig)
    3. {
    4.   uint32_t tmpcr2;
    5.   uint32_t tmpsmcr;
    6.   __HAL_LOCK(htim);
    7.   htim->State = HAL_TIM_STATE_BUSY;
    8.  
    9.   tmpcr2 = htim->Instance->CR2;
    10.  
    11.   tmpsmcr = htim->Instance->SMCR;
    12.  
    13.   // 清除CR2寄存器中的MMS位，即 4 5 6 都是0
    14.   tmpcr2 &= ~TIM_CR2_MMS;
    15.   // 设置新的MMS主模式选择
    16.   tmpcr2 |=  sMasterConfig->MasterOutputTrigger;
    17.  
    18.   // 将CR2配置到寄存器中
    19.   htim->Instance->CR2 = tmpcr2;
    20.   
    21.   if (IS_TIM_SLAVE_INSTANCE(htim->Instance))
    22.   {
    23.     // 清除SMCR中的msm(主从模式选择)
    24.     tmpsmcr &= ~TIM_SMCR_MSM;
    25.     // 外部传入的是DISABLE	= 0,0代表无作用
    26.     tmpsmcr |= sMasterConfig->MasterSlaveMode;
    27. 	  // 设置回寄存器
    28.     htim->Instance->SMCR = tmpsmcr;
    29.   }
    30.  
    31.   htim->State = HAL_TIM_STATE_READY;
    32.  
    33.   __HAL_UNLOCK(htim);
    34.  
    35.   return HAL_OK;
    36. }
    3.1.6、定时器主从模式配置

    选调用 HAL_TIM_PWM_ConfigChannel，内部对channel3的处理如下

    1.  
    2.      TIM_OC3_SetConfig(htim->Instance, sConfig);
    3.  
    4.       /* Set the Preload enable bit for channel3 */
    5.       htim->Instance->CCMR2 |= TIM_CCMR2_OC3PE;
    6.  
    7.       /* Configure the Output Fast mode */
    8.       htim->Instance->CCMR2 &= ~TIM_CCMR2_OC3FE;
    9.       htim->Instance->CCMR2 |= sConfig->OCFastMode;
    10.       break;

    核心代码 是TIM_OC3_SetConfig函数

    1. static void TIM_OC3_SetConfig(TIM_TypeDef *TIMx, const TIM_OC_InitTypeDef *OC_Config)
    2. {
    3.   uint32_t tmpccmrx;
    4.   uint32_t tmpccer;
    5.   uint32_t tmpcr2;
    6.  
    7.   tmpccer = TIMx->CCER;
    8.  
    9.   // 清除CCE使能位
    10.   TIMx->CCER &= ~TIM_CCER_CC3E;
    11.  
    12.   tmpcr2 =  TIMx->CR2;
    13.   tmpccmrx = TIMx->CCMR2;
    14.  
    15. 	// 清除CCMR2(输入捕获寄存器)0C3M(输出比较3模式),CC3S（捕获比较3选择）
    16.   tmpccmrx &= ~TIM_CCMR2_OC3M;
    17.   tmpccmrx &= ~TIM_CCMR2_CC3S;
    18.   // 外部设置的 TIM_OCMODE_PWM1即110 0000（向上计数模式）
    19.   tmpccmrx |= OC_Config->OCMode;
    20.  
    21.   // 清除CCER(输入捕获寄存器)极性位
    22.   tmpccer &= ~TIM_CCER_CC3P;
    23.   // 外部传入的HIGH = 0,CC3E = 0 禁止输出
    24.   tmpccer |= (OC_Config->OCPolarity << 8U);
    25.  
    26.   /* Write to TIMx CR2 */
    27.   TIMx->CR2 = tmpcr2;
    28.  
    29.   /* Write to TIMx CCMR2 */
    30.   TIMx->CCMR2 = tmpccmrx;
    31.  
    32.   /* Set the Capture Compare Register value */
    33.   TIMx->CCR3 = OC_Config->Pulse;
    34.  
    35.   /* Write to TIMx CCER */
    36.   TIMx->CCER = tmpccer;
    37. }

    3.1.7、主栈地址初始化

    里面就是就是使能了一下timer定时器

    1. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
    2. {
    3.  
    4.   if(tim_baseHandle->Instance==TIM4)
    5.   {
    6.     /* TIM4 clock enable */
    7.     __HAL_RCC_TIM4_CLK_ENABLE();
    8.   }
    9. }

    3.2、开启TIM4的PWM模式

    1. HAL_StatusTypeDef HAL_TIM_PWM_Start(TIM_HandleTypeDef *htim, uint32_t Channel)
    2. {
    3.   uint32_t tmpsmcr;
    4.  
    5.   /* Check the parameters */
    6.   assert_param(IS_TIM_CCX_INSTANCE(htim->Instance, Channel));
    7.  
    8.   /* Check the TIM channel state */
    9.   if (TIM_CHANNEL_STATE_GET(htim, Channel) != HAL_TIM_CHANNEL_STATE_READY)
    10.   {
    11.     return HAL_ERROR;
    12.   }
    13.  
    14.   // 将channel设置成busy（这里传入的是channel3）
    15.   TIM_CHANNEL_STATE_SET(htim, Channel, HAL_TIM_CHANNEL_STATE_BUSY);
    16.  
    17.   // 使能channel 3
    18.   TIM_CCxChannelCmd(htim->Instance, Channel, TIM_CCx_ENABLE);
    19.  
    20. 	// TIM1才会进
    21.   if (IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
    22.   {
    23.     /* Enable the main output */
    24.     __HAL_TIM_MOE_ENABLE(htim);
    25.   }
    26.  
    27.   /* Enable the Peripheral, except in trigger mode where enable is automatically done with trigger */
    28.   if (IS_TIM_SLAVE_INSTANCE(htim->Instance))
    29.   {
    30. 		// 获取SMCR 中0-2位(SMS) ，外部SMS是关闭的即0
    31.     tmpsmcr = htim->Instance->SMCR & TIM_SMCR_SMS;
    32. 		
    33. 		// 这个比较不成功 000 != 110
    34.     if (!IS_TIM_SLAVEMODE_TRIGGER_ENABLED(tmpsmcr))
    35.     {
    36. 			// 使能CR1的第0位CEN开启计数
    37.       __HAL_TIM_ENABLE(htim);
    38.     }
    39.   }
    40.   else
    41.   {
    42.     __HAL_TIM_ENABLE(htim);
    43.   }
    44.  
    45.   /* Return function status */
    46.   return HAL_OK;
    47. }

    核心代码就是使能通道3

    1. void TIM_CCxChannelCmd(TIM_TypeDef *TIMx, uint32_t Channel, uint32_t ChannelState)
    2. {
    3.   uint32_t tmp;
    4.  
    5.   /* Check the parameters */
    6.   assert_param(IS_TIM_CC1_INSTANCE(TIMx));
    7.   assert_param(IS_TIM_CHANNELS(Channel));
    8.  
    9. 	// 外部是Channel3 = 1000 ，Channel & 0x1FU = 1000，
    10.   tmp = TIM_CCER_CC1E << (Channel & 0x1FU); /* 0x1FU = 31 bits max shift */
    11.  
    12.   // 清除CC3E
    13.   TIMx->CCER &= ~tmp;
    14.  
    15.   // 这里ChannelState = Enable = 1, 使能CC3E
    16.   TIMx->CCER |= (uint32_t)(ChannelState << (Channel & 0x1FU)); /* 0x1FU = 31 bits max shift */
    17. }

    3.3、设置CCR1用于动态配置PWM波形的输出

    更改CCR3，来设置占空比。

    1. #define __HAL_TIM_SET_COMPARE(__HANDLE__, __CHANNEL__, __COMPARE__) \
    2.   (((__CHANNEL__) == TIM_CHANNEL_1) ? ((__HANDLE__)->Instance->CCR1 = (__COMPARE__)) :\
    3.    ((__CHANNEL__) == TIM_CHANNEL_2) ? ((__HANDLE__)->Instance->CCR2 = (__COMPARE__)) :\
    4.    ((__CHANNEL__) == TIM_CHANNEL_3) ? ((__HANDLE__)->Instance->CCR3 = (__COMPARE__)) :\
    5.    ((__HANDLE__)->Instance->CCR4 = (__COMPARE__)))
    6.  
    7. #define __HAL_TIM_SetCompare            __HAL_TIM_SET_COMPARE
    8.  
    9. __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, pwmVal);

    四、总结

    1、HAL 中每次在设置相应的位时都会先清除一下，清除时设置的宏对应位是1。

    1. tmpcr1 &= ~TIM_CR1_CKD;
    2. tmpcr1 |= (uint32_t)Structure->ClockDivision;

    2、定时器单线程初始化时通常会加锁，完成之后解锁（别忘解锁）。

    1.  __HAL_LOCK(htim);
    2.  
    3. __HAL_UNLOCK(htim);
    4.  
    5. // 加锁时会判断有没有锁住，没有锁住再加锁，有锁就直接返回
    6. #define __HAL_LOCK(__HANDLE__)                                           \
    7.                                 do{                                        \
    8.                                     if((__HANDLE__)->Lock == HAL_LOCKED)   \
    9.                                     {                                      \
    10.                                        return HAL_BUSY;                    \
    11.                                     }                                      \
    12.                                     else                                   \
    13.                                     {                                      \
    14.                                        (__HANDLE__)->Lock = HAL_LOCKED;    \
    15.                                     }                                      \
    16.                                   }while (0U)
    17. // 返回时直接解锁
    18. #define __HAL_UNLOCK(__HANDLE__)                                          \
    19.                                   do{                                       \
    20.                                       (__HANDLE__)->Lock = HAL_UNLOCKED;    \
    21.                                     }while (0U)

    代码地址

  • 相关阅读:
    【ESP 保姆级教程】疯狂Node.js服务器篇 ——教室WiFi自动打卡考勤（飞书群信息+NodeJs）
    Redis 哨兵（sentinel）
    云服务器和本地服务器的优缺点分析
    vue实现404页面配置、自带的回车事件@keyup.enter
    内存问题难定位，那是因为你没用 ASAN
    蓝桥等考Python组别十八级003
    探索HTML5的设计原则：引领Web开发的未来方向
    判断语音识别结果好坏的指标——python实现
    Python网络基础爬虫-python基本语法
    Vue-devtools、React Developer Tools安装
  • 原文地址：https://blog.csdn.net/TSC1235/article/details/132913039