STM32F pulse packet

HAL & CMSIS Timer Interrupt

HAL library helps us to handle all the checking and clearing status flag bits so we don’t have to worry about them again, just use the following function as an interrupt handler routine.


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if (htim->Instance==TIM3) //check if the interrupt comes from TIM3
{
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_9);
}
}

This Callback function is sharing among all timers interrupt. If you are using more than one Time base interrupt, you need to check the source of the interrupt before executing any command. For example, if you use TIM3 and TIM6 time base interrupt, the Callback function should be like this:


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   if (htim->Instance==TIM3)
      {
      //do something here
      }
   if (htim->Instance==TIM6)
      {
      //do something else here
      }
}

void TIM2_IRQHandler(void) //Функция обработчика прерывания от таймера 6
  {
    TIM2->SR &= ~TIM_SR_UIF; //Сбрасываем бит вызова прерывания. 
    GPIOC->ODR ^= GPIO_ODR_ODR8;//Инвертируем состояние вывода - зажигаем/гасим светодиод
  }
int main()
{
  NVIC_SetPriority(TIM2_IRQn, 1); //Приоритет прерывания
  NVIC_EnableIRQ(TIM2_IRQn); //Разрешаем обработку прерывания от таймера 2
  
  RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; //Тактирование порта C
  GPIOC->CRH |= GPIO_CRH_MODE8_0;//Вывод PC8 порта C - выход
  GPIOC->CRH &= ~GPIO_CRH_CNF8;//Режим Push-Pull для вывода PC8 порта C
  
  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;//Тактирование таймера TIM2
  TIM2->PSC = 16799;//Настройка предделителя таймера
  TIM2->ARR = 5000;//Загружаем число миллисекунд в регистр автоперезагрузки
  TIM2->DIER |= TIM_DIER_UIE; //Разрешаем прерывание при переполнении счетчика
  TIM2->CR1 |= TIM_CR1_CEN;//Запускаем счет
  
  while(1);
}

#include "stm32f10x.h"
uint8_t i=0;
int main(void) 
{
  RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;  // Enable PORTC Periph clock
  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;  // Enable TIM2 Periph clock
  // Clear PC8 and PC9 control register bits
  GPIOC->CRH &= ~(GPIO_CRH_MODE8 | GPIO_CRH_CNF8 |
                 GPIO_CRH_MODE9 | GPIO_CRH_CNF9);
  // Configure PC.8 and PC.9 as Push Pull output at max 10Mhz
  GPIOC->CRH |= GPIO_CRH_MODE8_0 | GPIO_CRH_MODE9_0;
  TIM2->PSC = SystemCoreClock / 1000 - 1; // 1000 tick/sec
  TIM2->ARR = 1000;  // 1 Interrupt/sec (1000/100)
  TIM2->DIER |= TIM_DIER_UIE; // Enable tim2 interrupt
  TIM2->CR1 |= TIM_CR1_CEN;   // Start count
  NVIC_EnableIRQ(TIM2_IRQn);  // Enable IRQ
  while(1); // Infinity loop
}
void TIM2_IRQHandler(void)
{
  TIM2->SR &= ~TIM_SR_UIF; //Clean UIF Flag
  if (1 == (i++ & 0x1)) {
    GPIOC->BSRR = GPIO_BSRR_BS8;   // Set PC8 bit
    GPIOC->BSRR = GPIO_BSRR_BR9;   // Reset PC9 bit
  } else {
    GPIOC->BSRR = GPIO_BSRR_BS9;   // Set PC9 bit
    GPIOC->BSRR = GPIO_BSRR_BR8;   // Reset PC8 bit
  }
}

STM32F 3 phase digital signals

snippet from timer.c:
----------------------------------------------------------------------------------------------
TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
TIM_OCInitTypeDef  TIM_OCInitStructure;
__IO uint16_t CCR1_Val = 65534;
__IO uint16_t CCR2_Val = 43689;
__IO uint16_t CCR3_Val = 21844;
uint16_t PrescalerValue = 0;

/* Private function prototypes -----------------------------------------------*/
void Setup3PhaseTimer(void);
void NVICConfig(void);
/* Private functions ---------------------------------------------------------*/

STM32 CubeMX Timer One Pulse Mode

  MX_TIM3_Init();

  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);
  while (1)
  {
   HAL_Delay(1000);
   __HAL_TIM_ENABLE(&htim3);
  }

STM32F PWM phase shift

Counter mode to Center-aligned mode 3 (CMS[1:0]=11 in TIM1_CR1). And then use PWM mode 1 for TIM1_CH1 (OC1M = 0110 in TIM1_CCMR1) and PWM mode 2 for TIM1_CH2 (OC2M = 0111). Now they'll share the same frequency and if you use the same pulse length in TIM1_CCR1 and TIM1_CCR2 they´ll have the same duty cycle as well.

    TIM_TimeBaseStructure.TIM_Prescaler = 0;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_CenterAligned3;
    TIM_TimeBaseStructure.TIM_Period = TimerPeriod;
    TIM_TimeBaseStructure.TIM_ClockDivision = 0;
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    
    TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
    
    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
    TIM_OCInitStructure.TIM_Pulse = Channel1Pulse;
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_Low;
    TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
    TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCIdleState_Reset;
    
    TIM_OC1Init(TIM1, &TIM_OCInitStructure);
    
    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
    TIM_OCInitStructure.TIM_Pulse = Channel2Pulse;
    
    TIM_OC2Init(TIM1, &TIM_OCInitStructure);

STM32F Timer Synchronization

STM32 Timer One Pulse Mode

CMSIS Initialisation

GPIO

STM32F4 HAL Timer& Interrupt Init

/* TIM5 init function */
void MX_TIM5_Init(void)
{
  htim5.Instance = TIM3; 
  htim5.Init.Prescaler = 16800-1; // делим 168 МГц на 16800 получаем 10000 Гц или 10 мс
  htim5.Init.CounterMode = TIM_COUNTERMODE_UP; // таймер считает вверх
  htim5.Init.Period = 5000-1; // считать будет до 5000, т.е. через 500 мс произойдет прерывание
  htim5.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // частоту входную не делим - нам хватает
  HAL_TIM_Base_Init(&htim5);
  /* Start the TIM Base generation in interrupt mode */
  /* Start Channel1 */
  HAL_TIM_Base_Start_IT(&htim5); // включаем прерывание таймера 5
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_1);
}

STM32 Basic Timer

#include "stm32l1xx.h" //В этом файле заданы все имена регистров периферии 

uint8_t i = 0; //Переменная отображает текущее состояние светодиода - ON/OFF

void TIM6_IRQHandler(void); //Объявление функции обработчика прерывания таймера 6

int main()
{
  //GPIOB init
  RCC->AHBENR |= RCC_AHBENR_GPIOBEN; //Подаем тактовые импульсы в порт B
  GPIOB->MODER |= GPIO_MODER_MODER6_0; //Порт B в режиме "выход"
  GPIOB->OTYPER &= ~GPIO_OTYPER_OT_6; //Выход в режиме "push-pull"
  GPIOB->PUPDR &= ~GPIO_PUPDR_PUPDR6; //Подтягивающие резисторы не используются
  GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR6; //Скорость работы порта максимальная
  
  NVIC_SetPriority(TIM6_IRQn, 1); //Приоритет прерывания
  NVIC_EnableIRQ(TIM6_IRQn); //Разрешаем обработку прерывания от таймера 6
  
  //TIM6 init
  RCC->APB1ENR |= RCC_APB1ENR_TIM6EN; //Подаем тактовые импульсы на таймер 6
  TIM6->PSC = 0xFFFF; //Коэффициент деления максимальный - 65535 + 1
  TIM6->ARR = 0x000F; //Перезагружаемое значение - 16
  TIM6->DIER |= TIM_DIER_UIE; //Разрешаем прерывание при переполнении счетчика
  TIM6->CR1 |= TIM_CR1_CEN; //Запуск счета    
  
  while(1); //Бесконечный цикл. Здесь могла быт ваша программа!
}

 void TIM6_IRQHandler(void) //Функция обработчика прерывания от таймера 6
  {
    TIM6->SR &= ~TIM_SR_UIF; //Сбрасываем бит вызова прерывания. 
    if (i == 0) //Проверяем текущее состояние светодиода - ON/OFF
      GPIOB->BSRRL |= GPIO_BSRR_BS_6; //Зажигаем светодиод
    else
     GPIOB->BSRRH |= GPIO_BSRR_BS_6; //Или гасим светодиод
    i = ~i; //Изменяем переменную, отображающую текушее состояние светодиода
  }

STM32F405/415, 407/417, 427/437, 429/439 Timers Internal trigger connection

STM32F4 Timers for PWM

STM32F4 Timers for Periodic Interrupts

STM32F4: Generating a sine wave

void TIM2_IRQHandler(void)

{

if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)

{

GPIO_SetBits(GPIOD, GPIO_Pin_13);

PWM_SetDC(1,pulse_width);

// Calculate a new pulse width

phase_accumulator+=R;

angle=(uint8_t)(phase_accumulator>>24);

pulse_width = sinetable[angle];

TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

GPIO_ResetBits(GPIOD, GPIO_Pin_13);

}

}




STM32F4 PWM

void TIM_Config(void)

{

  GPIO_InitTypeDef GPIO_InitStructure;

  /* TIM3 clock enable */

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  /* GPIOC and GPIOB clock enable */

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOB, ENABLE);

   

  /* GPIOC Configuration: TIM3 CH1 (PC6) and TIM3 CH2 (PC7) */

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 ;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;

  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;

  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;

  GPIO_Init(GPIOC, &GPIO_InitStructure);

   

  /* GPIOB Configuration:  TIM3 CH3 (PB0) and TIM3 CH4 (PB1) */

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;

  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;

  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;

  GPIO_Init(GPIOB, &GPIO_InitStructure);

  /* Connect TIM3 pins to AF2 */ 

  GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_TIM3);

  GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_TIM3);

  GPIO_PinAFConfig(GPIOB, GPIO_PinSource0, GPIO_AF_TIM3);

  GPIO_PinAFConfig(GPIOB, GPIO_PinSource1, GPIO_AF_TIM3);

}