FreeRTOS + Arduino = erstes Programm.

[X. A. (wilhem)]

..das natürlich nie wie gewünscht funktioniert.
Hallo zusammen,
Wegen der Uni brauche ich eine Einführung in Echtzeitssysteme und 
Arduino.
Im Internet bin ich auf diesen Port des FreeRTOS 
http://code.google.com/p/rtoslibs/ der sehr vielversprenchend ist und 
daher ich damit anfangen wollte.

Angenommen, dass ich erst jetzt mit Echtzeitprogrammierung angefangen 
habe, habe ich mich die Examples in der Bibliothek angeschaut und das 
folgende Programm für Arduino 2009 geschrieben und hochgeladen habe

#include <FreeRTOS_AVR.h>

// The LED is attached to pin 4 and 5
const int greenLed = 4;
const int redLed = 5;

/*
 * Thread 1, turn the LED on and off.
 */
// Declare the thread function for thread 1.
static void Thread1(void* arg) {
  while (1) {
    
    digitalWrite(redLed, HIGH);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
    // Turn LED off.
    digitalWrite(redLed, LOW);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
  }
}

/*
 * Thread 2, turn the LED on and off.
 */
// Declare the thread function for thread 2.
static void Thread2(void* arg) {
  
  while (1) {
    
    digitalWrite(greenLed, HIGH);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
    // Turn LED off.
    digitalWrite(greenLed, LOW);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
  }
}

void setup() {

  pinMode(redLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  
  Serial.begin(115200);
  
  portBASE_TYPE s1, s2;
  
  /* Thread 1 prio 1 */
  s1 = xTaskCreate(Thread1, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
  /* Thread 2 prio 2 */
  s2 = xTaskCreate(Thread2, NULL, configMINIMAL_STACK_SIZE, NULL, 2, NULL);

  // check for creation errors
  if (s1 != pdPASS || s2 != pdPASS) {
    Serial.println(F("Creation problem"));
    while(1);
  }
  
  vTaskStartScheduler();
  Serial.println(F("Insufficient RAM"));
  while(1);

}
// Loop is the idle thread.  The idle thread must not invoke any 
// kernel primitive able to change its state to not runnable.
void loop() {
  // Not used.
}

Nun ich habe 2 Tasks erzeugt, damit die an den Pins 4 und 5 verbundenen 
Led ein-ausgeschaltet werden können.
Die gewünschte Reihenfolge ist folgende:

redLed ON     redLed OFF     greenLed ON      greenLed OFF
|-------------|--------------|----------------|-----------------------> t
t0 = 0        t1 = 200 ms    t2 = 400 ms      t2 = 600 ms

ABER, wenn ich das Programm kompilieren und hochladen lasse, dass werden 
alle 2 Led gleichzeitig ein- und ausgeschlatet.
Also....ich hatte mir gedacht, dass da die 2 Tasks zwei verschiedene 
Prioritäten haben. Infolgedessen wird zuerst die Task mit prio 1 
ausgeführt und dann die Task mit prio 2. Hingegen passiert alles 
gleichzeitig.
Wie soll ich das Programm ändern? Wo steckt der Fehler?

Danke und Gruß!!!

[Karl (Gast)]

Nun, das die Sachen gleichzeitig passieren ist doch gerade der Sinn 
eines RTOS. Hast du da was falsch verstanden?

[Jojo S. (Gast)]

vTaskDelay()  gibt die CPU anderen Prozessen anstelle die Zeit in einer 
Endlosschleife zu verbraten. Zum Vergleich kannst du die Funktion ja mal 
durch das Arduino delay() ersetzen.
Im FreeRTOS Manual ist das Verhalten in den ersten Kapiteln auch sehr 
gut beschrieben.

[X. A. (wilhem)]

Naja, ich dachte mir, dass der Sinn eines RTOS darin bestand, ein 
Programm in verschiedenen Tasks aufzuteilen und ausführen lassen. Aus 
der Webseite ist hier zB eine kurze Einführung zu ersehen:
http://www.freertos.org/implementation/TaskExecution.gif

und anscheinend ähnelt mein Program dem ersten Graf oben, währenddessen 
das Verhalten in dem zweiten Graf gewünscht ist. Ich verstehe nicht, wie 
ich die 3 Tasks miteinander koordinieren kann.

ich werde mir nun das Manual besorgen. Leider gibt es nicht so viele 
info im Internet, sondern muss man das Buch kaufen.

Danke!

[Jojo S. (Gast)]

Task1 startet und schaltet die rote LED an und wartet dann. Wenn Task1 
anfängt zu warten kommt die nächste Task dran, also Task2 und schaltet 
die grüne LED an. Das passiert mit nicht sichtbarem Zeitversatz, einigen 
mikrosekunden. Wenn die grüne LED versetzt blinken soll müsstest du vor 
die while Schleife in Task2 noch ein vTaskDelay setzen.

[Jojo S. (Gast)]

Wenn die Task voneinander abhängig laufen sollen dann sieh dir das 
Kapitel mit den Semaphoren an. Damit kann man eine Task anhalten bis sie 
durch ein Ereignis einer anderen wieder freigegeben wird.

[X. A. (wilhem)]

Danke Jojo!!
Ich habe seit Stunden versucht, mit einer Semaphore das Programm 
umzuschreiben. Dennoch läuft es gar nicht. Die Led werden ein- und 
ausgeschaltet @ random.
Hier der Code:

#include <FreeRTOS_AVR.h>

// The LED is attached to pin 13 on Arduino
const int yellowLed = 2;
const int blueLed = 3;
const int greenLed = 4;
const int redLed = 5;

xSemaphoreHandle sem;

//------------------------------------------------------------------------------
/*
 * Thread 1, turn the LED off and on.
 */
// Declare the thread function for thread 1.
static void Thread1(void* arg) {
  while (1) {

    xSemaphoreTake(sem, portMAX_DELAY);
    
    digitalWrite(redLed, HIGH);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
    // Turn LED off.
    digitalWrite(redLed, LOW);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
    
    xSemaphoreGive(sem);
  }
}
//------------------------------------------------------------------------------
/*
 * Thread 2, turn the LED on and off.
 */
// Declare the thread function for thread 2.
static void Thread2(void* arg) {
  
  while (1) {
    
    xSemaphoreTake(sem, portMAX_DELAY);
        
    digitalWrite(greenLed, HIGH);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
    // Turn LED off.
    digitalWrite(greenLed, LOW);
    // Sleep for 200 milliseconds.   
    vTaskDelay((200L * configTICK_RATE_HZ) / 100L);
    
    xSemaphoreGive(sem);
  }
}
void setup() {

  pinMode(redLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  pinMode(blueLed, OUTPUT);
  
  Serial.begin(115200);
  
  portBASE_TYPE s1, s2, s3;
  
  // initialize fifoData semaphore to no data available
  vSemaphoreCreateBinary(sem);
  
  s1 = xTaskCreate(Thread1, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
  s2 = xTaskCreate(Thread2, NULL, configMINIMAL_STACK_SIZE, NULL, 2, NULL);

  // check for creation errors
  if (sem == 0 || s1 != pdPASS || s2 != pdPASS) {
    Serial.println(F("Creation problem"));
    while(1);
  }
  
  vTaskStartScheduler();
  Serial.println(F("Insufficient RAM"));
  while(1);

}
//------------------------------------------------------------------------------
// Loop is the idle thread.  The idle thread must not invoke any 
// kernel primitive able to change its state to not runnable.
void loop() {
  // Not used.
}

Vielleicht verwende ich die Semaphore nicht richtig (meine Vermutung), 
aber Tutorial im Internet sind echt schwer zu finden und die meisten 
sind für mich unverständnis.

Bezüglich der Erklärung des ersten Problems, habe ich verstanden, wieso 
die Led fast gleichzeitig leuchteten. Nun verstehe was du mit delay() 
von Arduino meintest. Danke!!!

[Markus M. (mark_m)]

Wenn Du bei Guckle nach "Nebenläufige Programmstrukturen" suchst, hast 
Du Lesestoff bis Weihnachten.

Grüsse

[chris (Gast)]

Hallo Dave,

da ich mich nicht mit FreeRTOS auskenne: Wie aufwendig ist es, das 
System für Arduino in Betrieb zu nehmen? Muss man viel Zeit investieren, 
bis es mal grundsätzlich kompiliert?

Gruß,
chris

[X. A. (wilhem)]

Hi chris
Ich bin auch in der gleichen Situation und daher sage ich dir, dass das 
Ganze im Betrieb zu bringen nicht so schwierig ist. Ich konnte die 
ersten 2 Led mit Arduino 2009 innerhalb ein paar Stunden blinken lassen.
Was schwierig ist, ist in Echtzeitsysteme umzudenken.
Semaphore, Mutex und so weiter benötigen richtig Zeit um RTOS zu lernen.
Ich habe mit diesen 2 FreeRTOS-like RTOSs angefangen:
http://code.google.com/p/rtoslibs/            (meine Empfehlung +++++)
https://bitbucket.org/ctank/ardos/wiki/Home   (meine Empfehlung ++++)

Mit dem zweiten habe ich Probleme beim kompilieren aber hat den Vorteil, 
dass die Beispiele einfacher zu verstehen sind.

Im Internet habe ich nichts viel gefunden. Was ich ich fand, war 
andereseits unverständlich.

Ich würde mich aber drüber freuen, wenn wir hier unsere Erfarhungen 
austauschen würden.

gruß

[holger (Gast)]

>Ich habe seit Stunden versucht, mit einer Semaphore das Programm
>umzuschreiben. Dennoch läuft es gar nicht.

Kein Wunder, du fragst ja gar nicht ab ob du die
Semaphore bekommen hast oder nicht und schaltest trotzdem
munter weiter die LEDs.

[X. A. (wilhem)]

holger schrieb:
>>Ich habe seit Stunden versucht, mit einer Semaphore das Programm
>>umzuschreiben. Dennoch läuft es gar nicht.
>
> Kein Wunder, du fragst ja gar nicht ab ob du die
> Semaphore bekommen hast oder nicht und schaltest trotzdem
> munter weiter die LEDs.

Ich meinte damit, dass die Led nicht nach der gewünschten Reihenfolge 
schalten. Das liegt bestimmt an der Semaphore. Ich kann noch nicht deren 
Funktion in einem Programm implementieren. Das Programm hingegen lässt 
sich kompilieren.

[holger (Gast)]

>Ich meinte damit, dass die Led nicht nach der gewünschten Reihenfolge
>schalten. Das liegt bestimmt an der Semaphore.

Ich denke eher das das an deinen unterschiedlichen
Task Prioritäten liegt. Wer sagt denn das wenn Task2
fertig mit einmal blinken ist dann auch sofort Task1
drankommt? Task2 hat höhere Priorität und kann durchaus
auch zweimal nacheinander aufgerufen werden.

Was passiert wenn du beiden Tasks gleiche Priorität gibst?

[holger (Gast)]

>Was passiert wenn du beiden Tasks gleiche Priorität gibst?

Wird auch nichts breingen wenn man mal weiter nachdenkt.
Es ist ja nicht sicher das der Task sich die Semaphore
gleich wieder schnappt.
Nach dem     xSemaphoreGive(); könnte ein taskYield();
klappen. Damit gibst du dem zweiten Task die Chance
die Semaphore zu schnappen.
Aber Semaphore geht bei dir ja noch nicht.

Mal abgesehen davon hast du da EINE Aufgabe in zwei Tasks
gepackt. Das ist irgendwie nicht so sinnvoll.

[Falk B. (falk)]

Wie man Probleme mit HiTec löst, die man ohne sie nie hätte ;-)

Der OP muss glaub ich noch ein wenig das Grundkonzept von 
Multitasking verstehen, einfach nur hippes Arduino + RTOS reicht bei 
weitem nicht.

[Stefan (Gast)]

Das Programm ist kein gutes Beispiel für Semaphoren. Dafür nimmt man 
Message Queues.

Task A:
 - Warten auf Nachricht
 - Blinken
 - Nachricht an B

Task B:
 - Warten auf Nachricht
 - Blinken
 - Nachricht an A

Hier gibt es am Anfang ein Henne/Ei Problem weil beide Tasks warten.
Das kann man lösen in dem eine Task sofort eine Nachricht schickt und 
dann wartet oder daß in einer Task initial eine Nachricht verschickt 
wird.

Diese Tests mit LEDs halte ich aber für fragwürdig da ein reelles 
Programm doch etwas anders gestrickt ist. Hier wird im Grunde genommen 
ein typisches Mainloop Design auf ein RTOS abgebildet. Ohne Vorteil aber 
mit allen Problemen die ein RTOS machen kann. Kein Wunder daß sich RTOS 
Verweigerer ins Fäustchen lachen.
Klar, irgendwie muß man anfangen aber das Ziel sollte man halt nicht aus 
den Augen verlieren.

[Stefan (Gast)]

PS: Was mir noch aufgefallen ist:

vTaskDelay((200L * configTICK_RATE_HZ) / 100L);

Ich glaube das funktioniert eher zufälig. Offiziell wird es so 
beschrieben:

vTaskDelay((200/portTICK_RATE_MS);

Oder ist das eine Besonderheit des AVR Ports?

[X. A. (wilhem)]

Ok danke an Stefan und Holger.
Nur ist es mir klar geworden, dass das Beispiel mit den Leds eher 
Probleme erzeugt als was zu klären. Nun lerne ich FreeRTOS direkt aus 
dessen Manual.
Die Idee mit den Nachrichten ist gut. Nun habe ich verstanden wie ich 
meine programme umschreiben soll.
Wie gesagt, ich muss wegen der Uni ein RTOS lernen und die ersten 
Programme habe ich immer mit Leds angefangen.

Der

configTICK_RATE_HZ

ist anscheinend ein Port für AVR und ARM.
Wenn ihr bessere Beispiele um FreeRTOS habt, bitte Bescheid geben!!!!

Danke