定时器同步

最新推荐文章于 2023-12-02 22:36:42 发布
最新推荐文章于 2023-12-02 22:36:42 发布
阅读量1.5k 收藏 5
点赞数 3
分类专栏： 笔记 文章标签： stm32 单片机 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gs2019/article/details/119535136
版权

cube Gated Mode定时器同步

遇到的问题

在改造一块无刷电机电调时，遇到一些问题，其中就有：两个定时器分别是三个PWM的H和L驱动脚，当直接设置timer2timer3PWM模式输出时，开启定时器后其波形不互补，为此我特地查阅主从模式触发相关资料，解决该问题。
在这里插入图片描述

主从模式介绍（参考）

在这里插入图片描述
定时器与外部触发的同步
1.复位模式：计数器使用内部时钟计数，然后正常运转，直到出现TI1上升沿，当TI1出现上升沿时，计数器清零然后重新从零开始计数。TI1上升沿与实际计数器复位之间的延迟是由于TI1输入的重新同步电路引起的。
2.门控模式：低电平计数，高电平不计数
3.触发模式：原本不计数，检测TI2上升沿，计数器启动。（默认为内部CLK）
4.外部时钟模式2 + 触发模式：用ETR作为时钟信号。
定时器同步
1.一个定时器作为另一个定时器的预分频器。
2.一个定时器使能另一个定时器。
3.一个定时器启动另一个定时器。
4.使用一个外部触发同步地启动2个定时器。
链接https://blog.csdn.net/weixin_42263208/article/details/112845804

解决方法

在这里插入图片描述

我将上面几个都尝试了一下，发现Gated Mode好使，走的弯路就不赘述了，我要让timer3和timer4同步，于是我将timer2打开，不分频，计数为1，然后使能主模式，接着将timer3timer4从模式设置为Gated Mode，查表选择ITR1的源，即定时器3 4都在定时器2的控制下同步。完成配置后，先打开定时器34 再开启定时器2。问题解决！
在这里插入图片描述

定时器代码和开启代码

// main.c主要

 
	 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_2);	//开启pwm3
	 HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_1);	//开启pwm4
	 
	 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);	//开启pwm3
	 HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_2);	//开启pwm4
	 
	 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_4);	//开启pwm3
	 HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_3);	//开启pwm4
	 HAL_TIM_Base_Start(&htim2);    //打开定时器

// tim.c

/**
  ******************************************************************************
  * @file    tim.c
  * @brief   This file provides code for the configuration
  *          of the TIM instances.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "tim.h"

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3;
TIM_HandleTypeDef htim4;

/* TIM2 init function */
void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 0;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 1;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_IC_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}
/* TIM3 init function */
void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 0;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 1800-1;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;
  sSlaveConfig.InputTrigger = TIM_TS_ITR1;
  if (HAL_TIM_SlaveConfigSynchro(&htim3, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_ENABLE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 450;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.Pulse = 900;
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.Pulse = 1350;
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */
  HAL_TIM_MspPostInit(&htim3);

}
/* TIM4 init function */
void MX_TIM4_Init(void)
{

  /* USER CODE BEGIN TIM4_Init 0 */

  /* USER CODE END TIM4_Init 0 */

  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM4_Init 1 */

  /* USER CODE END TIM4_Init 1 */
  htim4.Instance = TIM4;
  htim4.Init.Prescaler = 0;
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 1800-1;
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;
  sSlaveConfig.InputTrigger = TIM_TS_ITR1;
  if (HAL_TIM_SlaveConfigSynchro(&htim4, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_ENABLE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 450;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.Pulse = 900;
  if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.Pulse = 1350;
  if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM4_Init 2 */

  /* USER CODE END TIM4_Init 2 */
  HAL_TIM_MspPostInit(&htim4);

}

void HAL_TIM_IC_MspInit(TIM_HandleTypeDef* tim_icHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(tim_icHandle->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspInit 0 */

  /* USER CODE END TIM2_MspInit 0 */
    /* TIM2 clock enable */
    __HAL_RCC_TIM2_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**TIM2 GPIO Configuration
    PA0-WKUP     ------> TIM2_CH1
    */
    GPIO_InitStruct.Pin = GPIO_PIN_0;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* USER CODE BEGIN TIM2_MspInit 1 */

  /* USER CODE END TIM2_MspInit 1 */
  }
}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM3)
  {
  /* USER CODE BEGIN TIM3_MspInit 0 */

  /* USER CODE END TIM3_MspInit 0 */
    /* TIM3 clock enable */
    __HAL_RCC_TIM3_CLK_ENABLE();

    /* TIM3 interrupt Init */
    HAL_NVIC_SetPriority(TIM3_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM3_IRQn);
  /* USER CODE BEGIN TIM3_MspInit 1 */

  /* USER CODE END TIM3_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM4)
  {
  /* USER CODE BEGIN TIM4_MspInit 0 */

  /* USER CODE END TIM4_MspInit 0 */
    /* TIM4 clock enable */
    __HAL_RCC_TIM4_CLK_ENABLE();
  /* USER CODE BEGIN TIM4_MspInit 1 */

  /* USER CODE END TIM4_MspInit 1 */
  }
}
void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(timHandle->Instance==TIM3)
  {
  /* USER CODE BEGIN TIM3_MspPostInit 0 */

  /* USER CODE END TIM3_MspPostInit 0 */
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**TIM3 GPIO Configuration
    PA7     ------> TIM3_CH2
    PB0     ------> TIM3_CH3
    PB1     ------> TIM3_CH4
    */
    GPIO_InitStruct.Pin = A_L_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(A_L_GPIO_Port, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = B_L_Pin|C_L_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* USER CODE BEGIN TIM3_MspPostInit 1 */

  /* USER CODE END TIM3_MspPostInit 1 */
  }
  else if(timHandle->Instance==TIM4)
  {
  /* USER CODE BEGIN TIM4_MspPostInit 0 */

  /* USER CODE END TIM4_MspPostInit 0 */

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**TIM4 GPIO Configuration
    PB6     ------> TIM4_CH1
    PB7     ------> TIM4_CH2
    PB8     ------> TIM4_CH3
    */
    GPIO_InitStruct.Pin = A_H_Pin|B_H_Pin|C_H_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* USER CODE BEGIN TIM4_MspPostInit 1 */

  /* USER CODE END TIM4_MspPostInit 1 */
  }

}

void HAL_TIM_IC_MspDeInit(TIM_HandleTypeDef* tim_icHandle)
{

  if(tim_icHandle->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspDeInit 0 */

  /* USER CODE END TIM2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM2_CLK_DISABLE();

    /**TIM2 GPIO Configuration
    PA0-WKUP     ------> TIM2_CH1
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_0);

  /* USER CODE BEGIN TIM2_MspDeInit 1 */

  /* USER CODE END TIM2_MspDeInit 1 */
  }
}

void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM3)
  {
  /* USER CODE BEGIN TIM3_MspDeInit 0 */

  /* USER CODE END TIM3_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM3_CLK_DISABLE();

    /* TIM3 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM3_IRQn);
  /* USER CODE BEGIN TIM3_MspDeInit 1 */

  /* USER CODE END TIM3_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM4)
  {
  /* USER CODE BEGIN TIM4_MspDeInit 0 */

  /* USER CODE END TIM4_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM4_CLK_DISABLE();
  /* USER CODE BEGIN TIM4_MspDeInit 1 */

  /* USER CODE END TIM4_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
剑指天涯！
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
STM32定时器4种同步模式
11-14
1、一个定时器作为另一个定时器的预分频；2、定时器门控模式；3、定时器同步----触发模式； 4、定时器同步---同步触发两个定时器
同步定时器
小米的修行之路
02-05 214
Timer.1 - Using a timer synchronously This tutorial program introduces asio by showing how to perform a blocking wait on a timer. We start by including the necessary header files. All of the asio classes can be used by simply including the"asio.hpp"he..
jmeter定时器---同步定时器（Synchronizing Timer）
paidaxing_dashu的博客
10-09 360
一，目录 jp@gc - Hits per Second（每秒点击量） jp@gc - Active Threads Over Time（不同时间活动用户数量展示） jp@gc - Composite Graph（混合图集） jp@gc - AutoStop Listener（自动停止监听） jp@gc - Console Status Logger（一些log的设置） 二...
定时器和外部触发的同步
m0_69251699的博客
07-18 669
TIMx定时器能够在多种模式下和一个外部的触发同步：复位模式、门控模式和触发模式。
多线程 定时器 同步 LINUX
09-12
多线程 定时器 同步 LINUX和WINDOWS下两个版本 四种同步方法 C++ 附带测试程序
SSH框架网上商城项目第15战之线程、定时器同步首页数据
09-02
主要为大家详细介绍了SSH框架网上商城项目第15战之线程、定时器同步首页数据，感兴趣的小伙伴们可以参考一下
应用笔记LAT1173高精度定时器的同步功能
最新发布
03-15
单独工作，也可以进行同步，且高精度定时器还能与片上的其他定时器以及其他芯片进行同步，本文将对高精度定时器的同步功能进行介绍。 整个同步功能的主体是主定时器，其主要作用就是用来给所有子定时器提供统一的...
Cube生成定时器2触发双ADC同步采集并用DMA传输
01-06
用cube生成一个用定时器触发ADC1，ADC2同步采集的程序，单片机选择的是STM32L476RGT6，用定时器2进行ADC采集触发，更改定时器2的定时周期便可以更改ADC的采样周期，ADC1和ADC2使用同步规则模式，并用DMA进行数据的...
Gardner定时同步算法
09-15
完整的gardner定时同步算法，能够有效的对高阶QAM信号进行时偏校正，同时分析了环路误差和环路抖动，性能良好，适合新手学习。
数字通信定时同步算法，大牛写的，通俗易懂
10-28
数字通信定时同步算法，大牛写的，通俗易懂，需要的下载
基于Gardner位定时同步算法
11-04
基于Gardner位定时同步算法，学习的好资料，有助于理解
定时同步时钟
weixin_33817333的博客
01-05 125
30 22 * * * /usr/sbin/ntpdate   
实现文件定时同步
qq_337694336
04-08 1790
Linux rsync 实现文件定时同步 本文档适用于私有云文件存储方式为本地存储、磁盘挂载 思路：服务器A和B上都安装rsync，其中B服务器上是以服务器模式运行rsync，而A上则以客户端方式运行rsync。这样在web服务器B上运行rsync守护进程，在A上定时运行客户程序来同步服务器B上需要同步的内容。 准备： 机器 ip 目录 A（源机器） 192.168.1.146 文...
《Linux系统》之"皮毛系列"（十）使用定时器进行时间同步
从明老师的博客
08-14 408
玩linux系统的人应该知道这个事情，那就是Linux系统时间有两个，一个是硬件时间，即BIOS时间；另一个是系统时间，即linux系统Kernel(内核程序)时间。当Linux启动时，系统Kernel会去读取硬件时钟的设置，然后系统时钟就会独立于硬件运作。而某些时候，我们会发现系统时钟和硬件时钟不一致，此时需要进行时间同步。 一、设置Linux系统的时区 1.查看时间或者时区 #查看时间...
服务器时间定时自动同步
zsycsnd的博客
03-29 2514
一、系统时间    1、硬件时间与系统时间； （1）、UTC：通用协调时间 （2）、GMT：格林威治标准时间 （3）、CST：中国标准时间 （4）、DST：夏令时                GMT+8=UTC+8=CST （5）、硬件时钟 RTC或CMOS时钟，一般在主板上靠电池供电，服务器断电后也会继续运行。仅保存日期时间数值，无法保存时区和夏令时设置 （6）、系统时间 一般在服务器启动...
C/C++ 在网络下的编程的应用（时间同步器）
yangshuolll的专栏
04-20 3930
写一个基于UDP的时间服务器。    时间服务器提供的功能就是： 当客户端发送请求时，发回当前的系统时间。时间服务器要写成死循环，用信号退出。    提示：系统时间找 time() 获得秒差，函数localtime()负责把秒差转成 年月日小时分秒的格式，返回给客户端。localtime()返回时间的结构体指针 struct tm，具体成员 在localtime的手册中可以看到。 简介： 采
【c++】c++11 实现定时器 ： 同步、异步
突围
05-27 496
看到一个没有用epoll timer 这样的机制实现的定时器 里面是用线程阻塞等待实现的 vtimer #ifndef TIMER_H_ #define TIMER_H_ #include<functional> #include<chrono> #include<thread> #include<atomic> #include<memory> #include<mutex> #include<condition_var..
spring boot定时器实现定时同步数据
qq_55648724的博客
12-02 1133
配置文件server:port: 8089spring:remote :local :log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #开启sql日志。
STM32H7 定时器同步
02-06
在STM32H7中，定时器同步是指将多个定时器模块的时钟源和计数值进行同步，以实现精确的时间控制。 定时器同步可以通过以下步骤来实现： 1. 配置定时器时钟源：首先，需要选择定时器的时钟源。在STM32H7中，定时器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值