STM32F429i-Disco FreeRTOS Task wird nur einmal ausgeführt

[W. M. (muhh)]

Hey Leute,

ich wollte mich mal mit RTOS auseinandersetzen und FreeRTOS für das 
STM32F429i-disco Board verwenden.

Dafür habe ich mir ein Projekt in Eclipse eingerichtet, welches mir 
fleißig Code ausspuckt, der auch funktioniert. Allerdings habe ich wie 
im Titel beschrieben das Problem, dass mein Task nur einmal ausgeführt 
wird. Im Projekt verwende ich die neusten HAL-Treiber von der ST 
Homepage (FW1.5).

Ich poste hier erstmal nur den Code der main.c, wenn Bedarf an weiteren 
Ausschnitten besteht, einfach Bescheid sagen :)

Bin ich nur zu doof die FreeRTOS API zu benutzen oder liegt es 
vielleicht doch an etwas anderem?

#include "main.h"
#include <stdint.h>
#include <stddef.h>
#include "core_cmFunc.h"

#include "FreeRTOS.h"
#include "task.h"

static void SystemClock_Config(void);

/* Private functions ---------------------------------------------------------*/
GPIO_InitTypeDef GPIOG_13;

void vTaskCode12( void * pvParameters )
{
  while(1)
  {
    HAL_GPIO_TogglePin(GPIOG, GPIO_PIN_13);

      vTaskDelay(500);
  }
}


/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{
  HAL_Init();  
  
  /* Configure the system clock to 180 MHz */
  SystemClock_Config();


  /* Configure LED3 and LED4 */
  __GPIOG_CLK_ENABLE();

  GPIOG_13.Mode = GPIO_MODE_OUTPUT_PP;
  GPIOG_13.Pin = GPIO_PIN_13;
  GPIOG_13.Pull = GPIO_NOPULL;
  GPIOG_13.Speed = GPIO_SPEED_FAST;

  HAL_GPIO_Init(GPIOG, &GPIOG_13);
  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET);
  
  xTaskCreate( vTaskCode12, "LED1", 512, NULL, 1, NULL );
  
  /* Start scheduler */
  vTaskStartScheduler();

  /* We should never get here as control is now taken by the scheduler */
  while(1)
  {
    HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET);
  }
}

static void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct;
    RCC_ClkInitTypeDef RCC_ClkInitStruct;

    __PWR_CLK_ENABLE();

    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

    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 = 8;
    RCC_OscInitStruct.PLL.PLLN = 360;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    RCC_OscInitStruct.PLL.PLLQ = 4;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);

    HAL_PWREx_ActivateOverDrive();

    RCC_ClkInitStruct.ClockType = 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;
    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
}

Dank und LG Willy

[Leo B. (luigi)]

Deine Fehlerbeschreibung ist doch recht oberflächlich.
Was genau passiert denn, was nicht?
Wo "hängt" das Programm?

Um deine Frage so wie sie ist zu beantworten, würde ich sagen:
Du rufst den Task einmal auf, also wird er einmal Ausgeführt. Was willst 
du mehr?

Ich vermute aber deine LED blinkt nicht wie gewollt. Da würde ich den 
Fehler bei vTaskDelay() suchen:
http://www.freertos.org/a00127.html
vielleicht das hier?

INCLUDE_vTaskDelay must be defined as 1 for this function to be available.

[W. M. (muhh)]

Hallo Leo,

hier eine bisschen genauere Beschreibung:

Der Task "vTaskCode12" soll in 0,5s Abständen die LED3 (GPIOG Pin 13) 
toggeln.
Nach dem Initialisieren des Pin 13 des Port G setze ich die LED auf 
HIGH, sodass sie anfängt zu leuchten. Mit dem Task wird sie nun wieder 
ausgeschaltet und bleibt dann leider aus, obwohl sie ab nun im 500ms 
Takt blinken sollte.

Daher ist meine Vermutung, dass der Task nur einmal ausgeführt wird. Ich 
hatte überlegt, ob es vielleicht an irgendwelchen Interrupts bzw. 
falschen Prioritäten des NVIC zu tun hat... Hat sich bis jetzt aber noch 
nicht rausfinden lassen.

Leo B. schrieb:
> INCLUDE_vTaskDelay must be defined as 1 for this function to be
> available.

Leider steht genau in dieser Zeile eine 1, schön wär's gewesen :)

[Jan K. (jan_k)]

Toggle pin funktioniert?
Wie wäre es mal mit einem break point in der task?
Der Inhalt in deiner main while Schleife wird nie ausgeführt.

[Matthias N. (matt90)]

Hallo,

wenn du die "neue" STM HAL nimmst solltest du auch die hierfür 
bereitgestellten Befehle verwenden.

Definition und erstellen des tasks über STM HAL:

    osThreadDef(User_thread, StartThread, osPriorityNormal, 0, configMINIMAL_STACK_SIZE);
    osThreadDef(CheckButton_thread, CheckButtonThread, osPriorityNormal, 0, configMINIMAL_STACK_SIZE);
    osThreadCreate(osThread(User_thread), NULL);
    osThreadCreate(osThread(CheckButton_thread), NULL);
    osKernelStart(NULL, NULL);

Beispiel hierfür Wäre:
https://github.com/dobromyslov/stm32f0-cmsis-cube-hal-freertos-template/blob/master/src/main.c

Grüße

MaTT

[Fritz (Gast)]

W. M. schrieb:
> /* We should never get here as control is now taken by the scheduler
> */
>   while(1)
>   {
>     HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET);
>   }

Steht zwar wahrscheinlich so im Template, aber wer weiss obs auch 
stimmt. Da würde der Pin immer gesetzt und nur einige Bruchteile von us 
von der Task getoggelt!

kommentiere HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET); aus und 
versuche es nochmals.

[Jupp (Gast)]

Un ich finde es immer spannend, wenn so ein Thread mitten drinn beendet 
wird. Jetzt hat "Jeder" der mal recherchiert, gar nichts davon.
Zum anderen wird nur eingeschaltet uns sonst nix.
Mit einem JTAG/SWD kann man schon bei nutzung von FreeRTOS die laufenden 
Threads und deren Status anzeigen lassen. In emBits und Keil's µVision 
geht sowas sehr gut. In anderen IDE's gibt es sowas auch. Da muss man 
also nicht raten oder vermuten sondern prüfen und tracen.

[Frank (Gast)]

Um das Thema mal abzuschließen:
Ich stand gerade vor dem selben Problem. Leider sieht man vor lauter 
Wrappern/StdLib/HAL/Präsidentenwahl/etc.pp. gar nicht mehr durch.
Gerade die cmsis_os.h finde ich nicht hilfreich, wenn man FreeRTOS 
lernen bzw. nutzen möchte.

Lange Rede, kurzer Sinn: vTaskDelay funktioniert nur, wenn 
xPortSysTickHandler aufgerufen wird.
Das wiederum passiert im SysTick_Handler, aber nur, wenn dort 
USE_RTOS_SYSTICK definiert ist.

Diese Symbol kann man in Eclipse (4.6.1) unter Project -> Properties -> 
C/C++ General -> Paths and Symbols -> Symbols -> Add... -> Name: 
USE_RTOS_SYSTICK
definieren.

Hier ist ein Minimalbeispiel, getestet mit Eclipse, dem openSTM32-Plugin 
und einem Nucleo-F446ZE:

#include "stm32f4xx.h"
#include "stm32f4xx_nucleo_144.h"

// don't forget to define USE_RTOS_SYSTICK globally!
// Wichitg! USE_RTOS_SYSTICK muss global definiert werden!
// (damit wird über osSystickHandler -> xPortSysTickHandler von freeRTOS aufgerufen)

// Wrapper von ARM/CMSIS einbinden (bindet wiederum freertos.h ein)
#include <cmsis_os.h>


// user defines
// Nutzerdefinitionen
#define LED_PIN        GPIO_PIN_0
#define LED_PORT       GPIOB


void blinky_task( void* pvParameters)
{
  for(;;)
  {
    vTaskDelay( 1000 / portTICK_PERIOD_MS);
    HAL_GPIO_WritePin( LED_PORT, LED_PIN, GPIO_PIN_SET);

    vTaskDelay( 200  / portTICK_PERIOD_MS);
    HAL_GPIO_WritePin( LED_PORT, LED_PIN, GPIO_PIN_RESET);
  }
}


int main(void)
{
  //
  // STM32-HAL-spezifisch
  //
  // Takt einstellen, SysTick aktivieren
  HAL_Init();

  // GPIO mit Takt versorgen
  __HAL_RCC_GPIOB_CLK_ENABLE();

  // IO-Port für LED konfigurieren
  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStructure.Pin  = LED_PIN;
  HAL_GPIO_Init( LED_PORT, &GPIO_InitStructure);


  //
  // freeRTOS-spezifisch
  //
  // Task erzeugen
  xTaskCreate( blinky_task, (char*) "blinky", configMINIMAL_STACK_SIZE, 0, 1, 0);
  // Scheduler ausführen
  vTaskStartScheduler();
}