STM32 Timer Problem mit internen Quarz (?)

[Massi87 (Gast)]

Hi zusammen,

ich beschäftige mich aktuell mit der Synchronisation von zwei Timern 
(soll später mal für die Signalerzeugung verwendet werden und daher ist 
mir die Genauigkeit der Timer sehr wichtig).
Der TIM1 ist der Slave-Timer und soll immer wenn er vom Master TIM2 
getriggert wird, einen Puls von aktuell 1 Sekunden (das soll später mal 
im Mikrosekundenberich sein) nach 4 Sekunden auslösen und auf GPIOA-10 
an die angeschlossene LED ausgeben. TIM2 schickt in TIM1 immer den 
Trigger beim Start und läuft aktuell 10 Sekunden (soll später auch mal 
im Mikrosekundenbereich sein.

Das Ganze lasse ich aktuell endlos laufen und messe mit einer Stoppuhr 
die Zeit. Mir ist aber aufgefallen, dass der erste Puls bei 4 Sekunden 
kommt, aber der zweite kommt nicht bei 14 Sekunden, sondern etwas eher 
(der Puls sollte immer bei 4, 14, 24, 34, 44 Sekunden kommen, was er 
aber nicht macht(ungefähr 4, 13.8, 23.65, 33.5, 43.35, 53, 62.9)).

Das Board nutzt aktuell als Versorgungsquelle den PC über USB (wegen 
Programmierung und Debugging).

Hat der interne Quarz so eine schlechte Qualität, dass er so start 
abweicht und ich einen externen Quarz verwenden sollte? Oder mache ich 
irgendetwas falsch?

Ich bin über jede Hilfe sehr dankbar!!



Im Programm STM32CubeMX habe ich zuvor das STM32F446RE-Nucleo 64 Board 
konfiguriert und dann den Quellcode mit TrueStudio weiter angepasst.

Einstellungen STM32CubeMX:
- PLL Source MuX = HSI (HSI RC = 16MHz)
- PLLM = /8
- PLLN = 180
- PLLP = /2
- System Clock Mux = PLLCLK
-> SYSCLK (MHz) = 180
- AHB Prescaler = /1
- HCLK (MHz) = 180

Für TIM2:
- APB1 Prescaler = /4
- APB1 Faktor = x2
- APB1 Clock -> 90 MHz

Für TIM1:
- APB2 Prescaler = /2
- APB2 Faktor = x2
- APB2 Clock = 180


C-Code in True Studio mit HAL-Libraries. Wenn gewünscht, kann ich auch 
den Code mit Registern posten:

#include "main.h"
/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3;

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM2_Init(void);
static void MX_TIM3_Init(void);


int main(void)
{
  /* MCU Configuration--------------------------------------------------------*/
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

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

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM1_Init();
  MX_TIM2_Init();
  MX_TIM3_Init();

  while (1)
  {} // wird akuell noch nicht benötigt
}


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 CPU, AHB and APB busses clocks 
  */
  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;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 180;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 2;
  RCC_OscInitStruct.PLL.PLLR = 2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Activate the Over-Drive mode 
  */
  if (HAL_PWREx_EnableOverDrive() != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses 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_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

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


static void MX_TIM1_Init(void)
{
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 17999; // APB2 Clock / (Prescaler + 1) = 10kHz = 0.1ms
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 49999; // APB2 Clock / ((Prescaler + 1) * (Period +1)) = 0.2Hz = 5s
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_OnePulse_Init(&htim1, TIM_OPMODE_SINGLE) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
  sSlaveConfig.InputTrigger = TIM_TS_ITR1;
  if (HAL_TIM_SlaveConfigSynchro(&htim1, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 40000; //CCR1 Wert: (Period + 1) - Pulse = 1s (Pulsdauer)
  sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */
  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
  /* USER CODE END TIM1_Init 2 */
  HAL_TIM_MspPostInit(&htim1);
}


static void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 44999; // APB1 Clock / (Prescaler + 1) = 2kHz = 0.5ms
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 19999; // APB2 Clock / ((Prescaler + 1) * (Period +1)) = 0.1Hz = 10s
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */
  TIM2->CR1 |= TIM_CR1_CEN; //aktiviere den Timer
  /* USER CODE END TIM2_Init 2 */
}


static void MX_GPIO_Init(void)
{

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

}

[A. B. (Gast)]

Einen "internen Quarz" gibt es nicht. Der HSI RC ist (wie der Name schon 
sagt) ein RC-Oszillator. Der ist halt nicht "quarzgenau". Wie genau, 
steht im Datenblatt ...

[Massi87 (Gast)]

Danke! Hmm da muss ich zugeben, dass ich das mit dem Quarz falsch zuvor 
verstanden habe. Jetzt macht es mehr Sinn mit den internen RC Oszillator 
(HSI) - Danke dafür :)

Habe im Dokument DM00135183.pdf den Abschnitt "6.2.2 HSI Clock" 
gefunden.
Dort steht, dass er von Werk aus bei T_A=25°C mit einer Genauigkeit von 
1% kalibriert ist. Wenn ich das richtig lese, kann man die Frequenz 
selber noch trimmen. Das werde ich mal ausprobieren.

[Schorsch X. (bastelschorsch)]

Mach doch einen externen Oszillator ran. Ein DSC6011 kostet bei 25ppm 
<0,80€

[Massi87 (Gast)]

Vielen Dank für die Antwort Schorch! Ich werde mich zu dem DSC6011 mal 
schlau machen.