STM32f767zi: FreeRTOS und TIM

[Frank B. (fbergemann)]

Ich mache gerade meine ersten Schritte mit dem STM32F767ZI board 
(https://www.st.com/en/evaluation-tools/nucleo-f767zi.html).
Dabei habe ich Probleme, unter FreeRTOS den TIM3 mit HAL unterzubringen.

Siehe hier: https://github.com/FBergemann/STM32-FreeRTOS-TIM

In 
https://github.com/FBergemann/STM32-FreeRTOS-TIM/blob/master/Core/Inc/Init/Init_Global.h 
habe ich:

// #define TASK_LED2_USE_NEW_VERSION
#undef TASK_LED2_USE_NEW_VERSION

// #define TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ
#undef TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ

Damit werden #3 LEDs einfach nur über eine einfache loop getoggled:

  while (1)
  {
    HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
    osDelay(250);
  }

Aber wenn ich verwende:

#define TASK_LED2_USE_NEW_VERSION
//#undef TASK_LED2_USE_NEW_VERSION

// #define TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ
#undef TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ

dann blinkt LED2 nicht mehr, weil ich dafür benötige:

#define TASK_LED2_USE_NEW_VERSION
//#undef TASK_LED2_USE_NEW_VERSION

#define TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ
// #undef TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ

Damit wird in 
https://github.com/FBergemann/STM32-FreeRTOS-TIM/blob/master/Core/Src/stm32f7xx_hal_msp.c 
aktiviert:

#ifdef TASK_LED2_USE_NEW_VERSION_ENABLE_IRQ
  /* Enable the TIMx global Interrupt */
  HAL_NVIC_EnableIRQ(TIMx_IRQn);
#endif

Aber damit komme ich nicht mehr durch die Initialisierung durch.
Ich habe schon rumgesucht, ob und wie HAL_TIM mit FreeRTOS verheiratet 
werden kann. Aber bis jetzt bin ich damit nur gegen die Wand gelaufen.

Kann mir da eine von euch helfen?

Grüsse,
Frank

[Harry L. (mysth)]

Vielleicht solltest du mal erklären, was dein Timer überhaupt machen 
soll.

Ansonsten solltest du den Timer in CubeMX initialisieren, wie auch die 
zugehörigen Interrupts.

Einschalten musst du den dann immer noch, aber das kannst du dann 
natürlich auch innerhalb eines Task mit den HAL-Funktionen machen.

[Frank B. (fbergemann)]

Der Timer soll über einen callback die LED2 togglen:
https://github.com/FBergemann/STM32-FreeRTOS-TIM/blob/master/Core/Src/Run/Run_Task_Led2.c

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
}

void Run_Task_Led2(void const * argument)
{
  printf("start Task_Led2...\n\t");

  while (1)
  {
    osDelay(1000);
  }
}

Initialisiert wird über 
https://github.com/FBergemann/STM32-FreeRTOS-TIM/blob/master/Core/Src/Init/Tasks/Init_Task_Led2.c

static GPIO_InitTypeDef GPIO_InitStruct;
static TIM_HandleTypeDef TimHandle;
static __IO uint32_t uwPrescalerValue = 0;

void Init_Task_Led2()
{
  // init LED ------------------------------------------------
  __HAL_RCC_GPIOB_CLK_ENABLE();
  GPIO_InitStruct.Pin  = LD2_Pin;
  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull  = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

  // init Timer ----------------------------------------------
  /* Compute the prescaler value to have TIMx counter clock equal to 10000 Hz */
  uwPrescalerValue = (uint32_t)((SystemCoreClock/ 2) / 10000) - 1;

  /* Set TIMx instance */
  TimHandle.Instance = TIMx;

  /* Initialize TIMx peripheral as follows:
       + Period = 10000 - 1
       + Prescaler = ((SystemCoreClock / 2)/10000) - 1
       + ClockDivision = 0
       + Counter direction = Up
  */
  TimHandle.Init.Period            = 10000 - 1;
  TimHandle.Init.Prescaler         = uwPrescalerValue;
  TimHandle.Init.ClockDivision     = 0;
  TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
  TimHandle.Init.RepetitionCounter = 0;
  TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
  {
    /* Initialization Error */
    Error_Handler();
  }

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

Vertragen sich HAL Timer mit dem FreeRTOS überhaupt?

Oder kollidiert da irgendwas?

[Nachtrag] ich sehe gerade, dass ich ignoriert habe:
"- When RTOS is used, it is strongly recommended to use a HAL timebase 
source other than the Systick.   The HAL timebase source can be changed 
from the Pinout tab under SYS"

Das blöde ist, man kann das im Nachhinein nicht mehr so einfach ändern. 
Wenn die Code-Generierung dafür anläuft, dann werden relevant source 
files einfach wieder überschrieben.

[Harry L. (mysth)]

Frank B. schrieb:
> Vertragen sich HAL Timer mit dem FreeRTOS überhaupt?
>
> Oder kollidiert da irgendwas?
Das hat schlicht nichts miteinander zu tun.

Du kannst die LED wahlweise via Task mit osDelay() oder über deinen 
Timer-Callback blinken lassen.

Das sind aber 2 kompl. unterschiedliche Paar Schuhe.

[Frank B. (fbergemann)]

Ich weiss, ich wollte ja auch verschiedene Varianten ausprobieren.
Für LED2 halt via Timer anstatt über osDelay().

[Johannes S. (Gast)]

das Programm landet im DefaultHandler weil nix ISR für TIM3 IRQ 
vorhanden ist. Dank der weak Technik sucht man sich da jedesmal einen 
Wolf...

füge den hinzu und siehe es blinken:

static GPIO_InitTypeDef GPIO_InitStruct;
static TIM_HandleTypeDef TimHandle;
static __IO uint32_t uwPrescalerValue = 0;

/**
  * @brief This function handles TIM3 global interrupt.
  */
void TIM3_IRQHandler(void)
{
  /* USER CODE BEGIN TIM3_IRQn 0 */

  /* USER CODE END TIM3_IRQn 0 */
  HAL_TIM_IRQHandler(&TimHandle);
  /* USER CODE BEGIN TIM3_IRQn 1 */

  /* USER CODE END TIM3_IRQn 1 */
}

oder wie Harry schon schrieb, besser per Cube generieren lassen.

[Frank B. (fbergemann)]

Super!
Da fehlt nur der

void TIM3_IRQHandler(void)

D.h. das framework bindet da still und heimlich ein NOP ein, wenn man es 
nicht definitiert? (weak)

> oder wie Harry schon schrieb, besser per Cube generieren lassen.

Das muss man aber wirklich schon von Anfang an genau und komplett 
wissen, welche Resourcen man verwenden will. Nachträglich irgendetwas 
ändern geht nicht, weil die Code-Generierung dann immer alles wieder 
übermangelt.

- Danke!

[Johannes S. (Gast)]

Frank B. schrieb:
> D.h. das framework bindet da still und heimlich ein NOP ein, wenn man es
> nicht definitiert? (weak)

Im Startup sind die Vektoren und die Handler als weak definiert. Die 
werden überschrieben wenn es andere gibt und weak verhindert dann das 
der Linker meckert. Wenn der richtige Handler fehlt oder falsch 
geschrieben ist oder durch C++ Kompilierung vermangelt ist, dann meckert 
keiner weil das Symbol ja vorhanden ist.

Frank B. schrieb:
> Nachträglich irgendetwas ändern geht nicht, weil die Code-Generierung
> dann immer alles wieder übermangelt.

Doch, man muss nur brav in den User Sektionen bleiben. Vorher ein commit 
ist trotzdem sicherer.

[Harry L. (mysth)]

Frank B. schrieb:
> Das muss man aber wirklich schon von Anfang an genau und komplett
> wissen, welche Resourcen man verwenden will. Nachträglich irgendetwas
> ändern geht nicht, weil die Code-Generierung dann immer alles wieder
> übermangelt.

Natürlich geht das!

Du darfst, wenn du generierte Dateien ändesrt- deinen Code allerdings 
nur zwischen die markierten UserCode-Sections schreiben.

Diese Teile werden beim Code-generieren nicht angefasst und bleiben 
erhalten.

/* USER CODE BEGIN 1 */

// dein code - der bleibt erhalten

/*  USER CODE END 1 */

[edit] Jojo war schneller...
[Mod-Edit: Codeformatierungstag]

[Frank B. (fbergemann)]

Aha, die entsprechenden Kommentare schützen die Bereiche.

Ich glaube, ich sollte mir doch ein paar der online Kurs von STM antun 
:-)

Vielen Dank noch einmal für eure Hilfe!

[Harry L. (mysth)]

Frank B. schrieb:
> Ich glaube, ich sollte mir doch ein paar der online Kurs von STM antun
> :-)
Dann fang doch direkt mal mit Diesem an:
https://www.youtube.com/watch?v=QGVAayFI5ZQ&t=8s&ab_channel=STMicroelectronicsSTMicroelectronics

Hat mir beim Einstieg in FreeRTOS sehr geholfen, auch, wenn der Typ 
furchtbar nuschelt, und das Audio teilweise zusätzlich sehr leise ist.

[Frank B. (fbergemann)]

Falls noch mal jemand darüber stolpert - hier noch ein link, wie man das 
mit STM32CubeIDE aufsetzt:

"Getting Started with STM32 and Nucleo Part 6: Timers and Timer 
Interrupts | Digi-Key Electronics"

https://www.youtube.com/watch?v=VfbW6nfG4kw

[Frank B. (fbergemann)]

Das project ist umbenannt und umstrukturiert worden nach:
https://github.com/FBergemann/STM32-FreeRTOS-Framework

[Harry L. (mysth)]

Ich habs kurz mal überflogen, aber das hier:

 /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */

  HAL_TIM_Base_Start_IT(&htim14);

  /* USER CODE END RTOS_TIMERS */

ist Quatsch!
Ein RTOS-Timer ist etwas vollkommen Anderes als ein Hardware-Timer.
Der Timer-Start gehört hierhin:

  MX_TIM14_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT(&htim14);

  /* USER CODE END 2 */

Das osDelay in Zeile 159 kannst du löschen.
Der Teil des Code wird nie ausgeführt.

[Frank B. (fbergemann)]

HAL_TIM_Base_Start_IT(&htim14);

habe ich entsprechend verschoben.

> Das osDelay in Zeile 159 kannst du löschen.
> Der Teil des Code wird nie ausgeführt.

Da wird's ein bisschen philosophisch.

Ich habe das 'osDelay(1000)' entfernt, weil hier der FreeRTOS 
task-manager nicht mehr läuft. Stattdessen habe ich ein 
'HAL_Delay(1000);' eingebaut, weil dass ja immer noch verfügbar sein 
sollte.

Wenn der code sowieso nicht läuft, warum dann die Schleife?

while (1) {}

Und wenn schon Schleife, dann nicht als CPU consuming busy-loop.

Oder übersehe ich hier etwas?