Das Schneider CPC Systembuch

Die Firmware des Schneider CPC

KERNEL

Die Zentrale

BCC8: KL CHOKE OFF

Setze den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
zurück.

Eingaben:    keine
Ausgaben:    LOW KERNEL JUMPBLOCK: 000B:  LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
=ROM-Select-Adresse des laufenden Vordergrund-Programms DE=Kaltstartadresse des laufenden Vordergrund-Programms C =Die Z80: Wirkung der Z80-Befehle auf die FlagsFlag: &FF -> Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM- / &00 -> RAM-Vordergrund-Programm Unverändert: IX,IY

KERNEL: BCC8: KL CHOKE OFFKL CHOKE OFF wird hauptsächlich von &MACHINE PACK: BD13: MC BOOT PROGRAMBD13 MC BOOT PROGRAM benutzt, und dafür sind auch die Ausgabe-Parameter gedacht. Schlägt ein Lade-Vorgang Der Linien-Algorithmus: Fehler 3fehl, orientiert sich MACHINE PACK: BD13: MC BOOT PROGRAMMC BOOT PROGRAM an diesen Werten von KERNEL: BCC8: KL CHOKE OFFKL CHOKE OFF, um zu einem lauffähigen Vordergrund-Programm zurückzukehren. Sind C und DE gleich Real: NullNull, so erfolgte der Aufruf von einem anderen RAM-Vordergrund-Programm aus. MACHINE PACK: BD13: MC BOOT PROGRAMMC BOOT PROGRAM kehrt im Fehlerfall dann zum Default-Vordergrund-ROM 0 (Basic-ROM) zurück.

KERNEL: BCC8: KL CHOKE OFFKL CHOKE OFF löscht die Synchronous-Pending-Queue und alle Ticker-Chains bis auf die Der Kernel - Software-Interrupts: EventsEvents des Sound-Managers und der Der Key Manager: Tastatur-AbfrageTastatur-Abfrage. Außerdem wird der Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt verboten, was aber bei Aufruf über diesen Vektor (der mit einem ROM-Konfiguration: RestartsRestart gebildet ist) nicht weiter interessiert, da dieser Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupts ja wieder zulässt.

BCCB: KL ROM WALK

Suche und initialisiere alle Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs.

Eingaben:    DE=Adresse des 1. Datentypen: Bytes
Datenbreite: Bytes
Bytes
des freien Speicherbereiches (incl.) HL=Adresse des letzten Datentypen: Bytes
Datenbreite: Bytes
Bytes
(incl.) Ausgaben: DE=Adresse des 1. Datentypen: Bytes
Datenbreite: Bytes
Bytes
des freien Speicherbereiches (incl.) HL=Adresse des letzten Datentypen: Bytes
Datenbreite: Bytes
Bytes
(incl.) Unverändert: IX,IY

CPC 464: Es werden alle ROM-Nummern von 1 bis 7 abgeklappert. Jedes Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM (Kennung &01 auf Adresse &C000) wird initialisiert.

CPC 664 und 6128: Es werden alle ROMs-Nummern von 0 bis 15 berücksichtigt. Vor der Initialisierung eines Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs wird noch getestet, ob es nicht vielleicht das laufende Vordergrund-ROM ist, das sich dann nicht wieder selbst initialisieren darf.

Das ist interessant weil das AMSDOS-ROM, das als Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM normalerweise die ROM-Select-Adresse 7 hat, nach Durchtrennen einer einzigen Leiterbahn auf der Platine zum Power-Up-ROM mit der ROM-Adresse 0 wird (und das Basic-ROM auf dieser Adresse ausblendet). Durch eine entsprechende Programmierung der Initialisierungs-Routine dieses Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs wird der Schneider CPC damit zum CP/M-Rechner. Obwohl dieses Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM jetzt immer noch im ROM-Header als Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM deklariert ist, ist es jetzt de facto das laufende Vordergrund-ROM.

Die Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs werden initialisiert, indem &KERNEL: BCCE: KL INIT BACKBCCE KL INIT BACK aufgerufen wird. Dort ist auch die Parameter: Parameter-ÜbergabeParameter-Übergabe beschrieben.

BCCE: KL INIT BACK

Initialisiere ein bestimmtes Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM.

Eingaben:     C=ROM-Select-Adresse des gewünschten Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs
             DE=Adresse des ersten Datentypen: Bytes
Datenbreite: Bytes
Bytes
des freien Speicherbereiches (incl.) HL=Adresse des letzten Datentypen: Bytes
Datenbreite: Bytes
Bytes
(incl.) Ausgaben: DE=Adresse des ersten Datentypen: Bytes
Datenbreite: Bytes
Bytes
des freien Speicherbereiches (incl.) HL=Adresse des letzten Datentypen: Bytes
Datenbreite: Bytes
Bytes
(incl.) Unverändert: C,IX,IY

CPC 464: Das gewünschte Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM wird nur initialisiert, wenn es sich auch um ein Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROM handelt, und die ROM-Select-Adresse im Bereich 1 bis 7 liegt.

CPC 664 und 6128: Wie bei &KERNEL: BCCB: KL ROM WALKBCCB KL ROM WALK sind jetzt zusätzlich Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs im Bereich 0 bis 15 erlaubt. Ebenfalls wird nun vorher getestet, ob das zu initialisierende Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM nicht vielleicht das laufende Vordergrund-ROM ist.

Im Schneider CPC wird das frei verfügbare RAM dynamisch zugeteilt: Sobald der Rechner zurückgesetzt ist, wird das Vordergrund-Programm aufgerufen. Dabei übergibt der MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
im HL- und DE-Register die Unter- und Obergrenze des frei verfügbaren RAMs. Das Vordergrund-Programm kann sich davon zunächst oben und unten einen Bereich für den eigenen Gebrauch reservieren (einfach, indem es die Registerwerte anpasst) und sollte dann das oder die Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs initialisieren. Diese übernehmen nun ihrerseits die Grenzen, reservieren sich einen bestimmten Bereich und geben die neuen Grenzen zurück. Ist das letzte ROM initialisiert, erhält auch das Vordergrund-Programm in DE und HL den nun noch verbliebenen freien RAM-Bereich zurück.

Es ist zu beachten, dass Speicheraufteilung durch ein Vordergrund-Programm: Hintergrund-ROMsHintergrund-ROMs nicht erwarten können, dass sie ihren RAM-Bereich immer an der selben Stelle zugeteilt bekommen! Als Erleichterung wird aber beim &0018 FAR Maschinencode über HIMEM: CALLCALL (LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALLRST_3) in ein bestimmtes Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM immer das IY-Register auf den Wert gesetzt, den die Initialisierungs-Routine des Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs im HL-Register zurückgegeben hatte.

Alle Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs müssen einen ROM-Header haben, der die ersten Datentypen: Bytes
Datenbreite: Bytes
Bytes
beansprucht. Dieser Amsdos: HeaderHeader ist wie folgt aufgebaut:

&C000 - DEFB ROMTYP    - Vorder/Hintergrund/Erweiterungs-ROM
&C001 - DEFB MARKNR    - Mark Number          \
&C002 - DEFB VERSION   - Version Number        > Statistics
&C003 - DEFB MODIFI    - Modification Level   /
&C004 - ff             - Resident System Extensions: external command tableExternal Command Table

Der erste Eintrag in der Tabelle externer Kommandos muss die Initialisierungs-Routine des entsprechenden Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs sein. Der Aufbau dieser Tabelle ist bei &KERNEL: BCD1: KL LOG EXTBCD1 KL LOG EXT beschrieben.

BCD1: KL LOG EXT

Mache dem MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
eine RSX-Erweiterung bekannt.

Eingaben:    BC zeigt auf Kommandotabelle
             HL zeigt auf 4 Datentypen: Bytes
Datenbreite: Bytes
Bytes
RAM für den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
Ausgaben: keine Unverändert: AF,BC,HL,IX,IY

Maschinencode auf dem CPC: Resident System ExtensionsResident System Extensions (Maschinencode über HIMEM: RSXRSX) werden vom Hauptprogramm meist erst in's RAM nachgeladen und dann initialisiert. Solche Zusatzprogramme müssen ihre eigene Lage und die Lage ihrer Datenfelder mit dem Hauptprogramm selbst auskluengeln.

Es ist dabei Aufgabe dieser Zusatzprogramme sich selbst dem MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
vorzustellen. Unterbleibt dies, kann das Hauptprogramm nur bei genauer Kenntnis aller Einsprungsadressen auf die jeweiligen Routinen zugreifen.

Nach der Einbindung als Maschinencode über HIMEM: RSXRSX (mit diesem Vektor) sind diese Routinen aber dem MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
mit Namen bekannt, was einen Lage- unabhängigen auf sie ermöglicht.

Sowohl die Kommandotabelle als auch die freien 4 Datentypen: Bytes
Datenbreite: Bytes
Bytes
müssen im zentralen RAM liegen (&4000 bis &BFFF). Die Kommandotabellen der Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs müssen an der angegebenen Stelle im Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM selbst liegen.

Die Kommandotabelle besteht aus zwei Teilen:

1. Jumpblock
DEFW BCD1: KL LOG EXT: 2. Namenstabelle (NAMTAB)NAMTAB   - Zeiger auf die Namenstabelle
JP NAME1      - Vektor zum ersten Eintrag
JP NAME2      - Vektor zum zweiten Eintrag
....
2. Namenstabelle (NAMTAB)
DEFM "name 1"
DEFM "name 2"
....
DEFB 0

Der BCD1: KL LOG EXT: 1. JumpblockJumpblock muss so viele Vektoren umfassen, wie in der Namenstabelle Namen eingetragen sind. Die Vektoren können auch mit ROM-Konfiguration: RestartsRestarts gebildet sein.

Jeder Eintrag in der Namenstabelle kann bis zu 16 Buchstaben lang sein. Der letzte Buchstabe muss dabei jeweils mit &80 geodert sein (Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
7 gesetzt). Abgeschlossen wird diese Tabelle mit einem Nullbyte.

BCD4: KL FIND COMAND

Erfrage zum angegebenen Namen einer Maschinencode über HIMEM: RSXRSX oder eines Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs die Ausführungsadresse und Speicherkonfiguration.

Eingaben:    HL zeigt auf den Kommando-Namen. Im letzten Buchstabe des Namens
             muss Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
7 gesetzt sein. Ausgaben: CY=0 -> nicht gefunden CY=1 -> gefunden. HL=Adresse und C=ROM-Select-Byte Unverändert: IX,IY

Die zurückgegebenen Werte sind geeignet, um mit &001LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
KL
FAR PCHL direkt die Routine aufrufen zu können. Benötigt man aber auch das C- oder HL-Register für die Parameter: Parameter-ÜbergabeParameter-Übergabe, so muss man sich meist erst eine FAR ADDRESS basteln, um dann &0018 MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
KL
FAR Maschinencode über HIMEM: CALLCALL (LOW KERNEL JUMPBLOCK: 0018 - RST 3: LOW FAR CALLRST_3) aufzurufen.

Diese Routine durchsucht alle Kommandotabellen, ob sie nun von einer Maschinencode über HIMEM: RSXRSX stammen oder in einem Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROM liegen. Dabei werden die zuletzt angefügten Tabellen zuerst durchsucht. Das ist wichtig, da bei gleichbenannten Routinen immer nur die erste gefunden wird. Die andere wird 'verdeckt'. Die Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs werden von ROM-Nummer 0 an aufwärts durchsucht, bis zur ersten unbenutzten ROM-Nummer über 7 (CPC 464) bzw. 15 (CPC 664 oder 6128).

Wird das Kommando in einem Vordergrund-ROM gefunden, wird ein Kaltstart dieses Programmes durchgeführt. Dann kehrt MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
KL
FIND Befehls-Elemente: CommandsCOMMAND nicht mehr zurück!

BCD7: KL NEW FRAME FLY

Initialisiere einen Datenblock und füge ihn in die Trees: ListenListe aller Software-Unterbrechung bei jedem Strahlrücklauf des Bildschirms ein.

Eingaben:    HL zeigt auf den FRAME FLYBACK Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
              LOW KERNEL JUMPBLOCK: 000B:  LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
= EVENT-Klasse (express, Priorität o.Ä.) C = ROM-Select-Byte für die EVENT-Routine DE = Adresse der EVENT-Routine Ausgaben: keine Unverändert: BC,IX,IY

Der mit HL angezeigt Die Speicherkonfiguration im Schneider CPC: BlockBlock wird entsprechend LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
, C und DE initialisiert, der Kick Counter auf 0 eingestellt und der Die Speicherkonfiguration im Schneider CPC: BlockBlock in die FRAME FLYBACK Datenspeicherung und Datenstrukturen: ChainsCHAIN eingehängt, falls er nicht schon eingehängt ist. Die angegebene Routine wird nun mit jedem Strahlhochlauf im Monitorbild aufgerufen. Der FRAME FLYBACK Die Speicherkonfiguration im Schneider CPC: BlockBLOCK muss im zentralen RAM-Bereich liegen und besteht aus 2 freien Datentypen: Bytes
Datenbreite: Bytes
Bytes
für den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
(Kettungspointer) und einem Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK (7 Datentypen: Bytes
Datenbreite: Bytes
Bytes
lang).

BCDA: KL ADD FRAME FLY

Füge einen fertigen Datenblock in die Trees: ListenListe aller Software- Unterbrechung bei jedem Strahlrücklauf ein.

Eingaben:    HL zeigt auf den FRAME FLYBACK Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: BC,IX,IY

Der mit HL angezeigte Die Speicherkonfiguration im Schneider CPC: BlockBlock muss fertig initialisiert sein und wird vom MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
in die FRAME FLYBACK Datenspeicherung und Datenstrukturen: ChainsCHAIN eingehängt, wenn er sich noch nicht darin befindet. Dieser Die Speicherkonfiguration im Schneider CPC: BlockBlock muss im zentralen RAM-Bereich liegen und besteht aus zwei Datentypen: Bytes
Datenbreite: Bytes
Bytes
für den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
(Kettungspointer) und einem Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK.

BCDD: KL DEL FRAME FLY

Entferne einen Datenblock aus dieser Trees: ListenListe.

Eingaben:    HL zeigt auf den FRAME FLY Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: BC,IX,IY

Wenn der angezeigte Die Speicherkonfiguration im Schneider CPC: BlockBlock in der FRAME FLYBACK Trees: ListenLISTE ist, wird er ausgehängt. Dadurch wird dieser Die Speicherkonfiguration im Schneider CPC: BlockBlock nicht mehr angestoßen. Handelt es sich um ein Der Kernel - Software-Interrupts: Synchrone Eventssynchrones Event, so können aber noch einige Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupts ausstehen, die noch abgearbeitet werden. Um auch das zu verhindern, muss man auch noch &KERNEL: BCF8: KL DEL SYNCHRONOUSBCF8 KL DEL SYNCHRONOUS aufrufen.

BCE0: KL NEW FAST TICKER

Initialisiere einen Datenblock und füge ihn in die Trees: ListenListe aller Software-Unterbrechung bei jedem Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt ein.

Eingaben:    HL zeigt auf den FAST TICKER Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
              LOW KERNEL JUMPBLOCK: 000B:  LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
= EVENT-Klasse (asynchron, Priorität o.Ä.) C = ROM-Select-Byte für die Event-Routine DE = Adresse der Event-Routine Ausgaben: keine Unverändert: BC,IX,IY

Der durch HL angezeigt Die Speicherkonfiguration im Schneider CPC: BlockBlock wird entsprechend LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
, C und DE initialisert, der Kick Counter auf 0 eingestellt und der Die Speicherkonfiguration im Schneider CPC: BlockBlock in die FAST TICKER Datenspeicherung und Datenstrukturen: ChainsCHAIN eingehängt, wenn er sich nicht bereits in ihr befindet. Damit wird mit jedem Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt (300 mal pro Sekunde) die entsprechende Routine aufgerufen. Der FAST TICKER Die Speicherkonfiguration im Schneider CPC: BlockBLOCK muss im zentralen RAM liegen und besteht aus zwei freien Datentypen: Bytes
Datenbreite: Bytes
Bytes
für den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
(Kettungspointer) und einem Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK.

BCE3: KL ADD FAST TICKER

Füge einen fertigen Datenblock in die Trees: ListenListe aller Software-Unterbrechungen bei jedem Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupt ein.

Eingaben:    HL zeigt auf den FAST TICKER Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: BC,IX,IY

Wie &KERNEL: BCE0: KL NEW FAST TICKERBCE0 KL NEW FAST TICKER, nur dass der Die Speicherkonfiguration im Schneider CPC: BlockBlock bereits vollständig initialisert sein muss.

BCE6: KL DEL FAST TICKER

Entferne einen Datenblock aus dieser Trees: ListenListe.

Eingaben:    HL zeigt auf den FAST TICKER Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: BC,IX,IY

Der durch HL angezeigt Die Speicherkonfiguration im Schneider CPC: BlockBlock wird aus der FAST TICKER Datenspeicherung und Datenstrukturen: ChainsCHAIN wieder ausgehängt, wenn er sich noch darin befindet. Dadurch wird die entsprechende Routine nicht mehr angestoßen. Bei Der Kernel - Software-Interrupts: Synchrone Eventssynchronen Events können aber noch Kicks ausstehen, die dann noch abgearbeitet würden. Um das zu verhindern, muss man auch noch &KERNEL: BCF8: KL DEL SYNCHRONOUSBCF8 KL DEL SYNCHRONOUS aufrufen.

BCE9: KL ADD TICKER

Füge einen Datenblock in die Trees: ListenListe des Universal-Timers ein.

Eingaben:    HL zeigt auf den TICKER Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
             DE = Startverzögerung (Count Down)
             BC = Wiederholverzögerung (Reload Count)
Ausgaben:    keine
Unverändert: BC,IX,IY

Der durch HL angezeigt Die Speicherkonfiguration im Schneider CPC: BlockBlock wird in die TICKER Datenspeicherung und Datenstrukturen: ChainsCHAIN eingehängt, wenn er sich nicht bereits darin befindet. Der im BCE9: KL ADD TICKER: TickerblockTickerblock enthaltene BCEF: KL INIT EVENT: EventblockEventblock muss vollständig initialisiert sein. Der BCE9: KL ADD TICKER: TickerblockTickerblock muss sich im zentralen RAM befinden und ist wie folgt aufgebaut:

Tickerblock
2 Datentypen: Bytes
Datenbreite: Bytes
Byte
Platz für den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
(Kettungspointer) 2 Datentypen: Bytes
Datenbreite: Bytes
Byte
Count Down 2 Datentypen: Bytes
Datenbreite: Bytes
Byte
Reload Count 7 Datentypen: Bytes
Datenbreite: Bytes
Byte
Der Kernel - Software-Interrupts: EventsEvent Die Speicherkonfiguration im Schneider CPC: BlockBlock

Der normale TICKER ist der universellste von allen Software-Timern: 50 mal in der Sekunde wird diese Trees: ListenListe abgearbeitet. Dabei wird zunächst nur der Count-Down-Wert heruntergezählt und dann erst die Routine angestoßen. Mit jedem Kick wird dann der Reload-Wert in den Count Down geladen, und dieser dann von neuem heruntergezählt. Ein Nachladewert 0 blockiert jedoch weitere Kicks. Der Die Speicherkonfiguration im Schneider CPC: BlockBlock verbleibt zwar in der Trees: ListenListe (und verbraucht nach wie vor Rechenzeit), wird aber nicht mehr angestoßen. Mit Hilfe dieses Mechanismus werden EVERY und AFTER in Einleitung: BASIC
Anhang: Basic
Basic
realisiert.

BCEC: KL DEL TICKER

Entferne einen Datenblock aus der Trees: ListenListe des Universal-Timers.

Eingaben:    HL zeigt auf den TICKER Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    CY=1 -> Der Die Speicherkonfiguration im Schneider CPC: BlockBlock war in der Trees: ListenListe
                     DE enthält den verbliebenen Wert aus dem Count Down
             CY=0 -> Der Die Speicherkonfiguration im Schneider CPC: BlockBlock war nicht in der Trees: ListenListe
Unverändert: BC,IX,IY

Der mit HL adressierte Die Speicherkonfiguration im Schneider CPC: BlockBlock wird aus der TICKER Datenspeicherung und Datenstrukturen: ChainsCHAIN entfernt, wenn er in ihr eingehängt war. Dann enthält DE den Rest aus dem Count Down (entspricht dem Basic-Befehl REMAIN). Dadurch wird dieser Die Speicherkonfiguration im Schneider CPC: BlockBlock nicht mehr angestoßen. Bei Der Kernel - Software-Interrupts: Synchrone Eventssynchronen Events (wie Einleitung: BASIC
Anhang: Basic
Basic
sie benutzt) werden die ausstehenden Kicks aber noch abgearbeitet. Soll auch das unterbunden werden, muss man noch &KERNEL: BCF8: KL DEL SYNCHRONOUSBCF8 KL DEL SYNCHRONOUS aufrufen.

BCEF: KL INIT EVENT

Fülle einen Event-Block vorschriftsmäßig mit den in Registern angegebenen Werten.

Eingaben:    HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
              LOW KERNEL JUMPBLOCK: 000B:  LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
= EVENT-Klasse (asynchron, Priarität o. AE.) C = ROM-Select-Byte für die Event-Routine DE = Adresse der Event-Routine Ausgaben: HL zeigt hinter den BCEF: KL INIT EVENT: EventblockEventblock, wurde also um 7 erhöht Unverändert: AF,BC,DE,IX,IY

Der BCEF: KL INIT EVENT: EventblockEventblock wird mit den in LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
, C und DE angegebenen Werten initialisiert und der Kick Counter wird auf 0 eingestellt. Der Die Speicherkonfiguration im Schneider CPC: BlockBlock muss im zentralen RAM-Bereich (&4000 bis &BFFF) liegen, damit der MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
vom Interrupt-Pfad aus jederzeit darauf zugreifen kann. Der BCEF: KL INIT EVENT: EventblockEventblock ist folgendermassen aufgebaut:

Eventblock
   2 Datentypen: Bytes
Datenbreite: Bytes
Byte
Platz für den MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
(Kettungspointer) 1 Datentypen: Bytes
Datenbreite: Bytes
Byte
Kick-Counter (Zähl- und Steuerbyte) LOW KERNEL JUMPBLOCK: 000B: LOW KL LOW PCHL
LOW KERNEL JUMPBLOCK: 001B: LOW KL FAR PCHL
LOW KERNEL JUMPBLOCK: 003B: LOW EXT INTERRUPT
B
: 1 Datentypen: Bytes
Datenbreite: Bytes
Byte
Class (BCEF: KL INIT EVENT: Event-ArtEvent-Art: Express/Asynchron/Priorität...) DE:2 Datentypen: Bytes
Datenbreite: Bytes
Byte
Adresse der Event-Behandlungsroutine C: 1 Datentypen: Bytes
Datenbreite: Bytes
Byte
ROM-Select-Byte (außer, wenn NEAR ADDRESS angegeben)

Der BCEF: KL INIT EVENT: EventblockEventblock ist normalerweise Teil eines TICKER, bzw. FAST TICKER oder FRAME FLYBACK Die Speicherkonfiguration im Schneider CPC: BlockBLOCKs. Auch für die Sound-Interrupts und das Break-Event muss so ein BCEF: KL INIT EVENT: EventblockEventblock eingerichtet werden. Bei Bedarf können auch EXTERNAL Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptINTERRUPTs mit Hilfe des Software-Interrupt-Mechanismus behandelt werden.

Man muss dabei säuberlich zwischen den Interrupt-Quellarten (die gerade aufgelistet wurden) und den BCEF: KL INIT EVENT: Event-ArtEvent-Arten unterscheiden. Ist ein Der Kernel - Software-Interrupts: EventsEvent nämlich erst einmal angestoßen, sieht man nicht mehr, woher der Kick kam. Die BCEF: KL INIT EVENT: Event-ArtEvent-Art wird dabei in Datentypen: Bytes
Datenbreite: Bytes
Byte
3 (Class) angegeben:

Event-Art
Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
0 =1 -> NEAR ADDRESS (-> ROM-Select-Byte bedeutungslos) Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
1-4 -> Priorität (nur bei Der Kernel - Software-Interrupts: Synchrone Eventssynchronen Events) Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 -> muss auf 0 gesetzt sein. Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
6 =1 -> EXPRESS Der Kernel - Software-Interrupts: EventsEVENT Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
7 =1 -> ASYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT (Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bits
1-6 ohne Bedeutung)

Anm.: Die Port C - Output: &F6xx: Bits 0 bis 3:Bits 1 bis 6 werden benutzt, um eine Art 'Gesamt- Priorität' zu bilden. Durch ein gesetztes Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
6 erhalten alle Express-Events automatisch eine höhere Priorität als alle 'normalen'. Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 wird benutzt, um die Die Fließkomma-Routinen: FunktionenFunktion der Vektoren &KERNEL: BD04: KL EVENT DISABLEBD04 KL EVENT DISABLE und &KERNEL: BD07: KL EVENT ENABLEBD07 KL EVENT ENABLE zu realisieren. Durch ein gesetztes Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 werden ebenfalls alle 'normalen' Der Kernel - Software-Interrupts: EventsEvents übertrumpft.

BCF2: KL EVENT

Stoße einen Event-Block an. Dies führt zu einer Software-Unterbrechung.

Eingaben:    HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: IX,IY

Diese Routine ist dafür vorgesehen, vom Interruptpfad aus aufgerufen zu werden! Speziell ist hierbei an den EXTERNAL Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptINTERRUPT gedacht, um auch solchen Unterbrechungen den vollen Service des Event-Mechanismus bereitzustellen. Man kann sie zwar auch von einem normalen Programm aus aufrufen, doch ist das wohl nur in Ausnahmefällen sinnvoll.

Weil der für den Vektor verwendete ROM-Konfiguration: RestartsRestart (LOW KERNEL JUMPBLOCK: 0008 - RST 1: LOW LOW JUMPRST_1 LOW MAIN FIRMWARE JUMPBLOCK: JUMPER
Die Firmware des Schneider CPC: JUMPER
JUMP
) Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptInterrupts wieder zulassen würde, kann diese Routine vom Interruptpfad aus nicht über den Vektor aufgerufen werden. Dann muss man sich die Adresse aus dem Vektor herausklauben (Port B - Input: &F5xx: Bits 1, 2 und 3:
Port C - Output: &F6xx: Bit 6 und 7:
Bits 14 und
15 der Adresse zurücksetzen!) und die Routine direkt anspringen.

BCF5: KL SYNC RESET

Lösche die Trees: ListenListe aller synchronisierbaren Unterbrechungen, die noch auf ihre Ausführung warten.

Eingaben:    keine
Ausgaben:    keine
Unverändert: BC,DE,IX,IY

Alle Der Kernel - Software-Interrupts: EventsEvents, die noch in der SYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT PENDING QUEUE eingereiht sind, und auf ihre Ausführung warten, werden einfach vergessen. Die aktuelle Event-Priorität wird wieder auf 0 gesetzt.

In den so ausgehängten Event-Blocks werden keine Änderungen vorgenommen. Die QUEUE (eine verkettete Trees: ListenListe!) wird geleert, indem ihr Anfangszeiger einfach auf 0 gestellt wird.

Deshalb wird auch das Datentypen: Bytes
Datenbreite: Bytes
Byte
2 (Kick Counter) der BCEF: KL INIT EVENT: EventblockEventblocks nicht wieder auf 0 gestellt. Wird ein solcher BCEF: KL INIT EVENT: EventblockEventblock später wieder angestoßen, wird dann nur noch der Kick Counter erhöht, der Der Kernel - Software-Interrupts: EventsEvent Die Speicherkonfiguration im Schneider CPC: BlockBlock aber nicht in die PENDING QUEUE eingehängt (der MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
nimmt nämlich an, dass der Die Speicherkonfiguration im Schneider CPC: BlockBlock sich bereits darin befindet, weil er ja noch ein paar Kicks ausstehen hat). Der Die Speicherkonfiguration im Schneider CPC: BlockBlock ist de facto ruhiggestellt. Das laufende Programm muss selbst sicherstellen, dass die Kick Counter aller betroffenen BCEF: KL INIT EVENT: EventblockEventblocks auf 0 zurückgestellt werden.

BCF8: KL DEL SYNCHRONOUS

Stelle den BCEF: KL INIT EVENT: EventblockEventblock einer synchronisierbaren Unterbrechung ruhig und entferne ihn auch aus der Warteliste, falls er dort eingetragen ist.

Eingaben:    HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: IX,IY

Der durch HL angezeigte BCEF: KL INIT EVENT: EventblockEventblock wird ruhiggestellt und, falls nötig, aus der SYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT PENDIG QUEUE entfernt. Dadurch werden alle noch ausstehenden Kicks vergessen.

Um eine synchrone Der Kernel - Software-Interrupts: Interrupt-QuellenInterrupt-Quelle abzustellen, muss man erst den entsprechenden Die Speicherkonfiguration im Schneider CPC: BlockBlock aus der TICKER, FAST TICKER oder FRAME FLYBACK Datenspeicherung und Datenstrukturen: ChainsCHAIN entfernen, damit keine Kicks mehr erzeugt werden, und dann die ausstehenden Kicks mit diesem Vektor 'wegwerfen'. Die restlichen Der Kernel - Software-Interrupts: Interrupt-QuellenInterrupt-Quellen (EXTERNAL Alle noch folgenden Anschlüsse fallen unter die Rubrik STEUER- oder auch CONTROLBUS:: INT - InterruptINTERRUPT, BREAK oder Einleitung: Sound
MAIN FIRMWARE JUMPBLOCK: SOUND MANAGER
Die Firmware des Schneider CPC: SOUND MANAGER
SOUND
) müssen ähnlich behandelt werden.

BCFB: KL NEXT SYNC

Hole die nächste synchronisierbare Unterbrechung aus der Der Key Manager: WarteschlangeWarteschlange, falls noch eine wartet.

Eingaben:    keine
Ausgaben:    CY=0 -> die SYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT PENDING QUEUE ist leer
             CY=1 -> es war ein Die Speicherkonfiguration im Schneider CPC: BlockBlock in der QUEUE vorhanden
                     HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
                     Operationen: BD5B / 349A / 349A:  FLO SUBA=alte Event-Priorität
Unverändert: BC,IX,IY

War ein Die Speicherkonfiguration im Schneider CPC: BlockBlock in der SYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT PENDING QUEUE vorhanden, so wird er aus dieser entfernt. Außerdem wird die aktuelle Event-Priorität dem neuen Der Kernel - Software-Interrupts: EventsEvent angepasst. Dadurch kann die Der Key Manager: WarteschlangeWarteschlange auch gepollt werden, während ein Der Kernel - Software-Interrupts: Synchrone Eventssynchrones Event abgearbeitet wird. Der Kernel - Software-Interrupts: EventsEvents mit niedrigerer oder gleicher Priorität werden dann vom MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
einfach versteckt, wichtigere Unterbrechungen werden aber weitergemeldet, und können so die laufende Event-Routine noch einmal unterbrechen.

Nun muss &KERNEL: BCFE: KL DO SYNCBCFE KL DO SYNC aufgerufen werden! Dieser Vektor übernimmt die Block-Adresse aus dem HL-Register, und ruft die dort eingetragene Event-Behandlungsroutine auf.

Danach muss &KERNEL: BD01: KL DONE SYNCBD01 KL DONE SYNC aufgerufen werden, wofür alle Ausgabewerte von KERNEL: BCFB: KL NEXT SYNCKL NEXT SYNC benötigt werden. KERNEL: BD01: KL DONE SYNCKL DONE SYNC erniedrigt den Kick Count und fügt den Der Kernel - Software-Interrupts: EventsEvent Die Speicherkonfiguration im Schneider CPC: BlockBlock, falls nötig, wieder in die Pending Queue ein. Zum Schluss wird wieder die alte Event-Priorität eingestellt.

Es ist recht unverständlich, wieso diese drei Die Fließkomma-Routinen: FunktionenFunktionen nicht in einem Vektor zusammengefasst wurden. Sie können praktisch nur in folgendem Zusammenspiel aufgerufen werden:

        Maschinencode über HIMEM: CALLCALL KERNEL: BCFB: KL NEXT SYNCKL NEXT SYNC
        JR   NC,WEITER
        PUSH AF
        PUSH HL
        Maschinencode über HIMEM: CALLCALL KERNEL: BCFE: KL DO SYNCKL DO SYNC
        POP  HL
        POP  AF
        Maschinencode über HIMEM: CALLCALL KERNEL: BD01: KL DONE SYNCKL DONE SYNC
WEITER: ...

Variationsmöglichkeiten ergeben sich hauptsächlich nur durch den Einbau einer Schleife (Pollen, bis die Queue leer ist) und durch &HIGH KERNEL JUMPBLOCK: B921: HI KL POLL SYNCHRONOUSB921 HI KL POLL SYNCHRONOUS. Diese Routine testet nur, ob in der Pending Queue ein Die Speicherkonfiguration im Schneider CPC: BlockBlock wartet und ist dabei erheblich schneller als KERNEL: BCFB: KL NEXT SYNCKL NEXT SYNC, weil sie im RAM liegt und nicht über einen ROM-Konfiguration: RestartsRestart angesprungen werden muss.

BCFE: KL DO SYNC

Führe die mit &KERNEL: BCFB: KL NEXT SYNCBCFB geholte Unterbrechung aus.

Eingaben:    HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: IX,IY

Die Verwendung dieses Vektors ist bei &KERNEL: BCFB: KL NEXT SYNCBCFB KL NEXT SYNC beschrieben.

BD01: KL DONE SYNC

Muss nach &KERNEL: BCFE: KL DO SYNCBCFE aufgerufen werden.

Eingaben:    HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
             Operationen: BD5B / 349A / 349A:  FLO SUBA ist die alte Event-Priorität
Ausgaben:    keine
Unverändert: IX,IY

Dieser Vektor ist ebenfalls bei &KERNEL: BCFB: KL NEXT SYNCBCFB KL NEXT SYNC beschrieben.

BD04: KL EVENT DISABLE

Lege die Ausführung von normalen, synchronisierbaren Unterbrechungen auf Eis.

Eingaben:    keine
Ausgaben:    keine
Unverändert: AF,BC,DE,IX,IY

Wie bei &KERNEL: BCEF: KL INIT EVENTBCEF KL INIT EVENT erwähnt, bilden die Port C - Output: &F6xx: Bits 0 bis 3:Bits 1 bis 6 im Art-Byte (Class) eines Event-Blocks eine 'Gesamt-Priorität'. Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 soll dabei immer auf Real: NullNull gesetzt werden. Der MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
hat im RAM eine Speicherstelle, in der er entsprechend die Priorität des momentan bearbeiteten Der Kernel - Software-Interrupts: EventsEvent speichert (oder 0, falls zur Zeit kein Software-Interrupt bearbeitet wird). KERNEL: BD04: KL EVENT DISABLEKL EVENT DISABLE setzt einfach Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 in diesem Datentypen: Bytes
Datenbreite: Bytes
Byte
auf Eins. Dadurch ergibt sich eine 'Gesamt-Priorität', die höher ist, als die höchste Priorität eines 'normalen' Der Kernel - Software-Interrupts: Synchrone Eventssynchronen Events. Beim Pollen der SYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT PENDING QUEUE werden deshalb alle normalen Der Kernel - Software-Interrupts: EventsEvents verborgen, gerade so, als ob momentan ein Der Kernel - Software-Interrupts: EventsEvent mit der Priorität &X10000 bearbeitet würde.

Eigentlich nicht vorgesehen aber durchaus möglich ist es, dass ein express-synchrones Der Kernel - Software-Interrupts: EventsEvent KERNEL: BD04: KL EVENT DISABLEKL EVENT DISABLE aufruft. Dadurch wird dann auch die Behandlung aller Express-Events ausgesetzt, weil jetzt sowohl Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
6 als auch Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 gesetzt sind.

Wird KERNEL: BD04: KL EVENT DISABLEKL EVENT DISABLE oder auch &KERNEL: BD07: KL EVENT ENABLEBD07 KL EVENT ENABLE von einer Event-Behandlungsroutine aus aufgerufen, bleibt der Zustand von Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 nicht erhalten, wenn diese Routine mit 'RET' abgeschlossen wird. Dann wird nämlich mittels &KERNEL: BD01: KL DONE SYNCBD01 KL DONE SYNC die alte Priorität wieder restauriert.

Die Routine &KERNEL: BD07: KL EVENT ENABLEBD07 KL EVENT ENABLE hebt den Effekt von KERNEL: BD04: KL EVENT DISABLEKL EVENT DISABLE wieder auf, indem sie Datenbreite: Bits
Port B - Input: &F5xx: Bit 0:
Port B - Input: &F5xx: Bit 4:
Port B - Input: &F5xx: Bit 5:
Port B - Input: &F5xx: Bit 6:
Port B - Input: &F5xx: Bit 7:
Port C - Output: &F6xx: Bit 4:
Port C - Output: &F6xx: Bit 5:
Bit
5 zurücksetzt.

Einleitung: BASIC
Anhang: Basic
Basic
verwendet nur 'normale', Der Kernel - Software-Interrupts: Synchrone Eventssynchrone Events für seine Interrupt-Mechanismen. Die Basic-Befehle 'DI' und 'EI' rufen einfach KERNEL: BD04: KL EVENT DISABLEKL EVENT DISABLE bzw. &KERNEL: BD07: KL EVENT ENABLEBD07 KL EVENT ENABLE auf. Dadurch werden alle Der Kernel - Software-Interrupts: EventsEvents vom MAIN FIRMWARE JUMPBLOCK: KERNEL
Die Firmware des Schneider CPC: KERNEL
Kernel
verborgen, wenn der Basic-Interpreter zwischen zwei Befehls-Elemente: StatementsStatements pollt.

Einzige Ausnahme bildet dabei die BREAK-Behandlung: Hierfür wird ein express-synchrones Der Kernel - Software-Interrupts: EventsEvent benutzt. Deshalb kann man auch nach 'DI' noch breaken. Auch 'ON BREAK GOSUB' wird dadurch nicht beeinflusst.

BD07: KL EVENT ENABLE

Lasse die Ausführung von normalen, synchronisierbaren Unterbrechungen wieder zu.

Eingaben:    keine
Ausgaben:    keine
Unverändert: AF,BC,DE,IX,IY

Dieser Vektor ist mit &KERNEL: BD04: KL EVENT DISABLEBD04 KL EVENT DISABLE zusammen beschrieben.

BD0A: KL DISARM EVENT

Stelle einen BCEF: KL INIT EVENT: EventblockEventblock ruhig.

Eingaben:    HL zeigt auf den Der Kernel - Software-Interrupts: EventsEVENT Die Speicherkonfiguration im Schneider CPC: BlockBLOCK
Ausgaben:    keine
Unverändert: BC,DE,HL,IX,IY

Der BCEF: KL INIT EVENT: EventblockEventblock wird dadurch ruhiggestellt, dass der Kickzähler auf einen negativen Wert (-64) gesetzt wird. Noch ausstehende Kick-Behandlungen gehen dadurch verloren. Diese Routine ist nur für asynchrone BCEF: KL INIT EVENT: EventblockEventblocks gedacht.

Für Der Kernel - Software-Interrupts: Synchrone Eventssynchrone Events soll man &KERNEL: BCF8: KL DEL SYNCHRONOUSBCF8 KL DEL SYNCHRONOUS benutzen, da sich ein solches Der Kernel - Software-Interrupts: EventsEvent gerade in der SYNCHRONOUS Der Kernel - Software-Interrupts: EventsEVENT PENDIG QUEUE befinden könnte (weil es noch auf eine Kick-Bearbeitung wartet). Wird es dort nicht ausgehängt, wird es noch einmal aufgerufen.

Der TICKER-, FAST TICKER oder FRAME FLYBACK Die Speicherkonfiguration im Schneider CPC: BlockBLOCK, von dem der BCEF: KL INIT EVENT: EventblockEventblock eventuell ein Bestandteil ist, wird dadurch nicht aus seiner Trees: ListenListe entfernt. Eintreffende Kicks werden in Zukunft einfach ignoriert.

BD0D: KL TIME PLEASE

Erfrage den Stand des Interruptzählers.

Eingaben:    keine
Ausgaben:    DEHL enthält die Zeit in 1/300stel Sekunden
Unverändert: AF,BC,IX,IY

Für allgemeine Zeitmessungen lohnt es sich oft nicht, den CPC mit der Rechenzeit für einen BCEF: KL INIT EVENT: EventblockEventblock zu belasten. Verbrauchte Zeit lässt sich mit diesem Vektor bequem feststellen. In Einleitung: BASIC
Anhang: Basic
Basic
wird dieser Vektor für die reservierte Unterprogramme: VariablenVariable 'TIME' benutzt. Da dieser Zähler bei jedem Hardware-Interrupt weitergestellt wird, leidet seine Genauigkeit mit jedem Kassetten- oder Diskettenzugriff.

BD10: KL TIME SET

Stelle den Interruptzähler auf einen neuen Startwert.

Eingaben:    DEHL enthält den neuen Wert für den Interruptzähler
Ausgaben:    keine
Unverändert: BC,DE,HL,IX,IY

Der Zähler lässt sich auch stellen, um ihn beispielsweise an die Datums- und Uhrzeit-Eingabe in einem Programm anzupassen. Der gesamte Zeit-Messumfang des 4-Datentypen: Bytes
Datenbreite: Bytes
Byte
Zählers umfasst etwa 165 Tage.

BD5B: KL RAM SELECT

Nur CPC 6128.

Wähle eine neue BD5B: KL RAM SELECT: Mögliche RAM-Konfigurationen:RAM-Konfiguration aus.

Eingaben:    neue BD5B: KL RAM SELECT: Mögliche RAM-Konfigurationen:RAM-Konfiguration
Ausgaben:    alte BD5B: KL RAM SELECT: Mögliche RAM-Konfigurationen:RAM-Konfiguration
Unverändert: BC,DE,HL,IX,IY

Vom Speicher und Peripherie: Das PAL im CPC 6128PAL, das für die RAM-Auswahl zuständig ist, werden nur die Port B - Input: &F5xx: Bits 1, 2 und 3:
Port C - Output: &F6xx: Bit 6 und 7:
Bits 0, 1 und
2 ausgewertet. Die Die Speicherkonfiguration im Schneider CPC: ROM-KonfigurationROM-Konfiguration (ROM-Konfiguration: ROM-Status
Anschluss eines Zusatz-ROM: ROM-Status
ROM-Status
und ROM-Auswahl) bleibt davon unberührt, eingeblendete Erläuterung zu den Anschlüssen 40 bis 45: 42 - ROMEN (0)ROMs haben auch vor dem zusätzlichen RAM im CPC 6128 Priorität. Das Video-RAM kann sich nur in einem Die Speicherkonfiguration im Schneider CPC: BlockBlock der 'normalen' 64 kByte RAM befinden, im Extremfall kann die Die ICs im Überblick: Die CPU Z80
Das Innenleben der CPC-Rechner: Die CPU Z80
Die Anschlussbelegungen der wichtigsten ICs im CPC: Die CPU Z80
CPU
nicht auf den Bildschirmspeicher zugreifen, weil dieser sich in einem ausgeblendeten RAM-Block befindet.

Mögliche RAM-Konfigurationen:
    CPU-Adressviertel   Konfiguration wird    normale Lage
 Operationen: BD5B / 349A / 349A:  FLO SUBA  -0-  -1-  -2-  -3-  verwendet bei:        für Video-RAM
--- ------------------  --------------------- --------------
0  n0 - n1 - n2 - n3   Normalzustand           n3=Screen
1  n0 - n1 - n2 - z3   Einleitung: CP/MCP/M: BIOS, BDOS etc.   n1=Screen
2  z0 - z1 - z2 - z3   Einleitung: CP/MCP/M: TPA              (n1=Screen)
3  n0 - n3 - n2 - z3   Einleitung: CP/MCP/M: n3=Hash-Tabelle  (n1=Screen)
4  n0 - z0 - n2 - n3   Bankmanager             n3=Screen
5  n0 - z1 - n2 - n3   Bankmanager             n3=Screen
6  n0 - z2 - n2 - n3   Bankmanager             n3=Screen
7  n0 - z3 - n2 - n3   Bankmanager             n3=Screen

n = normale RAM-Bank    z = zusätzliches RAM

Valid HTML   Valid CSS