Wie schreibt man ein Programm mit mehreren Tasks

Was sind denn für Dich mehrere Tasks?

Wenn es das ist, was man gemeinhin darunter versteht, dann
brauchst Du wohl ein entsprechendes Betriebssystem dafür.
Aber vielleicht meinst Du ja auch was ganz anderes...

Ich möchte einfach nur mehrere Programmabläufe gleichzeitig ablaufen 
lassen.
Etwa so:

task1()
{
  // Programm1
}

task2()
{
  // Programm2
}

Ich benutze einen AT90S4433, falls das wichtig ist.

Claudio Lanconelli hat etwas in dieser Richtung entwickelt, sind keine 
echten Tasks, aber immerhin Threads...

http://www.cs.unibo.it/~lanconel/mthreads.asm.html

Es gibt eine Reihe von Kerneln für Echtzeitsysteme auf AVR,
kann man mit Gugel sicher finden.

Für einen so kleinen Prozessor würde ich mir sowas aber sicher
nicht antun.  Ich habe mir mal eine kleine Bibliothek geschrieben
für Timer-Events, die dann Callback-Funktionen abarbeiten, das
erfüllt letztlich einen ähnlichen Zweck (wenngleich völlig
anders in der Benutzung), selbst das braucht schon ein gutes
Stück an ROM.  Die Echtzeitkernel brauchen sowas auch, haben
aber noch zusätzlichen Overhead für die Thread- oder Taskverwaltung
(mehrere Stacks, Ressourcenverwaltung).

Das scheint ja etwas aufwendiger zu sein als ich dachte.
Ich werde mal sehen was ich mit den Mini-Threads von
Claudio Lanconelli anfangen kann, falls es keinere einfachere
Lösung gibt.
Das Programm was ich damit verwirklichen möchte soll blos
für einen kleinen Roboter sein der Hindernissen ausweicht.
Also ein Programm das auf drei Sensoren, die entweder
eine eins oder eine null an den Mikrocontroller geben,
reagiert und zwei Motoren ansteuert.

Ich weiß ja nicht wie schnell dein Roboter reagieren soll und wie 
umfangreich deine Sensor-Abfrage ist, aber ich würde sagen es reicht die 
Sensoren nacheinander abzufragen und danach entsprechend zu reagieren 
(AVR´s sind verdammt schnell!)

Gruß, Florian

> ich würde sagen es reicht die Sensoren nacheinander abzufragen und danach 
entsprechend zu reagieren

Genau, oder beide Tasks in kleinere Stücke zerlegen, diese in einer 
Statemaschine verteilen und wenn ein kleines Stück abgearbeitet ist, 
abbrechen und zurückkehren zum Hauptprogramm, das dann die Statemaschine 
des anderen Tasks aufruft.

(möglicherweise zerpflückt das Forum die Einrückungen, also entsprechend 
hinzudenken)

main()
{
 while(1)
 {
  task1();
  task2();
 }
}

task1()
{
 switch(state_t1)
 {
  case 1:
   kleines Codestueck;
   state_t1=2;
   break;
  case 2:
   nächstes Codestueck;
   state_t1=3;
   break;
  ...
 }
}

task2()
{
 switch(state_t2)
 {
  case 1:
   kleines Codestueck;
   state_t2=2;
   break;
  case 2:
   nächstes Codestueck;
   z.B. Meßwertgrenze überschritten?
    -> ja: state_t1=1;
    -> nein: state_1=2; /* weiter warten */
   state_t1=1;
   break;
 }
}

Bei geschickter Aufteilung der einzelnen States, werden diese quasi 
parallel ausgeführt. Geschickte Aufteilung ist immer dann, wenn auf ein 
externes Ereignis aktiv gewartet werden müßte oder die Ausführung zu 
lange dauern würde und die Abarbeitung des/der anderen Task(s) 
blockiert.

Schmittchen.