STM32 Timer Start/Stop mit zweitem Timer

[timertick_t (Gast)]

Auf nem STM32F4 ist Timer 2 als PWM-Erzeuger konfiguriert (kein 
Interrupt, Slave-Mode, 2kHz). Timer 4 der als Master im Interrupt läuft 
soll ihn periodisch ein/ausschalten (3Hz).
Die beiden Timer arbeiten für sich alleine wie sie sollen, aber das 
zusammenwirken via "gated mode" schaltet den Slave-Timer nicht ab.

Jemand ne Idee?

/**
 ******************************************************************************
 * @file    timerSync.c
 * @author  timertick_t
 * @version
 * @date    25.06.2015
 * @brief   This file contains functions for timer sync example
 *
 ******************************************************************************
 */

#include "stm32f4xx.h"
#include "stm32f4_discovery.h"
#include "pwmTimer2.h"  //defines
#include "timerSync.h"

TIM_HandleTypeDef    Tim4Handle;

void timerSync(void) {
  /*
   Alignment:
   Timer 2 32-bit: PWM beep - PA1 TIM2_CH2

   Timer 3 16-bit: Resolver -  TI1 + TI2 = TIM3_CH1 + TIM3_CH2
   TIM3_CH1: PA6 PC6 PB4
   TIM3_CH2: PA7 PC7 PB5
   PC7 = MCLK (Audio)
   => TIM3_CH1: PC6
   => TIM3_CH2: PC7

   Timer 4 16-bit: IRQ call: LED blink
   Timer 5 16-bit:

   Table 97. TIMx internal trigger connection:
   ITR3 (TS = 011)
   => Timer 2: Slave
   => Timer 4: Master
   */


  BSP_LED_Init(LED5);
  BSP_LED_Init(LED6);
  // some household stuff
  if (HAL_Init() != HAL_OK) {
    /* Start Conversation Error */
    Error_Handler();
  }

  //Step 1:
  //Config slave, Timer 2 32-bit: PWM beep - PA1 TIM2_CH2
  // frequency 0x20E0 = 9.980kHz, 0xA400 = 2.000kHz
  // => Timer 2 32-bit: PWM beep - PA1 TIM2_CH2

  TIM_HandleTypeDef Tim2Handle;

  /* First and foremost: Enable TIM2 clock & Port */
  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.Pin = GPIO_PIN_1;
  GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;  //Alternate function ! ! !
  GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
  GPIO_InitStructure.Pull = GPIO_NOPULL;
  GPIO_InitStructure.Alternate = GPIO_AF1_TIM2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);

  //Timer settings:
  //frequency determined by the value of the TIMx_ARR
  //duty cycle determined by the value of the TIMx_CCRx register

  /* Set TIM2 instance */
  Tim2Handle.Instance = TIM2;
  Tim2Handle.Init.Prescaler = 0;
  Tim2Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
  Tim2Handle.Init.Period = FREQUENCY; // 0x20E0 = 9.980kHz, 0xA400 = 2.000kHz (presc = 0)
  Tim2Handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 4 oder 1: kein Einfluss
  Tim2Handle.Init.RepetitionCounter = 0x10000;  // todo necessary?
  HAL_TIM_Base_Init(&Tim2Handle);

  TIM_ClockConfigTypeDef sConfigTIM_ClockConfig;
  sConfigTIM_ClockConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  sConfigTIM_ClockConfig.ClockPolarity = TIM_CLOCKPOLARITY_RISING;
  sConfigTIM_ClockConfig.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1; // without influence 1, 2, 4, 8x
  sConfigTIM_ClockConfig.ClockFilter = 0;
  HAL_TIM_ConfigClockSource(&Tim2Handle, &sConfigTIM_ClockConfig);

  TIM_OC_InitTypeDef sConfigTIM_OC;
  sConfigTIM_OC.OCMode = TIM_OCMODE_PWM1;
  sConfigTIM_OC.Pulse = (FREQUENCY * 4) / 10; // duty; //--- duty cycle ---
  sConfigTIM_OC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigTIM_OC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigTIM_OC.OCFastMode = TIM_OCFAST_ENABLE;
  sConfigTIM_OC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigTIM_OC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  HAL_TIM_PWM_ConfigChannel(&Tim2Handle, &sConfigTIM_OC, TIM_CHANNEL_2);



  TIM_SlaveConfigTypeDef sSlaveConfig;

  /*!< Slave mode selection This parameter can be a value of @ref TIM_Slave_Mode */
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_GATED;

  /*!< Input Trigger source This parameter can be a value of @ref TIM_Trigger_Selection */
  //ITR3 (TS = 011): Timer 2 = Slave, Timer 4 = Master
  sSlaveConfig.InputTrigger = TIM_TS_ITR3;

  /*!< Input Trigger polarity This parameter can be a value of @ref TIM_Trigger_Polarity */
  sSlaveConfig.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;

  /*!< Input trigger prescaler  This parameter can be a value of @ref TIM_Trigger_Prescaler */
  sSlaveConfig.TriggerPrescaler = TIM_TRIGGERPRESCALER_DIV1;

  /*!< Input trigger filter  This parameter can be a number between Min_Data = 0x0 and Max_Data = 0xF */
  sSlaveConfig.TriggerFilter = 0;


  //HAL_StatusTypeDef HAL_TIM_SlaveConfigSynchronization(TIM_HandleTypeDef *htim,
  //                                                     TIM_SlaveConfigTypeDef * sSlaveConfig);
  HAL_TIM_SlaveConfigSynchronization(&Tim2Handle, &sSlaveConfig);

  HAL_TIM_PWM_Init(&Tim2Handle);

  HAL_TIM_PWM_Start(&Tim2Handle, TIM_CHANNEL_2);


  //######################################################################
  //Step 2:
  //Config master, on/off (blink)

   uint32_t uwPrescalerValue = (uint32_t) ((SystemCoreClock / 2) / 10000) - 1;

  /* First and foremost: Enable TIM clock & Port */
  // LED: GPIO B8
  RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN;

  //Timer 2
  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;

  //GPIO B8, today with open-drain
  GPIO_InitStructure.Pin = GPIO_PIN_8;
  GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD;  // Open drain
  GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
  GPIO_InitStructure.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);  // LED ON!
  //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);  // LED OFF!

  /* Set TIMx instance */
  Tim4Handle.Instance = TIM4;
  Tim4Handle.Init.Period = 1000 - 1; //9999 = 0x270F
  Tim4Handle.Init.Prescaler = uwPrescalerValue;
  Tim4Handle.Init.ClockDivision = 0;
  Tim4Handle.Init.CounterMode = TIM_COUNTERMODE_UP;
  if (HAL_TIM_Base_Init(&Tim4Handle) != HAL_OK) {
    /* Initialization Error */
    Error_Handler();
  };

  TIM_MasterConfigTypeDef sTIM_MasterConfigTypeDef;
    /*!< Trigger output (TRGO) selection. This parameter can be a value of @ref TIM_Master_Mode_Selection */
  sTIM_MasterConfigTypeDef.MasterOutputTrigger = TIM_TRGO_ENABLE;

  /*!< Master/slave mode selection. This parameter can be a value of @ref TIM_Master_Slave_Mode */
  sTIM_MasterConfigTypeDef.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE ;
  //HAL_StatusTypeDef HAL_TIMEx_MasterConfigSynchronization(TIM_HandleTypeDef* htim, TIM_MasterConfigTypeDef * sMasterConfig);
  HAL_TIMEx_MasterConfigSynchronization(&Tim4Handle, &sTIM_MasterConfigTypeDef);


  /*##-2- Start the TIM Base generation in interrupt mode ####################*/
  if (HAL_TIM_Base_Start_IT(&Tim4Handle) != HAL_OK) {
    /* Starting Error */
    Error_Handler();
  }
  while (0) {  };
}

/**
 * @brief  Period elapsed callback in non blocking mode
 * @param  htim: TIM handle
 * @retval None
 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
  if (htim) {  }; //dummy for compiler warning
  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_8);
  // BSP_LED_Toggle(LED6);
}

/**
 *
 * From ... /stm32f4xx_hal_msp.c:
 *
 * @brief TIM MSP Initialization
 *        This function configures the hardware resources used in this example:
 *           - Peripheral's clock enable
 *           - Peripheral's GPIO Configuration
 * @param htim: TIM handle pointer
 * @retval None
 */
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim) {
  if (htim) {  }; //dummy

  /*##-1- Enable peripherals and GPIO Clocks #################################*/
  __HAL_RCC_TIM4_CLK_ENABLE();
  //TIM4_CLK_ENABLE();

  /*##-2- Configure the NVIC for TIMx ########################################*/
  /* Set Interrupt Group Priority */
  HAL_NVIC_SetPriority(TIM4_IRQn, 4, 0);

  /* Enable the TIMx global Interrupt */
  HAL_NVIC_EnableIRQ(TIM4_IRQn);
}

void Error_Handler(void) {
  BSP_LED_On(LED5);
  while (1) {  }
}

#if NO_CODE_HERE
#endif // #if NO_CODE_HERE

[Eric (Gast)]

Wo ist dein main()?
Wie gross ist FREQUENCY --> gibt (FREQUENCY * 4) kein Überlauf?
Was macht die while(0) am Ende von timerSync()?

[Little B. (lil-b)]

timertick_t schrieb:
> Jemand ne Idee?

Zwei Kleinigkeiten fallen mir auf:
In step2 aktivierst du im RCC Tim2 und nicht Tim4!
Beim Prescaler des Tim4 unterscheidet sich der Wert und dein Kommentar 
um Faktor 10.

Leider arbeite ich nicht mit Bibliotheken und kann daher keine Aussage 
treffen, was da genau passiert. Zu prüfen wäre vor allem, ob die Timer 
laufen. Diese, in der CMSIS sehr explizite Anweißung, vermisse ich hier. 
Kann aber auch sein, dass

 HAL_TIM_PWM_Start(&Tim2Handle, TIM_CHANNEL_2);

 das mit übernimmt.

[timertick_t (Gast)]

Autor: Eric (Gast) schrieb:
>Wo ist dein main()?
Das verrate ich nicht.

Oben schrieb ich:
>>Die beiden Timer arbeiten für sich alleine wie sie sollen, aber das
>>zusammenwirken via "gated mode" schaltet den Slave-Timer nicht ab.
Die Interrupt-Routine wird angesprungen, Bit 0 in TIMx_SR sollte also 
kommen:
Bit 0 UIF: Update interrupt flag
This bit is set by hardware on an update event. It is cleared by 
software.
0: No update occurred.
1: Update interrupt pending. This bit is set by hardware when the 
registers are updated.
At overflow or underflow (for TIM2 to TIM5) and if UDIS=0 in the 
TIMx_CR1 register.


>Wie gross ist FREQUENCY --> gibt (FREQUENCY * 4) kein Überlauf?
FREQUENCY = 0xA400, da passiert bei Timer2 als 32-Bit Zähler mit einem 
32-Bit breiten Register nichts böses. Ausserdem funktioniert der Timer 
als Standalone ja wie er soll, wie bereits beschrieben.

 Little Basdart (lil-b)
>In step2 aktivierst du im RCC Tim2 und nicht Tim4!
Die Zusammenhänge wären noch zu prüfen. Überhaupt ist das Verhalten 
seltsam, der Slave reagiert zwar auf entsprechende Schaltbits, aber 
nicht wie eigentlich erwartet.


>Beim Prescaler des Tim4 unterscheidet sich der Wert und dein Kommentar
>um Faktor 10.
Das macht nix, war nur rumgeblödel.

[timertick_t (Gast)]

>Diese, in der CMSIS sehr explizite Anweißung, vermisse ich hier.
Beide vorhanden:
HAL_TIM_PWM_Start(&Tim2Handle, TIM_CHANNEL_2);
und
if (HAL_TIM_Base_Start_IT(&Tim4Handle) != HAL_OK) {...

Interessant aber wäre wirklich die Frage, was genau den TRGO auslöst: 
Ein Update des Timers oder ein gesetztes Interrupt-Bit.
Jedefalls wird das Auto-Reload-Register bedient. in der entsprechenden 
Init-Funktion in stm32f4xx_hal_tim.c fand ich:

  /* Set the Auto-reload value */
  TIMx->ARR = (uint32_t)Structure->Period;

Wie gesagt: Einzeln gehen die Biester. Ich habe mittlerweile auch einige 
Varianten ausprobiert; es ist immer das Zusammenspiel das nicht funzt.
Als ob ein grundsätzlichen Denkfehler vorliegt und der eigentliche 
Fehler wo ganz anders steckt. Dummerweise scheint's für diese 
Konstellation auch keine veröffentlichten Examples im Netz zu geben.