Mein Betriebssystem ist while(1)

[Andreas W. (Gast)]

Hi

auf die Frage nach den einfachsten Betriebssystem bekam ich die Antwort: 
"while(1)". Ok das kann man nicht wirklich verneinen. Es kann zwar nicht 
viel, ist dafür aber auch wirklich einfach.

Anfänger:
Das ist jetzt auf keinen Fall der Weißheit letzter Schluss. Es soll nur 
als Anregung dienen.

Profis:
Macht ihr das auch so, oder so ähnlich?

Konzept:
In einen Timer wird eine Variable (oder ein Array von Variablen) 
runtergezählt. Meistens löst der Timer bei mir im ms Takt einen 
Interrupt aus. Wenn die Zahl 0 ist oder 255 (bei 16 Bit 65535) wird 
nicht runtergezählt. 0 ist das Zeichen das der Timer abgelaufen ist, und 
die höchste Zahl das der Timer aus ist. In den beiden Fällen wird der 
Timer nicht runtergezählt.

Die while-schleife

int main(void)

{
  inits();
  while(1)
  {
    if ( Timer1_done )
    {
      Timer1_set(30);
      // Mach was alle 30 ms
    }
    if ( Timer2_done )
    {
    }
    // usw.
  }
}

Jetzt achte ich nurnoch darauf das die nicht Zeitkritischen Teile sehr 
schnell fertig sind. Also nicht deutlich über eine ms. Es muss ja nicht 
nach den Timer geschaut werden. Man kann auch schauen ob Daten am UART 
angekommen sind. Bei mir werden sie von einer interruptroutine in eine 
ringbuffer geschrieben und in der while-schleife wird nurnoch gepollt ob 
was im Buffer steht, das ist ja dann nichtmehr zeitkritisch.

Durch den Timer hat man ein SEHR einfachen Prozess-Scheduler, dieser 
wird keine Funktion unterbrechen, man muss also selber dafür sorgen das 
diese nicht zu lange dauern.

ps:
es ist nichts großartiges, bloß habe ich in letzter Zeit Programme von 
"Profis" gesehen, die alles andere als "sauber" waren. Nicht hier, keine 
sorge. Ich hoffe man erkennt auf was ich rauswill :-)

[ST (Gast)]

Zuerst ist meistens das Problem da dann wird eine Lösung gesucht.

Und nicht für eine super-Deluxe-Lösung ein passendes Problem 
geschaffen...

[Matthias L. (matze88)]

Hier hast du zwar eine "festere Zuteilung von Rechenzeit", meistens ist 
es jedoch besser, den Timer durchlaufen zu lassen, da man z.B. häufig 
auch zeitkritische Sachen ohne eigenen Interrupt hat, die dann eben im 
Timer passieren. Dann gibt es noch die Sachen, die unwichtiger sind: Im 
Timerinterrupt einfach ein Flag setzen, wenn diese Sache durchgeführt 
werden soll. Dann in der Main auf dieses Flag testen und es eben 
ausführen falls "es darf".

Hier besteht der große Unterschied zu deiner Lösung, dass man direkt 
noch mehr Prioritäten einführt und außerdem keine Rechenzeit 
"verschenkt", wenn der Timer noch nocht abgelaufen ist du also garnichts 
in der main tust. Klar ist das nicht immer nötig, aber manchmal hat man 
da ja vll doch was sinnvolleres zu tun. Außerdem ist das System etwas 
dynamischer, man hat eventuell für jede kleinste Systemfunktion ne 
eigene Priorität durch das Flag und braucht das nur irgendwie setzen 
(z.B. über irgendne IO) und schon wird das ausgeführt, sobald das 
nächste mal Zeit dazu ist.

Für kurze zeitkritische Absätze IN diesem Programm muss man halt kurz 
die Interupts deaktivieren.

[Andreas W. (Gast)]

gerade das Dynamische ist sehr fix. auch "relativ" zeitkritische Dinge 
können gepollt werden, oder müssen sogar. Wie merkt man die sonst.
Auch IO Ereignisse können gepollt werden.

Wichtig an so einen Konstrukt ist nur, das kein Programmteil über einen 
großen Zeitraum Zeit frisst.

Klar ist das nicht die Lösung allen, vor allem ist es auch viel zu 
billig um Überhaupt als Allheilmittel zu gelten.

Das größte was ich so gemacht habe, war ein Controller eines Busses. 
Dieser wurde vom Computer bedient, hat auf einen Bus angeschlossene 
Geräte bedient, auf Benutzereingaben gewartet, Temperatur und Feuchte 
gemessen und ein LCD angesteuert.
Für mich am wichtigsten war da, das der Benutzer/Computer nicht merkt 
das er warten muss. Es wirkte einfach nur zu jederzeit schnell, in den 
Zusammenhang fällt mir immer das Wort Schwupsidität ein :-)