STM32 Timer PWM Periode dynamisch anpassen

[Hendrik (hendrik2812)]

Guten Tag,

ich versuche in STM32CubeIDE mit Hilfe von PWM flexible Rechtecksignale 
(es geht nur um TTL, also keine Stromschleife oder ähnliches) im 
zweistelligen Mikrosekundenbereich an einem Port-Pin zu erzeugen. Der µC 
ist ein STM32F411 @50 MHz und ich benutze Timer 11 in Verbindung mit Pin 
PB9. Meine Tests funktionieren halbwegs gut, so lange die Periodendauer 
konstant ist und ich nur die Pulsweite anpasse. Aber selbst dann sind 
der erste Puls und die erste Periode laut Speicheroszi ein paar µS zu 
kurz oder zu lang.

Dies ist der Code für Clock- und Timer-Initialisierung, der aufgrund 
meiner Einstellungen in STM32CubeIDE erzeugt wurde:

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 50;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief TIM11 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM11_Init(void)
{

  /* USER CODE BEGIN TIM11_Init 0 */

  /* USER CODE END TIM11_Init 0 */

  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM11_Init 1 */

  /* USER CODE END TIM11_Init 1 */
  htim11.Instance = TIM11;
  htim11.Init.Prescaler = 0;
  htim11.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim11.Init.Period = 999;
  htim11.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim11.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim11) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim11) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 500;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim11, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM11_Init 2 */

  /* USER CODE END TIM11_Init 2 */
  HAL_TIM_MspPostInit(&htim11);

}

Ich benutze ein Array, um die Daten für die weiteren Pulse zu erzeugen:

/* USER CODE BEGIN PV */
int16_t pwm_tx_array [4][2] = {
    { 999, 400 },
    { 999, 300 },
      { 999, 200 },
      { 999, 100 },
};
int pwm_tx_finished = 0;
int16_t pwm_tx_array_counter = 0;
int pwm_tx_array_size = sizeof(pwm_tx_array)/sizeof(pwm_tx_array[0]);
int16_t pwm_tx_period = 0;
int16_t pwm_tx_pulse = 0;
/* USER CODE END PV */

Im CallBack für den jeweils aktuellen Puls bereite ich den nächsten Puls 
vor:

/* USER CODE BEGIN 4 */
void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef* htim)
{
  if (htim->Instance == TIM11){
    if (!pwm_tx_finished)
    {
      HAL_TIM_PWM_Stop_IT(&htim11, TIM_CHANNEL_1);
      if (pwm_tx_array_counter == pwm_tx_array_size)
      {
        pwm_tx_finished = 1;
      } else {
        pwm_tx_period = pwm_tx_array[pwm_tx_array_counter][0];
        pwm_tx_pulse = pwm_tx_array[pwm_tx_array_counter][1];
        TIM_OC_InitTypeDef sConfigOC;

        // htim11.Init.Period = pwm_tx_period;
        // HAL_TIM_PWM_Init(&htim11);

        sConfigOC.OCMode = TIM_OCMODE_PWM1;
        sConfigOC.Pulse = pwm_tx_pulse;
        sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
        sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
        HAL_TIM_PWM_ConfigChannel(&htim11, &sConfigOC, TIM_CHANNEL_1);
        HAL_TIM_PWM_Start_IT(&htim11, TIM_CHANNEL_1);
        ++pwm_tx_array_counter;
      }
     }
  }
}
/* USER CODE END 4 */

Das funktioniert wie bereits gesagt bis auf die Ungenauigkeit des ersten 
Puls ganz gut, aber sobald ich die 2 Zeilen für die Periode 
einkommentiere und Array-Werte mit wechselnden Perioden benutze, bekomme 
ich echt merkwürdige Kurven auf dem Speicheroszi angezeigt. Zum Testen 
habe ich hier einfach immer kürzere Perioden mit 50:50 Tastverhältnis 
gewählt, es ist aber nur ein Beispiel:

/* USER CODE BEGIN PV */
int16_t pwm_tx_array [4][2] = {
    { 799, 400 },
    { 599, 300 },
      { 399, 200 },
      { 199, 100 },
};
int pwm_tx_finished = 0;
int16_t pwm_tx_array_counter = 0;
int pwm_tx_array_size = sizeof(pwm_tx_array)/sizeof(pwm_tx_array[0]);
int16_t pwm_tx_period = 0;
int16_t pwm_tx_pulse = 0;
/* USER CODE END PV */

Der Main Loop ist leer und der µC erzeugt momentan nur diese PWM. Ich 
benötige später nicht wirklich 2 Mikrosekunden lange Pulse und 
eigentlich würden mir +-2 Mikrosekunden Genauikgeit ausreichen, aber da 
ist ja noch das Problem mit der zu ändernden Periode und ich wollte auch 
wegen des ersten ungenauen Puls wissen, ob die nachfolgenden Pulse exakt 
sind...Aber sie sind es: der 2 µS Puls zum Schluss wird auf dem 
Speicheroszi exakt mit 2 µS gemessen. Wenn ich im Callback vor dem 
Stoppen des Interrupts einen Breakpoint setze, sehen die verschiedenen 
Pulse bei konstanter Periode bis auf den ersten PWM Durchlauf stets 
präzise aus.

Kann mir jemand bei diesem Problem helfen? Oder gibt es eine andere 
Möglichkeit, eine Abfolge von Rechtecksignalen bis runter in den 
zweistelligen Mikrosekundenbereich zu erzeugen?

Vielen Dank und liebe Grüße
Hendrik

[Harry L. (mysth)]

Das kennst du?
https://www.st.com/resource/en/application_note/dm00236305-generalpurpose-timer-cookbook-for-stm32-microcontrollers-stmicroelectronics.pdf

[Hendrik (hendrik2812)]

Nein, das kannte ich noch nicht. Vielen Dank, ich beschreibe die 
Register ARR und CCR1 jetzt direkt und damit konnte ich immerhin schon 
mal das Problem mit den dynamischen Perioden lösen.

Für meine Problem mit dem ungenauen ersten Puls habe ich leider noch 
keine Lösung finden können. Ich habe zum Testen ein neues Projekt für 
mein Nucleo Board erstellt und nur den Timer11 auf PWM gestellt (Periode 
auf 1999 , Puls auf 1000). Ansonsten alles auf Default gelassen, Clock 
ist dann HSI 16 MHz, also dauern 1000 Pulse 62,5 µS. Dann habe ich 
direkt vor der Main-Loop mit HAL_TIM_PWM_Start() die PWM gestartet.

Ergebnis: der erste Puls dauert 67,5 µS, alle nachfolgenden 62,5 µS. Ich 
meine, ich kann da ja eigentlich nicht so viel falsch gemacht haben, da 
ja fast alles von der IDE erstellt wird und ich lediglich die PWM im 
Blocking Mode gestartet habe. Weiß echt keiner, woran diese erste 
Ungenauigkeit liegen könnte?

Oder mein Speicheroszi spinnt...muss ich mal mit nem externen Trigger 
prüfen, den ich über den 2. Kanal des Oszis etwas eher als die PWM 
auslöse.

[STM32 (Gast)]

Man kann den Inhalt der PWM-Register auch per DMA füllen lassen. Das 
kann der Timer selbst triggern, z.B. bei jedem n-ten Durchlauf 
(n=1..256).
Damit kann man sehr komplexe Pattern generieren oder auch eine 
3-Phase-Sinus-Spannung erzeugen, wenn man mehrere Compare-Register so 
füttert.

Das braucht etwas Spucke und Geduld, aber danach macht das die HW quasi 
von selbst. Man fragt sich, was man mit der schlafenden 32-Bit-CPU 
anfangen könnte.

[STM32 (Gast)]

BTW, AN4776 Seite 44ff