
FutureOS Caruh - 2021.10.27
============== - ----------

Lokalisation
------------
- FutureOS Caruh sitzt entweder im unteren RAM zwischen &0000 und &37FF.
  Oder: FutureOS Caruh sitzt im unterem ROM (mit FutureOS Autostart)

- Der Bereich von &4000 bis &7FFF dient zustzlich als Puffer fr Daten und
  die Task-Tabelle.


Oberflche
----------
- Text-Modus, 80 Zeichen x 25 Zeilen, (und/oder...)
  (Oben/Unten MODE 2. Mittelbereich MODE 1 fr Dartstellung von HGB/Icons)
  (Dazu msste der Modus durch Interrupts umgeschalten werden)

- Die Namen vierer Tasks werden in der untersten Zeile angezeigt
  Mit den Links- und Rechts-Pfeilen kann man durch die aktiven Tasks rollen.



=========
= Tasks =
=========
Speicher-Aufbau eines Tasks
---------------------------
Einsprung / Start / Ladeadresse eines jeden Tasks ist an Adresse &4000.
(Tasks bentigen keinen Header, das sie immer an Adresse &4000 geladen werden)
(Vorhandene Header werden ignoriert. Die Dateilnge darf maximal 16 KB sein)

Jeder Task belegt einen 16 KB Block (E-RAM Block) von &4000 bis &7EFF.
Aktuell werden dafr die ersten 512 KB Erweiterungs-Speicher genutzt.
Es sollen jedoch schon bald die vollen 4 MB E-RAM genutzt werden.


Aufbau eines jeden Tasks in seinem 16 KB Block:
-----------------------------------------------------------------------------
- &4000-&7EFF: Programm-Bereich - --> Applikationslnge maximal 15,75 KB
-----------------------------------------------------------------------------
- &7F00-&7FF7: Stack (jeder Task hat seinen eigenen Stack). 124 Elemente.
-----------------------------------------------------------------------------
- &7FF8-&7FF9: 16 Aktions- und Konfigurations-Bits (siehe unten)
-----------------------------------------------------------------------------
- &7FFA-&7FFB: 16 Bit E-RAM Auswahl des Tasks (&7FC4-&78FF)
-----------------------------------------------------------------------------
- &7FFC......: Wert der in die Teilzeit Variable (Task-Tabelle) kopiert wird
               (Also wie viele 1/300 Sekunden vor Task-Aufruf gewartet wird)
               Es handelt sich um das Prioritts-Byte.
-----------------------------------------------------------------------------
- &7FFD......: Nummer des Tasks &01-&FF (255 mgliche Tasks). Dynamisch!
	       (Variablen-Name in Caruh: TNUME)
-----------------------------------------------------------------------------
- &7FFE-&7FFF: Puffer fr den Stack-Pointer SP dieses Tasks (-> Umschalten).
  -> Das zu ladende Programm (ohne Header) ist also maximal &3F00 Bytes lang.
  -> Das zu ladende Programm (mit  Header) ist also maximal &3F80 Bytes lang.
  (Variablen-Name in Caruh: TSPSE)
-----------------------------------------------------------------------------
- Wenn ein Task nichts zu tun hat, so fhrt er einen 'DI:RST 7' aus.

Beim ersten Start eines Tasks wir der Spackpointer (SP) auf &7FF8 gesetzt.
-> So wird das erste 16 Bit Stack-Element in &7FF6/&7FF7 geschrieben.
   Dies ist blicherweise die Rcksprung-Adresse bei der Task-Umschaltung.

(Das Testen des Inhalts von Adresse &7FFB auf &7x erlaubt Integrittstest).


------------------------------------
- Aktions- und Konfigurations-Bits -
------------------------------------
Die Speicherstellen &7FF8 und &7FF9 eines jeden Tasks enthalten 16 Aktions- und
Konfigurations-Bits. Dazu kommen Reaktions-Bits, die vom Task gesetzt werden:

Speicheradresse &7FF8 (TCON8)
-----------------------------
- Bit 0: = 0 -> Task ist im Hintergrund (das ist der Normalzustand)
	 = 1 -> Task ist im Vordergrund aktiv, d.h. bernimmt Bildschirm,
                Tastaturabfrage etc. Dieses Bit wird von Caruh eingeschalten.
		Es wird/kann aber vom Task gelscht werden.
		(Foreground-Bit)

- Bit 1: = 0 -> Task kann kein Vordergrund-Task werden
	 = 1 -> Task kann als Vordergrund-Task geschalten werden
		Dieses Bit muss vom Task selbst gesetzt werden!
		(Switch-Bit)

- Bit 2: -> reserviert

- Bit 3: = 0 -> Normale Funktion -> Task arbeitet normal weiter...
	 = 1 -> Setzen dieses Bits bestimmt den Task zur Lschung!
		Dieses Bit wird von dem Task selbst gesetzt!
		(Kill-Bit)

- Bit 4: = 0 -> Der Task kann nicht gespeichert werden bzw. muss nicht extra
		mittels dem 'Save-Bit 7' darauf vorbereiter werden.
	 = 1 -> Dieser Task kann gesichert werden und sollte mittels des Bits 7
		darauf vorbereitet werden.
		Dieses Bit wird von dem Task selbst gesetzt!
		(Storable-Bit)

- Bit 5: = 0 -> Der Task wurde bisher nicht gespeichert
	 = 1 -> Der Task wurde gespeichert, nachdem das Save-Bit gesetzt wurde.
		Dieses Bit 5 wird vom System Caruh gesetzt, nach dem Sichern.
		(Das Hold-Bit 6 wurde zuvor vom Task selbst gesetzt)
		Dieses Bit 5 muss von dem Task selbst zurck gesetzt werden,
		wenn der Task mehrmals gesichert werden soll.
		(Secured-Bit)

- Bit 6: = 0 -> Task ist weiterhin in Arbeit -> nicht abspeichern!
	 = 1 -> Task kann jetzt vom System jederzeit gespeichert werden
		Dieses Bit muss von dem Task selbst gesetzt werden!
		(Hold-Bit)

- Bit 7: = 0 -> Normaler Ablauf
	 = 1 -> Das System verlangt vom Task sich auf sein Abspeichern 
		vorzubereiten. Sein Neustart erfolgt dann wieder an &4000
		(Save-Bit)

-------------------------------------------------------------------------------

Speicheradresse &7FF9 (TCON9)
-----------------------------
- Bit 0: -> reserviert
- Bit 1: -> reserviert
- Bit 2: -> reserviert
- Bit 3: -> reserviert
- Bit 4: -> reserviert
- Bit 5: -> reserviert
- Bit 6: -> reserviert
- Bit 7: -> reserviert

-------------------------------------------------------------------------------



Anzahl der Tasks
----------------
255 maximal (je 15,75 KB), entsprechend freiem E-RAM, 4 MB.



==========================
= Anforderungen an Tasks =
==========================
- Whrend des Aufruf von OS Funktionen die den Stackpointer SP nutzen mssen
  die Interrupts AUS und anschlieend wieder EINgeschaltern werden. Beispiel:

	DI		;Interrupts ausschalten
	CALL TERM_2	;OS Funktion aufrufen, die SP verndert
	EI		;Anschlieend Interrupts einschalten

  Entsprechende OS Funktionen sind in ROM A:
  - CUR_CPY
  - B8DIN
  - B16DIN
  - und alle TERM_2(?) OS Funktionen (wegen der Steuerzeichen!)

- Das OS ROM A muss immer eingeblendet bleiben!
  Wird das ROM gendert oder eine OS Funktion in den anderen OS ROMs B, C, D
  aufgerufen so mssen die Interrupts AUS und anschlieend wieder
  EINgeschaltern werden. Siehe Beispiel:

	DI		;Interrupts ausschalten
	LD   IX,LESC	;OS Funktion liegt in ROM C
	CALL ROM_A2C	;OS Funktion in ROM C
	EI		;Anschlieend Interrupts einschalten

- Tasks mssen ihre E-RAM Konfiguration beibehalten

- Tasks mssen den ROM/RAM Status beibehalten (Das obere ROM ist immer ein)
  Mssen z.B. Daten aus dem Bildschirmspeicher gelesen werden, so sind hierfr
  die Interrupts zeitweilig auszuschalten. Status des unteren ROMs beachten!

- Tasks bentigen keinen Header, das sie immer an Adresse &4000 geladen werden
  Tasks, die einen Header besitzen drfen inclusive des Headers nicht grer
  als 16 KB sein. Dateien grer 16 KB werden NICHT geladen / gestartet.

- Ein Task darf maximal 15,75 KB lang sein, denn oberhalb befinden sich Stack
  und Task-Variablen (siehe oben: 'Aufbau eines Tasks')

- Kooperative Tasks knnen zum nchsten Task weiterschalten, solange sie keine
  Aufgaben haben (z.B. Warten auf ein Ereignis etc.)
  Dies geschieht durch die Befehle:

	DI	;Interrupts ausschalen
	RST 7	;Interrupt-Eingang aufrufen

  Dabei ist der 'DI' Befehl ntig, um einem zeitgleich auftretendem Interrupt
  entgegen zu wirken. Ohne 'DI' knnte es zu fatalen Folgen kommen.
  Nach der Abarbeitung des 'RST 7' werden die Interrupts wieder eingeschalten.
  Die Befehlsfolge 'DI:RST 7' entspricht somit einem System-Interrupt.

- Jeder Task muss einige Bit der Aktions- & Konfigurations-Bits selbst setzen.
  Diese befinden sich in den Speicherstellen &7FF8 und &7FF9 (siehe oben!).

- Vollschirm-fhige Tasks sind fhig, den gesamten Bildschirm nutzen knnen.
  Solche Tasks haben in ihrem E-RAM selbst das Bit 1 (Switch-Bit) der Adresse
  &7FF8 gesetzt.
  Alle anderen Tasks (z.B. ohne Bildschirmausgabe) sollen dieses Switch-Bit
  lschen.
  Jeder Vollschirm-Task sollte das Bit 0 (Foreground-Bit) an der Adresse &7FF8
  regelmig lesen. Denn wenn es gesetzt ist, dann steht dem Task der gesamte
  Bildschirm zur Verfgung.
  Sollte die Taste 'ESC' gedrckt werden, dann sollte sich der Task wieder in
  den Hintergrund schalten. Dies geschieht durch das Lschen des Bits 0 an der
  Adresse &7FF8 im Task E-RAM.

- Will sich ein Task selbst beenden und aus dem System entfernen so setzt er
  das Bit 3 (Kill-Bit). Das System wird den Task bei Zeiten lschen.
  --> Konkret heit das der Task schreibt den Wert &08 an Adresse &7FF8 und
      kann denn den Task Manger aufrufen mittels 'DI:RST 7'.
      Anschlieend solle ein Sprung auf den vorigen 'DI' Befehl folgen.

- Speicherbare Tasks sind Tasks die mit dem System zusammenarbeiten um eine
  Kopie von ihnen abzuspeichern. Um dem System anzuzeigen, dass es sich um
  einen Speicherbaren Task handelt setzt der Task selbststndig das Bit 4
  (Storable-Bit) an der Adresse &7FF8 in seinem eigenen E-RAM.
  Tasks die keinen Wert darauf legen gespeicher werden zu knnen sollten bei
  ihrem Aufruf einmal dieses Bit 4 lschen.
  Ein Speicherbarer Task sollte regelmig berprfen, ob das System ihn jetzt
  speichern will. Dies ist der Fall wenn Caruh das Bit 0 (Save-Bit) setzt.
  Sobald also das Save-Bit an Adresse &7FF8 gesetzt wurde sollte der Task alle
  ntigen Schritte unternehmen um sich auf das Speichern vorzubereiten.
  Ist das Task bereit gesichert zu werden, dann muss der das Bit 6 (Hold-Bit)
  an Adresse &7FF8 setzen.
  Anschlieend findet das Speichern des Tasks statt, darm kmmert sich Caruh
  selbst.
  Sobald der Task erfolgreich von Caruh gesichert wurde, setzt Caruh das Bit 5
  (Secured-Bit) and E-RAM Adresse &7FF8.
  Dem Task ist nun bekannt, das er erfolgreich gespeichert wurden, das sollte
  nun das 'Secured-Bit' zurcksetzten und nach Adresse &4000 springen.

- Vom System Caruh gesicherte Tasks werden (wie jeder andere auch) an Adresse
  &4000 geladen und auch dort gestartet



----------------------------
- Funktionen fr die Tasks -
----------------------------
- Ein RST 1 ruft das Menu-System M_DISP2 auf (siehe CBM)

- Ein CALL &000B ruft den Fenster-Zeichner DR_WIN auf (siehe CBM)



-------------------
- Typen von Tasks -
-------------------
1. Ein Task kann ein Hintergrund Task sein
   - Darf Teile des Bildschirms reservieren und darauf schreiben
   Dabei ist Bit 0 an &7FF8 gelscht.
2. Ein Task kann von Caruh auf 'Vordergrund' geschalten werden
   - Es gibt immer nur einen Vordergrund Task, normalerweise ist das Caruh
   - Wird ein anderer Task zum Vordergrund-Task so darf er den gesamten
     Bildschirm nutzen.
   - Er muss allerdings auch die Kontrolle zurck geben knnen
   Dabei ist Bit 0 an &7FF8 gesetzt.
   Achtung: Um einen Task auf Vordergrund schalten zu knnen muss Bit 1 an
   -------- Adresse &7FF8 gesetzt sein. Dies wird vom Task selbst erledigt.
   - Der Druck auf die 'ESC' Taste schaltet den Task wieder in den Hintergrund.
     Dabei wird von Caruh selbst auf ESC geprft.



===================
= Task Verwaltung =
===================
Die Tasks werden dynamisch verwaltet. Task-Nummern knnen sich also ndern.

Es gibt zwei RAM Abschnitte die zur Task-Verweltung dienen:
- Task Variablen (diese sind im ersten Element der Task-Tabelle enthalten)
- Task Tabelle   (diese enthlt eine Element fr jeden Task von 1-255)


------------------
- Task-Variablen -
------------------
- &4000: Ein Byte zeigt auf die Nummer des aktuellen Tasks (TASK_AKT)
- &4001: Eine Byte Variable enthlt die Anzahl der vorhandenen Tasks (TASK_NUM)
- &4002: Ein Byte enthlt die Nummer des ersten Tasks der Task-Zeile (DIS_A_T)

- &400C/D: 16 Bit enthalten temprr den I/O E-RAM Select (neu geladener Task)
	   (Variablen-Name: TA_ESEL)
- &400E/F: 16 Bit enthalten temprren Zeiger auf XRAM_ Variablen (neuer Task)
	   (Variablen-Name: TA_OSEV)

- &4010: Hier beginnt das erste Element von Task#1 (16 Bytes)


- &BE02: Zentrales Kommunikations-Byte zwischen Caruh und den Tasks (CCON2)
	 Aufbau der Speicheradresse &BE02:
	 ---------------------------------
- Bit 0: = 0 -> Alle Tasks sind im Hintergrund (das ist der Normalzustand)
	 = 1 -> Ein Task ist im Vordergrund aktiv, d.h. bernimmt Bildschirm,
                Tastaturabfrage etc.
		Dieses Bit wird vom Task selbst eingeschalten, sobald der aktiv
		die Kontrolle ber den Bildschirm etc. bernommen hat.
		Dieses Bit MUSS aber auch vom dem Task selbst wieder gelscht
		werden, sobald der die Kontrolle ber den Bildschirm wieder an
		Caruh zurckgibt. 
		Beim Drck auf die ESC-Taste muss der Task den Bildschirm etc.
		wieder an Caruh zurckgeben. Dazu wird Bit 0 an &BE02 gelscht.

- Bit 1: -> reserviert
- Bit 2: -> reserviert
- Bit 3: -> reserviert
- Bit 4: -> reserviert
- Bit 5: -> reserviert
- Bit 6: -> reserviert
- Bit 7: -> reserviert


-----------------------------
Lokalisation der Task-Tabelle
-----------------------------
Die Task-Tabelle beginnt rechnerisch ab &4000 im Hauptspeicher. Ende max. &7FE0
(Ein Eintrag sollte 32 Bytes nicht berschreiben. Aktuell: 16 Bytes).

---------------------------
- Aufbau der Task-Tabelle -
---------------------------
- Die Task Tabelle beginnt rechnerisch ab &4000 im Haupt-RAM (&7FC0).
  Dabei ist das erste Element mit der Nummer '0' jedoch speziell belegt.
  (siehe oben unter 'Task-Variablen')
  Das erste reale Element beginnt also ab &4010 fr den ersten Task (#1).

- Jedes Element hat (max. 32 Bytes) aktuell: 16 Bytes
  0...: Task-Nummer
  1...: Teilzeit: Wie viele 1/300 Sekunden warten bis Task-Aufruf (Wert <> &00)
  2...: Wiederlade-Wert fr Teilzeit Variable (> &00) fr Byte 1
  3- 4: Task E-RAM (16 Bit, physikalisch &7FC4-&78FF)
  5-15: Namen des Tasks, entspricht dem Dateinamen (11 Buchstaben)

Da es keinen Task mit der Nummer &00 gibt stehen die Bytes &4000-&400F fr die
Task Variablen (s.o.) zur Verfgung.
Der Bereich von &7FE4-&7FFF wird fr Task 1 - also Caruh selbst - bentigt.



Umschalten der Tasks
--------------------
Der Interrupt fhrt an Adresse &0038. Dort geschieht folgendes:
1. Sichern ALLER Z80 Register auf lokalen Stack des Tasks
2. Sichern des Stackpointers SP in Task E-RAM in Adressen &7FFE-&7FFF
3. Teste ob es nur einen Task gibt -> dann die Umschaltung berspringen.
4. Testen ob der aktuelle Task der letzte in der Tabelle ist
   - Ja, dann Zeiger auf Task 1 setzen
   - Nein, dann Zeiger auf nchsten Task in Tabelle setzen
5. Lese Teilzeit (Byte 1) und Teilzeit-Wiederladewert (Byte 2) Variablen.
   Teilzeit Variable -1. Ist Variable = &00?
   Nein, dann gehe zu Punkt 4
   Ja, dann Teilzeit Variable (1) aus Wiederlade-Wert (2) neu laden, und...
6. E-RAM des neuen Tasks einblenden
7. Stackpointer SP aus neuem Task E-RAM laden (von &7FFE-&7FFF)
8. ALLE Register von lokalem E-RAM Stack restaurieren
9. EI:RETI fhrt in den nchsten Task



=============================
= Task-Funktionen von Caruh =
=============================

1. Task hinzufgen (laden und starten)
--------------------------------------
-> Datei markieren (CBM)
-> Test ob Tast-Datei mehr als 16 KB hat. Ja? Dann Abbruch!
-> Test ob Header vorhanden. Ja, dann vermerken (-> Ladeadresse auf &7F80)
-> Freies E-RAM (beginnend ab &78FF, also von oben her) suchen und
   zugehrige Daten zwischenspeichern

-> DI - Interrupts ausschalten!!!
-> Task von Medium in zuvor gefundenes E-RAM laden

-> Hauptspeicher (&7FC0) einblenden
-> Anzahl der Tasks (in &4001 RAM &C0) um 1 erhhen

-> Zuvor gefundenes / gemerktes 'E-RAM':
   - E-RAM in OS Systemvariablen als 'Task' markieren

   - E-RAM in Task Tabelle (&4010...) eintragen

-> Restlichen Eintrag fr Task-Tabelle generieren

-> E-RAM des neuen Tasks einblenden

   - E-RAM in 'E-RAM-Variable' des Tasks verbuchen
     Das ist fr jeden Task an den Adressen &7FFA-&7FFB

-> Task-Nummer des neuen Tasks in Task E-RAM eintragen an Adresse &7FFD
   Siehe dazu Task-Variable in &4001 in RAM &7FC0 - Daten zuvor merken!

-> SP in Task E-RAM auf &7FF6 - &14 = &7FE2 setzen, und...
   Schreiben dieses Werts ins Task E-RAM an Adressen &7FFE/&7FFF (SP Puffer)

-> Startadresse &4000 des Tasks oben auf Task-Stack legen, also in &7FF6/&7FF7

-> Hauptspeicher (&7FC0) einblenden

-> EI - Interrupts einschalten!!!



2. Task lschen (beenden und E-RAM freigeben)
---------------------------------------------
-> Task mittels Unterprogramm selektieren, Nummer in -> YL

-> Der Task mit der Nummer XX wird beendet, durch:

 - Das E-RAM des 'gelschten' Tasks wird in den Systemvariablen freigegeben.
   (durch LD (XRAM_??),&01 bzw. 4 MB Variablen)

 - Der entsprechende Eintrag in der Task-Tabelle wird gelscht:
   Und zwar durch das nach unten schieben nachfolgender Elemente der Tabelle.
   (um ein Element, also aktuell 16 Bytes).

 - Tasknummer aller Tasks mit einer Tasknummer > XX um je Eins erniedrigen:
   Dies geschieht sowohl in der Task-Tabelle als auch in den Task E-RAMs.

-> Die Anzahl der Tasks (&4001 in RAM &7FC0) wird um 1 erniedrigt.



3. Zeit-Anteil / Prioritt eines Tasks anpassen
-----------------------------------------------
-> Task mittels Unterprogramm selektieren, Nummer in -> YL

-> Der entsprechende Eintrag in der Task-Tabelle wird angepasst:
   Und zwar das 3. Byte (Wiederlade-Wert fr Teilzeit Variable).

-> Weiterhin wird im E-RAM des Tasks der Wiederlade-Wert fr Teilzeit Variable
   angepasst. Dieser Wert befindet sich in jedem Task E-RAM an Adresse &7FFC.


FutureOS Caruh ist selbst als Task (Nummer 1) eingetragen.
Dies geschieht beim Start von Caruh automatisch.



4. Schalten auf Vordergrund-Task / Bildschirm und Tastatur an Task bergeben
----------------------------------------------------------------------------
Dies geschieht entweder via Task-Funktion 'Schalten <a>uf' oder durch Anklicken
eines der vier Task Namen in der Task-Zeile (ganz unten auf dem Bildschirm).

-> Selektion eines Tasks via 'Schalten <a>uf'
   bzw. Klick auf Task-Name in Task-Zeile (unterste Zeile)

-> Berechnen der Task-Nummer
-> Berechnen der Adresse in der Task-Tabelle

-> E-RAM des selektierten Tasks einblenden

-> Byte von Speicherstelle &7FF8 (TCON8) lesen und auswerten:
   - Ist das Bit 1 gelscht, dann kann der Task kein Vordergrund-Task werden!
     ---> Abbrechen mit Fehlermeldung 'Hintergrund-Task' -> ABBRUCH!!! -> Caruh

   - Ist das 2. Bit allerdings gesetzt, so darf der Task als Vordergrund-Task
     geschalten werden. -> weiter...

-> Nun wird von Caruh das Bit 0 der Speicherstelle &7FF8 im Task E-RAM auf '1'
   gesetzt. 
   Dadurch wird dem Task mitgeteilt, dass er jetzt der Vordergrund-Task ist.
   -> Der Task kann nun die Kontrolle ber den Bildschirm und die Tastatur
      bernehmen.

-> Um Caruh mitzuteilen, da der Task die Bildschirm-Kontrolle bernommen hat,
   mu der Task das Bit 0 in der Speicherstelle &BE02 setzen.
   Sobald dieses Bit gesetzt ist wird Caruh die Bildschirm-Kontrolle abgeben.


=> An dieser Stelle wartet Caruh nun darauf, dass an Adresse &BE02 das Bit 0
   auf 1 gesetzt wird!
   Sollte das nicht passieren, dann wird Caruh nach einiger Zeit (90* DI:RST 7)
   die Kontrolle wieder bernehmen, da der Task unfhig dazu erscheint.
=> Sobald das Bit 0 an Adresse &BE02 auf 1 gesetzt ist wartet Caruh darauf,
   dass es zurck gesetzt wird um die Kontrolle von neuem zu bernehmen
   => Siehe nchsten Absatz


-> Dem neu gebackenen Vordergrund-Task stehen jetzt Bildschirm und Tastatur zur
   Verfgung!
   -> Sinnvoll ist es den Bildschirm erst mal zu lschen, den Bildschirm-MODE
      einzustellen und eventuell das Bildschirm-Format.

-> Der Vordergrund-Task nimmt seinen Verlauf...


Wie kann nun ein Vordergrund-Task die Kontrolle an Caruh zurckgeben?
---------------------------------------------------------------------
Wenn ein Task die Kontrolle ber Bildschirm und Tastatur bernomme hat, dann
muss er auch testen ob die ESC Taste gedrckt wird. Ist dies der Fall, so ist
die Kontrolle wieder an Caruh zurck zu geben.
Das selbe gilt auch falls der Task die Kontrolle einfach so zurckgeben will.

-> Der Task lscht das Bit 0 an Adresse &7FF8 (TCON8) in seinem eigenen E-RAM.
   Dadurch wird der Task zum Hintergrund-Task (Normalzustand).
   Aber der Task muss das ebenfalls Caruh mitteilen! Dies geschieht so...

-> Der Vordergrund-Task lscht ebenfalls das Bit 0 an Adresse &BE02 (CCON2)!

-> Sobald das Bit 0 an Adresse &BE02 gelscht ist bernimmt Caruh die Kontrolle
   von Bildschirm, Tastatur etc. wie gehabt. 
   Der ehemalige Vordergrund-Task ist nun wieder im Hintergrund ttig.

-> Caruh ist wieder im Vordergrund :-)


Beachte: Wenn der neu ernannte Fordergrund-Task nicht in der Lage ist das Bit 0 
-------- der Speicheradresse &BE02 auf 1 zu setzen, dann wird ihm nach 192
         Zyklen (192 mal 'DI:RST 7') der Vordergrund-Status entzogen!
         Das heit nichts anderes als da Caruh wieder die Kontrolle bernimmt.

































