Context Switch beim Cortex M

[Moritz (Gast)]

Guten Abend,

ich versuche mich grade an einem RTOS für Cortex M (nur zum Spaß, ich 
weiß es gibt viele Fertige). Mein Problem ist zur Zeit der Kontext 
wechsel von einem Task zu einem anderen.

void Task1(void)
{
  int x = 123;
  while(1)
  {
    debug_printf("%d\n", x);
  }
}

void Task2(void)
{
  int x = 321;
  while(1)
  {
  }
}

Als erstes Läuft Task1 und dann wird gewechselt (im Systick Handler). 
Wenn Task1 dannach wieder laufen soll wird aber 321 statt 123 
ausgegeben, weshalb ich befürchte, dass die Stacks durcheinander kommen.
Ich könnte mir auch gut vorstellen, dass das mit dem Software Stacking 
zu tun hat, bei dem die Register R4 - R11 auf dem Stack gesichtert 
werden. Die anderen Register sichert die Hardware automatisch beim 
Eintritt in den Interrupt.

void SaveTask(void)
{
  CurrentTask->State = WAITING;

  msp = __get_MSP();
  __set_MSP(__get_PSP());
  __ISB();

  asm("push {r4}");
  asm("push {r5}");
  asm("push {r6}");
  asm("push {r7}");
  asm("push {r8}");
  asm("push {r9}");
  asm("push {r10}");
  asm("push {r11}");

  CurrentTask->StackPointer = __get_MSP();

  __set_MSP(msp);
  __ISB();
}

void LoadTask(Task_t *task)
{
  if(task->State == READY)
  {
    CurrentTask = task;
    CurrentTask->State = RUNNING;

    __set_PSP(CurrentTask->StackPointer);
    __ISB();
  }
  else if(task->State == WAITING)
  {
    CurrentTask = task;
    CurrentTask->State = RUNNING;

    msp = __get_MSP();
    __set_MSP(CurrentTask->StackPointer);
    __ISB();

    asm("pop {r11}");
    asm("pop {r10}");
    asm("pop {r9}");
    asm("pop {r8}");
    asm("pop {r7}");
    asm("pop {r6}");
    asm("pop {r5}");
    asm("pop {r4}");

    CurrentTask->StackPointer = __get_MSP();

    __set_MSP(msp);
    __ISB();

    __set_PSP(CurrentTask->StackPointer);
    __ISB();
  }
}

Die Stacks sind auch außreichen groß (128 Words nur für Daten) Der 
Zustand READY sagt nur aus, das der Task neu ist. WAITING bedeutet, das 
der Task schonmal aktiv war.

Vielleicht hat hier jemand Ahnung von RTOSs und kennt die Lösung. Per 
Debugging und Step by Step konnte ich leider nicht raus finden wie die 
Daten von Task2 in Task1 gelangen.

mfg Moritz

[Lothar (Gast)]

Es ist besser / übersichtlicher den Switch in Assembler zu machen, alles 
im Systick Handler. Deine C Lösung könnte eventuell funktionieren, wenn 
Deine Funktionen nicht selbst stacken, versuch mal:

inline void SaveTask(void)
inline void LoadTask(Task_t *task)

Ansonsten in Assembler siehe hier:

http://stackoverflow.com/questions/25199802/switching-context-inside-an-isr-on-cortex-m

[Little B. (lil-b)]

Ja, so muss ein Context Switch aussehen.

Mit entsprechendem Wissen über RTOSs und die Cortex-M-Prozessoren lässt 
sich hier sehr leicht verstehen, was du tust. Man merkt, dass du dir 
Gedanken gemacht hast, und es ist ein schönes Stück Software entstanden.

Auf den ersten Blick finde ich hier keinen Fehler. Mich würde aber 
interessieren, wie du deine Contexte initialisierst. Denn für 
"if(task->State == READY)" muss bereits was im Speicher vorhanden sein, 
das dann vom Interrupt Return geladen werden kann.
Dann wäre auch hilfreich zu wissen, wo genau die lokale variable x 
liegt. Stack oder Register?

Ich würde mich freuen, wenn du deinen kompletten code mit der community 
teilen würdest, es könnten vieleicht einige was davon lernen.

[eagle user (Gast)]

Apropos Initialisierung: benutzen die Tasks überhaupt den PSP? Zu Anfang 
läuft ja alles auf dem MSP, also muss per CONTROL Register umgeschaltet 
werden.

[Moritz (Gast)]

Moin,

also die Task werden so initialisiert:

Task_t *CreateTask(unsigned char *name, uint32_t stackSizeWords, uint8_t priority, void (*function)(void))
{
  Task_t *newTask = (Task_t *)malloc(sizeof(Task_t));
  if(newTask == NULL)
  {
    OutOfHeapCallback();
  }

  if(stackSizeWords < MIN_STACK_SIZE)
  {
    stackSizeWords = MIN_STACK_SIZE;
  }

  newTask->Function = function;
  newTask->Name = name;
  newTask->Next = NULL;
  newTask->Priority = priority;
  newTask->Stack = (uint32_t *)malloc(stackSizeWords * 4);
  if(newTask->Stack == NULL)
  {
    OutOfHeapCallback();
  }

  newTask->StackPointer = (((uint32_t)newTask->Stack) + ((stackSizeWords - 8) * 4));
  newTask->StackSizeWords = stackSizeWords;
  newTask->State = READY;

  *(newTask->Stack + (newTask->StackSizeWords - 1)) = 0x01000000;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 1) = (uint32_t)newTask->Function;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 2) = 0xFFFFFFFD;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 3) = 0x00;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 4) = 0x00;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 5) = 0x00;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 6) = 0x00;
  *(newTask->Stack + (newTask->StackSizeWords - 1) - 7) = 0x00;

  if(TaskChain == NULL)
  {
    TaskChain = newTask;
  }
  else
  {
    CMRTOS_Task_t *current = TaskChain;
    CMRTOS_Task_t *prev = NULL;
    while((current != NULL) && (current->Priority >= newTask->Priority))
    {
      prev = current;
      current = current->Next;
    }

    if(prev == NULL)
    {
      newTask->Next = current;
      TaskChain = newTask;
    }
    else
    {
      prev->Next = newTask;
      newTask->Next = current;
    }
  }

  return newTask;
}

Ich verwende eine sortierte Linked-List um die Task zu speichern. Hohe 
Prioritäten stehen am Anfang. TaskChain ist der Task mit der höchsten 
Priorität.

Ganz am Anfang gibts eine Init-Funktion für das RTOS. Bis jetzt wird da 
nur __set_CONTROL_(2) aufgerufen, was zum Process-Stack schaltet.

x ist eine lokale Variable und liegt auf dem Stack.

Wenns funktioniert lad ich das hier gerne hoch.

mfg, Moritz

[Moritz (Gast)]

Also folgendermaßen funktioniert es anscheinend (Die Task interferieren 
nicht mehr):

-Alles im Systick-Handler
-Systick-Handler mit __attribute__((naked)) gekennzeichnet
-Keine Funtionsaufrufe im Handler (mit naked gibt das ein Hardfault)

Allerdings möchte ich gerne den Systick-Handler für etwas anderes 
verwenden (STM32-HAL usw.).

Also hab ich den Inhalt aus dem SysTick-Handler in den PendSV kopiert 
und trigger im Systick-Handler nur den PendSV (der auch mit 
__attribute__((naked)) gekennzeichnet ist)

Das führt allerdings auch schon zu einem Hardfault, weil der 
Systick-Handler erst beendet wird nachdem der PendSV fertig ist. 
(Systick hat Priorität 0 (hoch) und PendSV Priorität 15 (niedrig)). Wenn 
ich das naked attribute vom Systick wegnehme interferieren beide Task 
wieder.

Was soll ich tuen? Am besten wäre es wohl wenn sich der Systick erst 
komplett beendet und dann der PendSV beginnt. Aber das ist glaube ich 
beim Cortex M extra so, damit alle Interrupts schnell bearbeitet werden.

mfg, Moritz

[Moritz (Gast)]

So, jetzt funktioniert es richtig. Das Problem war meine Faulheit, die 
darin bestand den Simulator zu verwenden anstatt die echte Hardware. Wie 
versprochen einmal das gesamte "RTOS". Um zu verstehen wie ein RTOS 
funktioniert und als Grundlage für ein RTOS vielleicht ganz nützlich, 
für den richtigen Einsatz fehlen noch viel zu viele Sachen. Ich hab 
Crossworks verwendet (gcc) und als Hardware einen STM32F746NG. Sollte 
aber mit Cortex M3 und M4 funktionen (M0 und M1 bin ich mir nicht ganz 
sicher. Es wird die stm32f7xx.h mit in das RTOS eingebunden, müsste man 
vllt. anpassen)

Beispiel Programm könnte so aussehen:

#include "CMRTOS.h"


void HAL_SYSTICK_Callback(void)
{
  CMRTOS_IncrementCurrentTime();
}

void Task1(void)
{
  uint32_t x = 0;
  while(1)
  {
    x++;
    debug_printf("x: %d\n", x);
  }
}


void Task2(void)
{
  uint32_t y = 10000;
  while(1)
  {
    y--;
    debug_printf("y: %d\n", y);
  }
}

int main(void)
{
  CMRTOS_Init();

  CMRTOS_Task_t *task1 = CMRTOS_CreateTask("Task1", CMRTOS_MIN_STACK_SIZE + 32, 200, Task1);
  CMRTOS_Task_t *task2 = CMRTOS_CreateTask("Task2", CMRTOS_MIN_STACK_SIZE + 32, 200, Task2);

  while (1)
  {
  }
}

mfg Moritz

[olaf (Gast)]

Ich hab mal eine Frage. Mit  __set_CONTROL(2) schaltet du ja die
Nutzung des psp frei. Brauchst du dafuer ein modifiziertes startup
damit der psp korrekt initialisiert ist?
Weil ueblicherweise nutzt man Embedded doch eigentlich nur den msp oder?

Olaf