STM32F1xxx Problem mit einer 50Hz PWM

[M. G. (ixil96)]

Hallo,

ich möchte eine PWM für die Ansteuerung eines Servos erzeugen.
Soweit funktioniert das auch, nur bekomme ich immer wieder low-Pulse 
(siehe Oszi Bild) in mein Signal rein und dabei fängt das Servo an 
ordentlich zu ruckeln.

FCPU (STM32F103C8T) = 32 MHz
PSC = 31
Timer Frequenz = FCPU / (PSC+1) = 1MHz
Counter Period = 20000
PWM Frequency = 50Hz

Es scheint, als würde hier eine Art "Timer Überlauf" dazwischen funken.
Vielleicht kann wer helfen?

Hier der Programmcode:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2022 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
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim4;

/* USER CODE BEGIN PV */
uint16_t highTime_ms = 1500;  // Positive pulse time in ms
uint8_t flag = 1;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM4_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void set_pwm_duty_cycle(uint16_t highTime_ms)
{
  TIM_OC_InitTypeDef sConfigOC = {0};

  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = highTime_ms;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1);
  HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM4_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_1);    // Start Timer
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
     if((flag == 1) && (highTime_ms < 1800))    // turn servo right until 1,8ms
     {
       highTime_ms ++;
       set_pwm_duty_cycle(highTime_ms);
       HAL_Delay(5);
       if(highTime_ms == 1800)
       {
         flag = 0;
         HAL_Delay(2000);
       }
     }

     else if((flag == 0) && (highTime_ms > 1200))  // turn servo left until 1,2ms
     {
       highTime_ms --;
       set_pwm_duty_cycle(highTime_ms);
       HAL_Delay(5);
       if(highTime_ms == 1200)
      {
        flag = 1;
        HAL_Delay(2000);
      }
     }
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL8;
  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 TIM4 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM4_Init(void)
{

  /* USER CODE BEGIN TIM4_Init 0 */

  /* USER CODE END TIM4_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {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 = 31;  // 32MHz (clock frequency) / (Prescaler +1) = 1MHz Timer frequency
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 20000;  // Resolution of PWM (counter period) max. 65535
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 1500;        // Servo Mittenstellung
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim4, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM4_Init 2 */

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

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

[erklehr behr (Gast)]

Fuck!

Was ist an den Hinweisen zum Posten nicht zu verstehen?

[M. G. (ixil96)]

erklehr behr schrieb:
> Fuck!
>
> Was ist an den Hinweisen zum Posten nicht zu verstehen?

Sehr nette Ausdrucksweise!
Das ist wirklich sehr hilfreich. Wo ist die Definition von "langer 
Sourcecode"?

[erklehr behr (Gast)]

M. G. schrieb:
> Wo ist die Definition von "langer
> Sourcecode"?

Du könntest dich in diesem Zusammenhang auch einfach selbst
in Bescheidenheit üben. Wenn man zig-mal scrollen muss um
das Ende zu finden dann ist das langer Sourcecode.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

M. G. schrieb:
> if(highTime_ms == 1800)
>        {
>          flag = 0;
>          HAL_Delay(2000);
>        }
>      }

Wann soll das je ausgeführt werden? Bedenke, die Bedingung des äusseren 
if ist :
> if((flag == 1) && (highTime_ms < 1800))    // turn servo right until bla

Das musst du schon ausserhalb des if() schreiben.
Ansonsten wäre es schön, entweder die Leerzeilen zu entfernen, oder als 
Datei zu posten.

[Stefan F. (Gast)]

Ich würde das Problem einkreisen.

Ersetze deine Hauptschleife durch eine leere und schaue nach, ob das 
Ausgangssignal dann stabil ist.

[erklehr behr (Gast)]

M. G. schrieb:
> Das ist wirklich sehr hilfreich.

Als sehr lang hier angemeldeter Benutzer solltest du um die
Gepflogenheiten und Nettiquette hier im Forum Bescheid wissen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

M. G. schrieb:
> Wo ist die Definition von "langer Sourcecode"?
Da hat jeder so seine Vorstellungen. Aber wenn man Scrollen muss und 
dann noch eine Antwort auf eine Frage beantworten will, wirds 
unübersichtlich.

Also kurze Programmschnipsel direkt in den Text und alles, was länger 
als ca. 30 Zeilen ist in den Anhang.

Die Idee von Andreas war vermutlich, dass man da mitdenkt und selber 
drauf kommt.

Ansonsten wie üblich bei der Fehlersuche: das Programm so lange 
reduzieren, bis der Fehler verschwindet.

Wenn er nicht verschwindet, dann den verbleibenden "Dreizeiler" 
posten...

Es ist übrigens eine ganz schlechte Idee, einen Timer einfach zu 
beliebigen Zeitpunkten anzuhalten, an ihm herumzuschrauben und wieder 
neu zu starten, so wie du es offenbar in der set_pwm_duty_cycle() 
machst.

[Kevin M. (arduinolover)]

M. G. schrieb:
> void set_pwm_duty_cycle(uint16_t highTime_ms)

Warum machst du das Ändern des Duty Cyles denn so kompliziert?
Es gibt keinen Grund das so zu tun, schreib einfach den gewünschten Duty 
Cycle direkt in das Register.

z.B. TIM4->CCR1 = X;

[M. G. (ixil96)]

mit

void set_pwm_duty_cycle(uint16_t highTime_ms)
{
  htim4.Instance->CCR1 = highTime_ms;
}

funktioniert es jetzt.

[Kevin M. (arduinolover)]

M. G. schrieb:
> funktioniert es jetzt.

Wer hätte das gedacht.....

[W.S. (Gast)]

Kevin M. schrieb:
> Es gibt keinen Grund das so zu tun, schreib einfach den gewünschten Duty
> Cycle direkt in das Register.
>
> z.B. TIM4->CCR1 = X;

Tja, normalerweise tut man das so. Aber hier haben wir einen TO, der 
ganz offensichtlich NUR sowas wie Cube benutzt und vermutlich so denkt 
wie einer, der mich vor kurzem mal so angeblafft hat: "Ich programmiere 
nicht auf Registerebene".

Allerdings gebe ich zu, daß man beim Benutzen von PWM-Registern an den 
Timern gut tut, einen Blick in das Manual des verwendeten µC zu tun.

Eben zu dem Zweck, daß man das Verhalten dieses Peripheriecores beim 
Überlaufen oder Reset des Zähler-Registers sich genauer anschaut und die 
ON-Zeit des PWM-Ausganges geeignet wählt, also entweder 0..X oder 
X..Zählende, je nachdem, was man erreichen will.

W.S.