Problem mit xSemaphoreGiveFromISR()

[Moot S. (mootseeker)]

Hallo Zusammen,

ich arbeitet momentan an einem STM32F446RE Projekt und verwende als 
Betriebssystem FreeRTOS. Bei FreeRTOS bin ich noch etwas neu dabei und 
möchte mir nun das Know How erarbeiten.

Mit dem Timer2 habe ich mir einen Interrupt erstellt welcher alle 10s 
kommt. Der Interrupt funktioniert soweit so gut (Getestet mit LED Pin 
toggeln).

Nun habe ich mir einen Event Task erstellt in dem das ganze 
Hauptprogramm nach dem Init der Peripherien laufen soll.

void event_handler_task(void *pvParameters)
{
  SemaphoreHandle_t init_synchronisation = *(SemaphoreHandle_t*) pvParameters;

  MX_TIM2_Init();                //Timer 2 init
  HAL_TIM_Base_Start_IT(&htim2); //Timer 2 start interrupt

  event_binary = xSemaphoreCreateBinary();
  configASSERT(event_binary);

  xSemaphoreGive(init_synchronisation);

  for (;;)
  {
    if (xSemaphoreTake(event_binary, portMAX_DELAY) == pdTRUE)
    {
      sprintf(debug_string, "We are in the Event Task!");
      debug_put_string(debug_string);
    }

    vTaskDelay(1000 / portTICK_RATE_MS);
  }
}

Die BinarySemaphore dazu habe ich Global im selben File erstellt:

static SemaphoreHandle_t event_binary = NULL;

Die Interrupt Funktion sieht so aus:

void TIM2_IRQHandler(void)
{
  static BaseType_t xHigherPriorityTaskWoken = pdFALSE;

  xSemaphoreGiveFromISR(event_binary, &xHigherPriorityTaskWoken);

    if( xHigherPriorityTaskWoken == pdTRUE)
    {
        portYIELD_FROM_ISR(xHigherPriorityTaskWoken); 
    }

  HAL_TIM_IRQHandler(&htim2);

  HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_2);
}

Mein Problem ist nun, dass wenn ich das ganze Debugge bleibt der 
kontroller beim xSemaphoreGiveFromISR hängen. Der Code wird nur bis zu 
dieser Funktion ausgeführt und wenn ich den Debugger anhalte bin ich in 
folgender Funktion:

configASSERT( pxQueue );

Hinter dem configASSERT steckt eine Endlosschelife wenn der Wert der 
übergeben wird 0 ist.

Meine Frage nun, verwende ich die falsche Funktion oder habe ich sie 
falsch initialisiert?

[Markus F. (mfro)]

Moot S. schrieb:
> Die BinarySemaphore dazu habe ich Global im selben File erstellt:
> static SemaphoreHandle_t event_binary = NULL;

Hast Du nicht.

Du hast lediglich eine Semaphore-Handle-Variable mit NULL initialisiert.

Da fehlt ein xSemaphoreCreateBinary() oder 
xSemaphoreCreateBinaryStatic()

Doku lesen! Lesen bildet ;)

[Moot S. (mootseeker)]

Aber das Create habe ich im eventTask? reicht das da nicht?

Das habe ich ja nach gelesen und da steht das so als Beispiel:

#define LONG_TIME 0xffff
#define TICKS_TO_WAIT    10

SemaphoreHandle_t xSemaphore = NULL;

/* Repetitive task. */
void vATask( void * pvParameters )
{
    /* We are using the semaphore for synchronisation so we create a binary
    semaphore rather than a mutex.  We must make sure that the interrupt
    does not attempt to use the semaphore before it is created! */
    xSemaphore = xSemaphoreCreateBinary();

    for( ;; )
    {
        /* We want this task to run every 10 ticks of a timer.  The semaphore
        was created before this task was started.

        Block waiting for the semaphore to become available. */
        if( xSemaphoreTake( xSemaphore, LONG_TIME ) == pdTRUE )
        {
            /* It is time to execute. */

            ...

            /* We have finished our task.  Return to the top of the loop where
            we will block on the semaphore until it is time to execute
            again.  Note when using the semaphore for synchronisation with an
            ISR in this manner there is no need to 'give' the semaphore
            back. */
        }
    }
}

/* Timer ISR */
void vTimerISR( void * pvParameters )
{
static unsigned char ucLocalTickCount = 0;
static signed BaseType_t xHigherPriorityTaskWoken;

    /* A timer tick has occurred. */

    ... Do other time functions.

    /* Is it time for vATask() to run? */
    xHigherPriorityTaskWoken = pdFALSE;
    ucLocalTickCount++;
    if( ucLocalTickCount >= TICKS_TO_WAIT )
    {
        /* Unblock the task by releasing the semaphore. */
        xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );

        /* Reset the count so we release the semaphore again in 10 ticks
        time. */
        ucLocalTickCount = 0;
    }

    /* If xHigherPriorityTaskWoken was set to true you
    we should yield.  The actual macro used here is
    port specific. */
    portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

Und da ist das Create ja auch im Task???

[Moot S. (mootseeker)]

Es funktioniert zwar nicht aber mir ist aufgefallen, dass ich die 
Semaphore erst nach dem Timer erstelle, das hat dazu geführt, dass beim 
Start des Interrupts die Semaphore noch nicht vorhanden war und er sich 
deswegen in der Endlosschleife aufgesetzt hat.

Nun habe ich noch ein Problem mit dem Take aber das sollte ich schaffen 
^^

[Max M. (maxmicr)]

Markus F. schrieb:
> Hast Du nicht.

Lies doch wenigstens seinen Code zuerst...