// JP
0x00D6 Fehlerroutine mit Halt
0x00E0 Systemprüfung, Kein Fehler
0x012B RST 0x38
0x0140 ERROR
0x020E Systemprüfung, Kein Fehler
0x0307 Abfrage SIO-0-K2, Schlüsseleingelesen?
0x035D Lese SIO-0-K1 und K2
0x03D2 SIO-0-K1 und K2, Prüfe Status 0x0d08
0x043A Intitalsierung SIO-0-K2 und Alternativregistersatz
0x0477 Einsprungadresse (HL) im Stack Teil von 0x043A
0x0502 Bildung Wurmreihen LAMBDA Ein-Ausgabe
0x0537 Return-Trick ...
0x06EA Alternativregister umschalten, ?Blockchiffrierung?, Abfrage SIO-0-K2C
0x070B Einsprung aus 0x0259, 0x0278
0x086A Fehlerbehandlungsroutine:
0x0897 Fehler Systemhalt
0x0AA0 Einsprung INT-1 Routine
0x0BE2 POP/RETI
0x0BE9 NMI
0x1A41 Prüfprogramm RAM CHECK, Übergabe IX; Rückgabe Z-Flag
0x1A97 CRC1-16 nur für ROM
0xFF7C Programmfehler? Einsprung zum RAM ende und Neustart
//CALL
0x0208 A == M
0x032D Subroutine: SDCL bit 3 und 5 Prüfen
0x034D Abfrage Startzeichen STZ = 0x55
0x03B9 Lese SIO-0-K2
0x0415 Initialisierung SIO-0-K2C
0x042E Vorbereiten LAMBDA, SIO-0-K1C Initialisierung
0x04B6 Prüfe Bit 4 und 3 von Eingabe
0x0502 Bildung Wurmreihen LAMBDA Ein-Ausgabe
0x0538 Kopiere Ein- Ausgabe LAMBDA von 0x0d08 nach 0x2A00
0x0557 Rundenschlüssel erzeugen, Chiffrierung Daten mit Ergebnis LAMBDA
0x0598 Initalisierung Wurmreihe/ Dateneingabe für LAMBDA
0x0600 Aktivierung Alternativregistersatz, Steuer-Signale, Rückgabe (0x0e10, 0x0e11)[0x00, 0x0f]
0x0622 Rundenschlüssel mit Initalwert 0x87, Prüfe auf RAM1 und RAM2
0x066E Statussignal 0x0e11, Löschen 0x0e00 / 0x0f00 4 byte; Warteschleife
0x0686 Inital Speichern Alternativregister Teil1, INT gespeert
0x068B Inital Speichern Alternativregister Teil2
0x06AC Lese SIO-0-K2 bis 0x55 in 0x0d08; Abfrage STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0x075E De- Chiffrierung
0x07B7 Warte STZ ab, danach De- Chiffrierung
0x07BC De- Chiffrierung
0x0801 Initalwerte nach RAM1, CTC Zeitkonst. Übergabe HL, Warte auf INT17
0x0825 PIO-1-B-C, Über-Rückgabe BC, A, NZ/Z
0x0833 PIO-1-A-C, Rückgabe DE, A, NZ/Z
0x0843 SIO-0-K1C = 0x05, "B"; Übergabe B L0054:
0x0848 SIO-0-K2C = 0x05, "B"; Übergabe B L0070:
0x084D SIO-0-K1C = 0x03, "B"; Übergabe B L0068:
0x0857 SIO-0-K2C = 0x03, "B"; Übergabe B L0069:
0x0861 Warteschleife; Übergabe BC
0x08EE XOR-Verknüpfung Wurmreihe XOR Daten
0x0936 XOR 8 byte Block, (0x2a00++) = (0x2a00++) XOR (0x0d08--)
0x1000 Einlesen Schlüssel, Erstelle Rundenschlüssel
0x11D4 Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
0x1204 Blockrotieren Schlüssel3 RAM2:0x28b0 ... 0x28c7, RAM2 4*6 = 24 Bytes
0x121D 5 bytes rotieren 10*; Übergabe DE, Rückgabe im RAM (DE)+10
0x123c Schlüsseleinlesen Kennung 11011, Rückgabe C Wert, Start- Ende- Kennung
0x1244 SLS Lesen
0x1259 Prüfe CRC 16 im Speicherbereich 0x2800 bis 0x2888; Rückgabe Z-Flag; Rundenschlüssel
0x126F Prüf-Funktion Rundenschlüssel; Rückgabe Z-Flag
0x12AA Blockkopie Rundenschlüssel 0x2800; LAMBDA Ein-Ausgabe Initialwerte 0x87 ... Initale Bildung Wurmreihen
0x1800 LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
0x1AED CRC2-16, Übergabe DE, A; Rückgabe DE
//
// DB Bereiche
//
0x0299 DB Adress-Bereich, RAM Check 0x1a41
0x02b0 INT Tabelle
0x02d8 PIO-SIO Steuertabelle
0x08e6 SIO-0-K2C 8 Steuerbytes
0x12cf Schlüssel für Prüffunktion
0x1357 Initalwert 0x87
0x135f Prüfwerte Chiffrator-Test
0x1367 EPROM CRC
0x1400 K-Box
0x1a28 RAM Check Variablen
// CTC
//
0x80 Kanal 0
0x81 Kanal 1
0x82 Kanal 2
0x83 Kanal 3
// PIO Ports, 3 installierte U855
0x84 P0A-D Schlüssellochstreifenleser Bit 0 ... 4 + Transportspur - Lesetakt
0x85 P0B-D
0x86 P0A-C Schlüssellochstreifenleser Bit 0 ... 4 + Transportspur - Lesetakt
0x87 P0B-C
0x88 P1A-D
0x89 P1B-D
0x8a P1A-C
0x8b P1B-D
0x8c P2A-D
0x8d P2B-D Tasten/LED
0x8e P2A-C
0x8f P2B-C Tasten/LED
// Halpbduplex DEE <-> T-325, Halbduplex T-325 <-> DÜE
// LED 108 Betriebsbereitschaft an DUE
// 106 Betriebsbereitschaft an DEE
// 105.1 Sendebeginn Sendeseite DEE = 1; Ende Sendung = 0
// 105.2 Sendeleitung durchgeschaltet an DÜE
// 109.2 DÜE Träger ein, empfangsseitig T-325
// 106.2 T-325 Sendesitig zur DEE
// 106.1 T-325 == 1 wenn 105.1 UND 106.2 == 1
// 109.1 STZ erkannt, Synchronfolge geladen danach 109.1 = 1: Beginn Dechiffrierung! ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
// 109 8*0xff gesendet danach 109 = 0
// Pin CCITT-V24 Klartext
// 1 101 Masse
// 2 103 TxD -> Senden
// 3 104 RxD <- Empfangen
// 4 105 RTS -> Senden einschalten
// 5 106 CTS <- Sendebereitschaft
// 6 107 DSR <- Betriebsbereitschaft
// 7 102 Masse
// 8 109 DCD <- Träger erkannt
// 20 108 DTR -> Empfänger bereit
// 22 125 RI <- ankommender Ruf
77
// Duplex DEE <-> T-325, Halbduplex T-325 <-> DÜE
// LED 108 Betriebsbereitschaft an DUE
// 106 Betriebsbereitschaft an DEE
// 105.1 = 1
// 105.2 = 1
// 109.2 = 1
// 106.2 = 1
// 106.1 = 1
// 109.1 = 1; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
// 109 8*0xff gesendet danach 109 = 0
// Tasten:
// Rücksetzen RST 0x00, eingelsener Schlüssel bleibt erhalten wenn CRC korrekt ist.
// Start/Test BZ DÜT, Übetragung Testfolgen -> 0x0622 und 0x12AA Online Test
// Test Übergang Betriebszustand (BZ) Datenübertragungstest (DÜT); Nur im Betriebszustand Normalbetrieb (NB) -> 0x0622 und 0x12AA Online Test
// Anzeige Lampentest
// LED:
// 108.1 108.2 Betriebsbereitschaft der DEE (Computer)
// 107.1 107.2 Betriebsbereitschaft der DÜE (Modem)
// 105.1 105.2 Sendebeginn 105.1, 105.2 Weitergabe an DÜE
// 106.1 106.2 105.1 UND 106.2 aktiv dann 106.1 EIN, einschalten 106.2 T-325 empfangsbereit (109.2)
// 109.1 109.2 DÜE erkennt Täger Empfangsbereit 109.2
// Test A1
// Testende A2
// SE
// BLZ STV Bereit
// Datenaustausch immer im Halbduplex, Duplex Signalaustausch der Steuerleitungen
// Duplex immer Ein 105.1, 105.2, 106.1, 106.2, 109.1, 109.2
//
// EPROM CPU Karte
0x0000 ... 0x0bff // 3 kbyte
// RAM CPU Karte; Schlüselspeicher, SP
0x0c00 ... 0x0fff
//
// EPROM ROM/RAM Karte
// EPROM 0x1000 ... 0x1bff 3 kbyte
// RAM 0x2800 ... 0x2fff 2 kbyte; Speicher Rundenschlüssel, Ein-Ausgabe LAMBDA
// RAM Bereiche
//0x0c00 1 byte ... 0x45, Chiffrieren?
//0x0c01
//0x0c02 1 byte EPROM Kennung
//0x0c03 1 byte 0x45, Chiffrieren?
//0x0c04 1 byte 0x64
//0x0c05 1 byte 0x8a,
//0x0c06 1 byte 0x92,
//0x0c08 3 byte ... Schlüssel Kenngruppe des Schlüssellochstreifenabschnittes, nicht für die Chiffrierung nutzen
//0x0c0b 32 byte ... Schlüssel 256bit -> Kopie Rundenschlüssel, 0x88 bytes
//0x0c2b 2 byte ... Schlüssel CRCFalse
//0x0c2d 2 byte ... Schlüssel CRCTrue
//0x0c2f
// ...
//0x0c92 136 byte -> Ende Kopie Rundenschlüssel, 0x88 byte
//0x0c95 8 byte Ausgabe LAMBDA mit Initialwert 0x87, Wurmreihe abgelegt, für CFB?; Testfunktion Online
//0x0ce0 12 byte Rauschgenerator? 0x0cec wird mit beschrieben, IX erhält Zeiger
//0x0ce0 2 byte Zeiger auf 0x0cee
//0x0ce2 2 byte Zeiger auf 0x0cf7
//0x0ce4 1 Byte Schleifenvariable, Init = 8
//0x0ce6 1 Byte Schleifenvariable, Init = 0
//0x0ce9 1 Byte Schleifenvariable, Init = 8
//0x0ce9 4 bytes -> 0x05e0 0xcf9 nach 0x0d0a; kopiere 4 bytes ... Auszug aus Rauschgenerator Daten
//0x0cec 1 byte 0x40
//0x0ced 1 byte 0x16, 0x32 -> 0x0d09, 0x0f06 bis 0x0f08; 0x0e00 bis 0x0e0a
//0x0cee 9 byte ... Wurmreihe + Summe Wurmreihe; Rauschgenerator
//0x0cf7 9 byte ... Wurmreihe + Summe Wurmreihe; Rauschgenerator
//0x0d00 Prüfbyte? -> Invers
//0x0d01 -> Daten Byte -> 0x0548 kopiere nach 0x2a00 ...
//0x0d02 -> Daten Byte
//0x0d03 -> Daten Byte
//0x0d04 -> Daten Byte
//0x0d05 -> Daten Byte
//0x0d06 -> Daten Byte
//0x0d07 -> Daten Byte
//0x0d08 -> Daten Byte -> 0x03e4 0x16, 0x55; STZ Block?
//0x0d09 -> Daten Byte -> 0x0ced 0x16, 0x32; oder aus 0x0ced
//0x0d0a -> Daten Byte -> 0x05e0 0xcf9 nach 0x0d0a; kopiere 4 bytes ... Auszug aus Rauschgenerator Daten
//0x0d0b -> Daten Byte
//0x0d0c -> Daten Byte
//0x0d0d -> Daten Byte
//0x0d0e
//0x0d0f
//0x0d10 Status; 0x00
//0x0d11 ... Zähler, Schleifenzähler; 0x04cf 0x02
//
//0x0e00 -> Summe 0x2a0n+1, XOR 0x0d00
//0x0e01 -> GTX Byte 8
//0x0e02 -> GTX Byte 7
//0x0e03 -> GTX Byte 6
//0x0e04 -> GTX Byte 5
//0x0e05 -> GTX Byte 4
//0x0e06 -> GTX Byte 3
//0x0e07 -> GTX Byte 2
//0x0e08 -> GTX Byte 1 Senden
//0x0e0a -> Status
//0x0ec0 4 byte STZ-folge NUR Klartext
//0x0e10 Status; Werte 0x00, 0x08, 0x0a
//0x0e11 Status; Werte 0x04, 0x05, 0x0e, 0x0f; 0x0e/0x0f Senden-Empfangen Speicherbereich
//0x0ef5 ... 0eff = 0x55; STZ Folge?
//
//0x0f00 -> Summe 0x2a0n+1, XOR 0x0d00
//0x0f01 -> GTX Byte 8
//0x0f02 -> GTX Byte 7
//0x0f03 -> GTX Byte 6
//0x0f04 -> GTX Byte 5
//0x0f05 -> GTX Byte 4
//0x0f06 -> GTX Byte 3
//0x0f07 -> GTX Byte 2
//0x0f08 -> GTX Byte 1 Empfangen
//0x0f0a -> Status
//0x0fff ... Stackpointer
//
//0x2800 136 byte Rundenschlüssel für LAMBDA
//0x2880 88 byte RAM Rundenschlüssel
//0x2890 Arbeitskopien Rundenschlüssel
//0x28b0 Arbeitskopien Rundenschlüssel
//0x2a00 8 byte LAMBDA Ein- Ausgabe 0x2A00; Wurmreihen für XOR Verknüpfung mit Daten
//0x2a08 1 byte Prüfbyte Summe 0x2a00 bis 0x2a07
// Interrupt Programme Modus 2,
// !! In den INT-Routinen werden die alternativ Register verwendet !!
// 0x0951 INT-Nr.7 Lese SIO-0-K1D Empfange Daten, bis 0x2aff gefüllt ist
// 0x0986 INT-Nr.15 springt in INT-7 ließt SIO-0-K1D oder schreibt 0x16 in 0x0f01 bis 0x0f10
// 0x09b6 INT-Nr.3 Lese SIO-0-K2CD, 256 byte, Vergleiche (HL) Inhalte
// 0x09eb INT-Nr.11 Einsprung INT-3, Lese SIO-0-K2CD, Prüfe Startfolge; Übergabe SIO-0-K2C
// 0x0a3f INT-Nr.5 Einsprung INT 11, 3; Ausgabe SIO-0-K1D
// 0x0a6e INT-Nr.13 Einsprung INT-5, 11, 3; Ausgabe SIO-0-K1C
// 0x0a80 INT-Nr.1 Ausgabe SIO-0-K2CD
// 0x0ac4 INT-Nr.9 - weiter in INT-1 oder Error
// 0x0b0b INT-Nr.6 SIO-K1C
// 0x0b10 INT-Nr.2 SIO-K2C
// 0x0b15 INT-Nr.8 und 16 SIO-K1C
// 0x0b1a INT-Nr.4 und 12 SIO-K2C
// 0x0b1f INT-Nr.14 SIO-K1C
// 0x0b36 INT-Nr.10 SIO-K2C
// 0x0b4d INT-Nr.17 Rauschgenerator, ohne INT-Registersatz!
// Schlüssel f:\...\pdf\DV\MfS-Abt-XI-305-Schlüsselerzeugung-T311-T314-T317-325.pdf
// Schlüsseleinlesen, CRC f:\...\pdf\DV\MfS-Abt-XI-307-Schluesselunterlagen T3xx.pdf 14.10.1988
// Aus BArch XI-549, Bereichsprüfung der Sync-Folge auf 0x4d. Seite22
// Rauschquelle liefert 16byte Zufallsfolgen.
// Synchronfolgetest, es dürfen nicht 8 gleiche Zeichen auftreten
// Synchronfolge == 8bye lang
// RAM Test 5 Kontrollwerte in bestimmte RAMzellen gespeichert und geprüft
// Test 4; 1 ... 5,
// Datenausgabe aus den RAM Bereichen:0x0e00 ... 0x0eff bzw. 0x0f00 ... 0x0fff
// Trickreich über alternativregister D' Bit 1 = 1
// CRC Check ROM 2 ... 4 K-Box-1 und K-Box-2, LZS (K-Box) 1024bit
// CRC über Kenngruppe 3byte (24bit), Schlüssel 32 byte (256 bit)
// CRC ab Adr + 34 und Adr + 36
// Senden 7 bit
// Startzeichen STZ = 0x55
// Chiffrierung beginnt nach SYN Zeichen (BSC-Prozedure) der DEE an T-325
// Beginnt mit Klartext-Synchronfolge, 0x55, GTX
// Ende des GTX mit anschließenden 8 * 0xff
// letzter GTXBlock wird zwischengespeicherte als nächste Synchronfolge
// aus BArch*549
// Halbduplex Leitung 108 Betriebsbereitschaft an DÜE
// 107 Betriebsbereitschaft der DÜE an die DEE
// Sendebereitschaft DEE 105.1 aktiv
// 105.2 weiterleitung and DÜE, Einschalten des Trägers DÜE
// Empfang Träger 109.2 an T-325
// Einschalten 106.2 sendeseitig T-325
// Sendeseitig aktiv? 105.1 und
// 106.2 schaltet
// 106.1 Ein
// Sendeseite DEE-> T-325->DÜE SyncF Startzeichen STZ (0x55) und Beginn Chiffrierung eingehender Zeichen
// Empfangsseite wartet auf 0x55 lädt empfangene SyncF
// 109.1 Ein, Beginn Dechiffrierung
// SyncF = 64 bit, einmalig verwendet, nachfolgende GTX werden in die SyncF eingschrieben CFB-Betrieb; Cipher-Feedback Mode
// Duplex der Steuerleitung
// DCA Test Chiffrierung 0x87 in 75 Runden und Vergleich mit dem Dechiffrat. (0x4b)
----------------------------------------
Z80 DISASSEMBLER LISTING
Addr Opcodes Instruction
---------------------------------------- Kommentare
ORG 0x0000 // ROM 1 Start
0000 C3 69 00 JP 0x0069 // StartCPU
0003 7F // Füllbytes
...
0007 7F // Füllbytes
0008 C3 00 00 JP 0x0000 // RST 0x08
000B 7F // Füllbytes
...
000F 7F // Füllbytes
0010 C3 00 00 JP 0x0000 // RST 0x10
0013 7F // Füllbytes
...
0017 7F // Füllbytes
0018 C3 00 00 JP 0x0000 // RST 0x18
001B 7F // Füllbytes
...
001F 7F // Füllbytes
0020 C3 00 00 JP 0x0000 // RST 0x20
0023 7F // Füllbytes
...
0027 7F // Füllbytes
0028 C3 00 00 JP 0x0000 // RST 0x28
002B 7F // Füllbytes
...
002F 7F // Füllbytes
0030 C3 00 00 JP 0x0000 // RST 0x30
0033 7F // Füllbytes
...
0037 7F // Füllbytes
0038 C3 2B 01 JP 0x012B // RST 0x38
003B 7F // Füllbytes
...
0065 7F // Füllbytes
0066 C3 E9 0B JP 0x0BE9 // NMI-Programm
StartCPU:
0069 F3 DI // Sperre INT
006A 31 00 10 LD SP, 0x1000 // Unteres Ende des RAMS, auf der CPU Karte
006D 3E 02 LD A, 0x02 // Interruptprogramm High-Adresse 0x02nn
006F ED 47 LD I, A // nn wird mit OUT oder OTIR geladen
0071 ED 5E IM 2 // Setze Interrupt Modus 2
0073 21 00 0C LD HL, 0x0C00 // Start RAM Bereich 1, vor dem Schlüsselbereich
0076 06 08 LD B, 0x08 // Länge 8
0078 36 00 LD M, 0x00 <-\
007A 23 INC HL |
007B 10 FB DJNZ 0xFB >-/ // Lösche RAM, 0x0c00 ... 0x0c07 = 0x00
007D 21 D8 02 LD HL, 0x02D8 // PIO CTC Initialisierung
0080 16 09 LD D,0x09 // 9 PIO & CTC Initialisierungen
0082 46 LD B, M <-\ // Anzahl der Kommandos
0083 23 INC HL |
0084 4E LD C, M | // C Adresse der PIO I/O Kanäle
0085 23 INC HL | // Initialisierung CTC PIO anhand der Tabelle
0086 ED B3 OTIR | // Ausgabe (C)=M; B-1; HL+1; bis B = 0x00
0088 15 DEC D | // 9 Blöcke
0089 20 F7 JR NZ, 0xF7 >-/
008B 3E 03 LD A, 0x03
008D D3 85 OUT (0x85), A // PI0-0-B-D Alle LED Ein
008F 3E 1F LD A, 0x1F
0091 D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
// Intialisieren SIO-0-K1C, SIO-0-K2C
0093 3E 05 LD A, 0x05 // Register 5
0095 D3 8A OUT (0x8A), A // SIO-0-K1C
0097 3E 82 LD A, 0x82 // /WAIT/READY + Sendeunterbrechung erlauben
0099 D3 8A OUT (0x8A), A // SIO-0-K1C
009B 3E 05 LD A, 0x05 // Register 5
009D D3 8B OUT (0x8B), A // SIO-0-K2C
009F 3E 02 LD A, 0x02 // Sendeunterbrechung erlauben
00A1 D3 8B OUT (0x8B), A // SIO-0-K2C
00A3 01 00 00 LD BC, 0x0000
00A6 0B DEC BC <--\ // Zeitschleife 1 Sekunde
00A7 AF XOR A | // Lösche A, beeinflusse Flags
00A8 B0 OR B | // Zeitschleife für Bitausgabe PIO, Abfrage Input?
00A9 B1 OR C | // Länge 0xFFFF
00AA 20 FA JR NZ, 0xFA >-/
00AC 3E 01 LD A, 0x01
00AE D3 85 OUT (0x85), A // PI0-0-B-D
00B0 3E 01 LD A, 0x01
00B2 D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
// Intialisieren SIO-0-K1C, SIO-0-K2C
00B4 3E 05 LD A, 0x05 // Register 5
00B6 D3 8A OUT (0x8A), A // SIO-0-K1C
00B8 D3 8B OUT (0x8B), A // SIO-0-K2C
00BA 3E 00 LD A, 0x00 // Kein INT & Steuerung
00BC D3 8A OUT (0x8A), A // SIO-0-K1C
00BE D3 8B OUT (0x8B), A // SIO-0-K2C
00C0 DB 8C IN A, (0x8C) // PIO-1-A-D; Wert von? Bit 3 und 4 dürfen nicht gesetzt sein
00C2 E6 18 AND 0x18 // Maske über den Input
00C4 FE 18 CP 0x18 // Prüfe auf 0x18
00C6 CA D6 00 JP Z, 0x00D6 >--\ // Fehler System HALT
00C9 FE 10 CP 0x10 | // Prüfe auf 0x10
00CB CA 97 08 JP Z, 0x0897 | // Fehler System HALT
00CE FE 08 CP 0x08 | // Prüfe auf 0x08
00D0 CA 6A 08 JP Z, 0x086A | // Fehler System HALT; Fehlerbehandlungsroutine:
00D3 C3 E0 00 JP 0x00E0 | >--\ // Alles-OK
| |
Fehler Systemstop: | |
00D6 F3 DI <----/ | // Sperre INT
00D7 3E 01 LD A, 0x01 |
00D9 D3 85 OUT (0x85), A | // PI0-0-B-D
00DB 3E 05 LD A, 0x05 |
00DD D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
00DF 76 HALT | // Systemfehler HALT-Befehl, Kann durch NMI oder Reset aus dem HALT geholt werden
|
Alles-OK: | //
00E0 3E 01 LD A, 0x01 <---/
00E2 D3 85 OUT (0x85), A // PI0-0-B-D
00E4 3E 05 LD A, 0x05 // Register 5
00E6 D3 8A OUT (0x8A), A // SIO-0-K1C
00E8 3E 80 LD A, 0x80 // CTC Kanal 0; /WAIT/READY
00EA D3 8A OUT (0x8A), A // SIO-0-K1C
00EC DD 21 67 13 LD IX, 0x1367 // Tabelle ROM Adresse und CRC
00F0 FD 21 F7 00 LD IY, 0x00F7 // Rücksprungadresse IY
00F4 C3 97 1A JP 0x1A97 // CRC1-16 nur für ROM
Rücksprung aus EPROM CRC1-16, CRC der EPROMs Z-Flag
00F7 DD 5E 00 LD E, (IX + 00) // Hole wert aus der Tabelle 0x1397, letzte Änderung IX im CRC Programm IX + (6 * 8)
00FA 21 02 0C LD HL, 0x0C02
00FD 73 LD M, E // lege in Wert in 0C02h ab
00FE 3E 26 LD A, 0x26 // Kennung ROM Check Ende
0100 20 03 JR NZ, 0x03 >-\ // Auswertung Z-Flag CRC1 Check über alle EPROM
0102 C3 40 01 JP 0x0140 | // ERROR EPROM!
0105 BB CP E <-/ // E == A ? 0x26; (0x1397)
0106 20 0A JR NZ, 0x0A >--\ // E > 0x26
0108 01 00 80 LD BC, 0x8000 | // E == 0x26, Kennung ROM Check Ende
010B 0B DEC BC <-\ |
010C 78 LD A, B | |
010D B1 OR C | |
010E 20 FB JR NZ, 0xFB >-/ | // Zeitschleife
0110 18 41 JR 0x41 | >-\ // zu Adresse 0x0153, RAM Check
Fehlerbehandlung | | // Binäranzeige ROM Nr. Fehlerhaft
0112 DD 7E 01 LD A, (IX + 01) <-/ | // A = (0x1392), z. B. 0x00, 0x04, 0x08, 0x14 ...
0115 47 LD B, A | // B = 0x00, 0x04 ...
0116 87 ADD A, A | // 2*A; 0x00, 0x08, 0x10, 0x28
0117 E6 18 AND 0x18 | // Maskierung 0001 1000; 0x00, 0x08, 0x10, 0x18,
0119 F6 05 OR 0x05 | // set 0, 2 000x x101; 0x05, 0x0c, 0x15, 0x1c
011B D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
011D CB 60 Bit 4, B | // Bit 4 von B == 0?
011F 28 0F JR Z, 0x0F >-\ | // (0x1398) ja
0121 3E 05 LD A, 0x05 | | // (0x1398) nein; Register 5
0123 D3 8B OUT (0x8B), A | | // SIO-0-K2C
0125 3E 02 LD A, 0x02 | | // Sendeunterbrechung erlauben
0127 D3 8B OUT (0x8B), A | | // SIO-0-K2C
0129 18 05 JR 0x05 >-+ |
| |
RST 0x38 Blinken A1 A2: | | // Fehlerbehandlung Hardware/RAM/ROM
012B F3 DI | | <-\ // sperre INT
012C 3E 05 LD A, 0x05 | | |
012E D3 8D OUT (0x8D), A | | | // PIO-1-B-D LED Ein/AUS Bit-2; A1 und A2 Bit 0 und 2
0130 01 00 80 LD BC, 0x8000 <-+ | | // Zeitschleife
0133 0B DEC BC <-\ | | |
0134 78 LD A, B | | | |
0135 B1 OR C | | | |
0136 20 FB JR NZ, 0xFB >-/ | | |
0138 DB 8D IN A, (0x8D) | | | // PIO-1-B-D Lese Tasteneingabe ANZEIGE
013A EE 04 XOR 0x04 | | | // A toggle Bit 2 (xxxx xtxx)
013C D3 8D OUT (0x8D), A | | | // PIO-1-B-D LED Ein/AUS Bit-2; A1 und A2 Bit 0 und 2
013E 18 F0 JR 0xF0 >-/ | | // Endlosschleife
| |
ERROR; LED Blinken | |
0140 F3 DI | | <-\ // Sperre Interupt
0141 3E 19 LD A, 0x19 | | | // 0001 1001
0143 D3 8D OUT (0x8D), A <-\ | | | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
0145 01 00 80 LD BC, 0x8000 | | | | // Zeitschleife
0148 0B DEC BC <-\ | | | |
0149 78 LD A, B | | | | |
014A B1 OR C | | | | |
014B 20 FB JR NZ, 0xFB >-/ | | | | // Zeitschleife
014D DB 8D IN A, (0x8D) | | | | // PIO-1-B-D Lese Tasteneingabe ANZEIGE
014F EE 18 XOR 0x18 | | | | // toggle Bit 3, 4 der Eingabe, Ausgabe (xxx1 1xxx)
0151 18 F0 JR 0xF0 >---/ | | | // Reset oder Interrupt erforderlich
Systemcheck weiter | | |
0153 3E 05 LD A, 0x05 <---------/ | | // Register 5
0155 D3 8A OUT (0x8A), A | | // SIO-0-K1C
0157 3E 02 LD A, 0x02 | | // Sendeunterbrechung erlauben
0159 D3 8A OUT (0x8A), A | | // SIO-0-K1C
015B DD 21 99 02 LD IX, 0x0299 | | // Konstante RAM-Check
015F FD 21 66 01 LD IY, 0x0166 | | // Rücksprungadresse RET IY
0163 C3 41 1A JP 0x1A41 | | // Prüfprogramm RAM CHECK, Übergabe IX; Rückgabe Z-Flag
| |
Ende RAM1 Check | |
0166 20 C3 JR NZ, 0xC3 >-----+ | // RST 38; Fehler RAM
0168 DD 21 A1 02 LD IX, 0x02A1 | | // Datenblock RAM Check
016C FD 21 73 01 LD IY, 0x0173 | | // Rücksprungadresse RET IY
0170 C3 41 1A JP 0x1A41 | | // Prüfprogramm RAM CHECK, Übergabe IX; Rückgabe Z-Flag
| |
Ende RAM2 Check | |
Start Prüffunktion Chiffrieren | |
0173 21 03 0C LD HL, 0x0C03 | |
0176 36 45 LD M, 0x45 | | // RAM Wert: 0x45
0178 20 B1 JR NZ, 0xB1 >-----/ | // RST 38, Fehler RAM1 oder 2
017A 3E 05 LD A, 0x05 | // Register 5
017C D3 8A OUT (0x8A), A | // SIO-0-K1C
017E 3E 82 LD A, 0x82 | // /WAIT/READY, Sendeunterbrechung erlauben
0180 D3 8A OUT (0x8A), A | // SIO-0-K1C
0182 CD 6F 12 CALL 0x126F | // Prüf-Funktion Rundenschlüssel; Rückgabe Z-Flag
0185 3E 64 LD A, 0x64 |
0187 32 04 0C LD (0x0C04), A |
018A 20 B4 JR NZ, 0xB4 >---------/ // Fehler LED Blinken
018C 06 00 LD B, 0x00
018E CD 43 08 CALL 0x0843 // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0191 3E 05 LD A, 0x05
0193 D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/Aus
0195 AF XOR A // Lösche A, beeinflusse Flags
0196 32 E7 0C LD (0x0CE7), A
0199 3E 03 LD A, 0x03
019B 32 EA 0C LD (0x0CEA), A // Steuerwort
019E 21 EE 0C LD HL, 0x0CEE // Übergabe Rauschgenerator; 9 byte ... Wurmreihe + Summe Wurmreihe
01A1 CD 01 08 CALL 0x0801 // Initalwerte nach RAM1, CTC Zeitkonstante; Übergabe HL, Warte auf INT17 Rauschgenerator, ohne INT-Registersatz!
// weiter nach (0x0cec) bit 7 == 1
01A4 F3 DI // Disable Interrupt
01A5 3E 8A LD A, 0x8A //
01A7 32 05 0C LD (0x0C05), A // ? Wert 0x8a
01AA 3A EC 0C LD A, (0x0CEC) // in 0x0801 gesetzt
01AD CB 77 Bit 6, A // Bit 6
01AF C2 7C FF JPNZ, 0xFF7C // Z != 0; 131 * NOP bis Neustart?
01B2 3E 03 LD A, 0x03 <---\ // ja, hier weiter
01B4 D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
01B6 CD 59 12 CALL 0x1259 | // Prüfe CRC 16 im Speicherbereich 0x2800 bis 0x2888; Rückgabe Z-Flag; Rundenschlüssel
01B9 3E 92 LD A, 0x92 |
01BB 32 06 0C LD (0x0C06), A |
01BE 28 20 JR Z, 0x20 >--\ | // CRC in 0x02800 OK? dann ist der Rundenschlüssel bereits erzeugt.
01C0 CD 00 10 CALL 0x1000 | | // Einlesen Schlüssel, Erstelle Rundenschlüssel
01C3 CD AA 12 CALL 0x12AA | | // Blockkopie Rundenschlüssel 0x2800; LAMBDA Ein-Ausgabe Initialwerte 0x87 ... Initale Bildung Wurmreihen
01C6 21 00 0D LD HL, 0x0D00 | | // Daten
01C9 01 A0 02 LD BC, 0x02A0 | | // 0x0d00 bis 0x0fa0; 672 Bytes
01CC 7E LD A, M | <--\ | // BC-Schleife
01CD 23 INC HL | | |
01CE BE CP M | | | // Vergleiche M; (HL) mit (HL+1)
01CF 28 08 JR Z, 0x08 >--\ | | | // Gleich
01D1 06 02 LD B, 0x02 | | | | // Ungleich
01D3 CD 43 08 CALL 0x0843 | | | | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
01D6 C3 2B 01 JP 0x012B | | | | // RST 0x38, Zeitschleife LED blinken A1 und A2
| | | |
01D9 0B DEC BC <--/ | | | // Schleifenzähler
01DA 78 LD A, B | | |
01DB B1 OR C | | |
01DC 20 EE JR NZ, 0xEE | >--/ | // Schleife bis BC == 0
01DE 18 D2 JR 0xD2 | >---/ // Springe zur Adresse 0x01b2
// Aufruf der Funktions- | Parameter über die Tasten bzw. Systemparameter
01E0 3E 01 LD A, 0x01 <--/ // RAM 0x2800 ist korrekt
01E2 D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
01E4 21 02 0C LD HL, 0x0C02 // Fülle RAM mit Init Bytes
01E7 3E 26 LD A, 0x26 // Inhalt von M XOR 0x26
01E9 CD 08 02 CALL 0x0208 // Unterprogramm IST-GLEICH A == M
01EC 3E 45 LD A, 0x45 // Inhalt von M == 0x45
01EE CD 08 02 CALL 0x0208 // Unterprogramm IST-GLEICH A == M
01F1 3E 64 LD A, 0x64 // Inhalt von M == 0x64
01F3 CD 08 02 CALL 0x0208 // Unterprogramm IST-GLEICH A == M
01F6 3E 8A LD A, 0x8A // Inhalt von M == 0x8A
01F8 CD 08 02 CALL 0x0208 // Unterprogramm IST-GLEICH A == M
01FB 3E 92 LD A, 0x92 // Inhalt von M == 0x92
01FD CD 08 02 CALL 0x0208 // Unterprogramm IST-GLEICH A == M
0200 AF XOR A // ab 0x0c02: 0x26, 0x45, 0x64, 0x8a, 0x92
0201 3C INC A // A = 1, Z-falg == 0; Kontrolle Fehler CPU? - sonst sinnlos
0202 C2 0E 02 JP NZ, 0x020E >---\ // Nächster Programmschritt
0205 C3 40 01 JP 0x0140 | // ERROR LED Blinken
|
IST-GLEICH [A == M] | // Übergabe A, HL
0208 AE XOR M | // A XOR M
0209 23 INC HL | // HL+1
020A C2 40 01 JP NZ, 0x0140 | // Wenn A != M ERROR LED Blinken
020D C9 RET |
|
020E 3E 16 LD A, 0x16 <--/
0210 32 ED 0C LD (0x0CED), A
0213 DB 8C IN A, (0x8C) // PIO-1-A-D
0215 47 LD B, A
0216 CB 50 Bit 2, B // Bit 2 von B == 0
0218 28 05 JR Z, 0x05 >--\ // ja in Speicherzelle 0x0ced = 0x16
021A 3E 32 LD A, 0x32 | // nein in Speicherzelle 0x0ced = 0x32
021C 32 ED 0C LD (0x0CED), A |
021F 3E 06 LD A, 0x06 <--/ // Register 6
0221 D3 8A OUT (0x8A), A // SIO-0-K1C = 0x06 oder 0x32
0223 3A ED 0C LD A, (0x0CED) // Wait/Ready-Steuerung
0226 D3 8A OUT (0x8A), A // SIO-0-K1C = 0x16 oder 0x32
0228 3E 07 LD A, 0x07 // Register 7
022A D3 8A OUT (0x8A), A // SIO-0-K1C = 0x07
022C 3A ED 0C LD A, (0x0CED) // Wait/Ready-Steuerung
022F D3 8A OUT (0x8A), A // SIO-0-K1C = 0x16 oder 0x32
0231 FB EI // INT Freigabe
0232 3E 01 LD A, 0x01
0234 32 E7 0C LD (0x0CE7), A
0237 32 EA 0C LD (0x0CEA), A
023A 21 F7 0C LD HL, 0x0CF7 // Initialwerte (HL) Rauschgenerator Werte
023D CD 01 08 CALL 0x0801 // Initalwerte nach RAM1, CTC Zeitkonstante; Übergabe HL, Warte auf INT17 Rauschgenerator, ohne INT-Registersatz!
// weiter nach (0x0cec) bit 7 == 1
0240 CB 48 Bit 1, B // Bit 1 von B == 0?
0242 28 1B JR Z, 0x1B >-\ // Ja Springe
0244 3A ED 0C LD A, (0x0CED) | // nein: 0x16 oder 0x32
0247 EE 0F XOR 0x0F | // invertiere unter 4 Bits, 0x19 oder 0x3d
0249 D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS 0x8d = 0x19 oder 0x3d; A1 und A2 Bit 4 und 3
024B 01 00 00 LD BC, 0x0000 |
024E CD 61 08 CALL 0x0861 | // Warteschleife; Übergabe BC (1 sec)
0251 3E 02 LD A, 0x02 |
0253 D3 85 OUT (0x85), A | // PI0-0-B-D Ausgabe 0x85 = 0x19 oder 0x3d
0255 DB 85 IN A, (0x85) | // PI0-0-B-D Lese Eingabe B2
0257 CB 5F Bit 3, A | // Bit 3 == 0 ?
0259 C2 0B 07 JP NZ, 0x070B | >-\ // nein Springe: Alternativregister umschalten, ?Blockchiffrierung?, Abfrage SIO-0-K2C
025C C3 D2 03 JP 0x03D2 | // ja: SIO-o-K1 und K2, Prüfe Status 0x0d08
|
025F CB 40 Bit 0, B <-/ // Bit 0 von B == 0?
0261 28 1B JR Z, 0x1B >---\ // ja: Springe
0263 3A ED 0C LD A, (0x0CED) | // nein: PIO-1-B-D = 0x16 oder 0x32
0266 EE 07 XOR 0x07 | // invertiere Bit 0, 1, 2, 0x11 oder 0x35
0268 D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
026A 01 00 00 LD BC, 0x0000 |
026D CD 61 08 CALL 0x0861 | // Warteschleife; Übergabe BC (1 sec)
0270 3E 02 LD A, 0x02 |
0272 D3 85 OUT (0x85), A | // PI0-0-B-D
0274 DB 85 IN A, (0x85) | // PI0-0-B-D
0276 CB 5F Bit 3, A | // Bit 3 von A == 0
0278 C2 0B 07 JP NZ, 0x070B | // nein: Springe: Alternativregister umschalten, ?Blockchiffrierung?, Abfrage SIO-0-K2C
027B C3 3A 04 JP 0x043A | // Ja: Intitalsierung SIO-0-K2 und Alternativregistersatz
|
027E 3A ED 0C LD A, (0x0CED)<--/ //
0281 EE 1F XOR 0x1F // Maskieren, 5 bit
0283 D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
0285 01 00 00 LD BC, 0x0000
0288 CD 61 08 CALL 0x0861 // Warteschleife; Übergabe BC (1 sec)
028B 3E 02 LD A, 0x02
028D D3 85 OUT (0x85), A // PI0-0-B-D
028F DB 85 IN A, (0x85) // PI0-0-B-D
0291 CB 5F Bit 3, A // Bit 3 von A == 0
0293 C2 EA 06 JP NZ, 0x06EA // nein: Springe zu Alternativregister umschalten, ?Blockchiffrierung?, Abfrage SIO-0-K2C
0296 C3 07 03 JP 0x0307 // Ja: Abfrage SIO-0-K2, Schlüsseleingelesen?
//DB Adress-Bereich, RAM Check 0x1a41
0299 E0 0C // IX + 0; IX + 1; 0x0ce0 -> Zeiger auf 0x0cee
029B 20 03 // IX + 2; -> C; IX + 3; -> B; BC = 0x0320, Länge
029D 00 00 00 00
02A1 90 28 // IX + 0; IX + 1; 0x2890 -> RAM2, Schlüssel2
02A3 6F 03 // IX + 2; -> C; IX + 3; -> B; BC = 0x036f, Länge
02A5 00 00 00 00
02A9 7F // Füllbytes
...
02AF 7F
// INT Tabelle
02B0 80 0A // 0x0a80 INT Routine NR. 1; INT SIO-0-K2; Ausgabe SIO-0-K2CD
02B2 10 0B // 0x0b10 INT Routine NR. 2; SIO-K2C
02B4 B6 09 // 0x09b6 INT Routine NR. 3; Lese SIO-0-K2CD, 256 byte, Vergleiche (HL) Inhalte
02B6 1A 0B // 0x0b1a INT Routine NR. 4; und 12 SIO-K2C
02B8 3F 0A // 0x0a3f INT Routine NR. 5; Einsprung INT 11, 3; Ausgabe SIO-0-K1D
02BA 0B 0b // 0x0b0b INT Routine NR. 6; SIO-K1C
02BC 51 09 // 0x0951 INT Routine NR. 7; Lese SIO-0-K1D Input bis 0x2aff gefüllt ist
02BE 15 0B // 0x0b15 INT Routine NR. 8; und 16 SIO-K1C
02C0 C4 0A // 0x0ac4 INT Routine NR. 9; - weiter in INT-1 oder Error
02C2 36 0B // 0x0b36 INT Routine NR. 10; SIO-K2C
02C4 EB 09 // 0x09eb INT Routine NR. 11; Einsprung INT-3, Lese SIO-0-K2CD, Prüfe Startfolge; Übergabe SIO-0-K2C
02C6 1A 0B // 0x0b1a INT Routine NR. 12; und 4 SIO-K2C
02C8 6E 0A // 0x0a6e INT Routine NR. 13; Einsprung INT-5, 11, 3; Ausgabe SIO-0-K1C
02CA 1F 0B // 0x0b1f INT Routine NR. 14; SIO-K1C
02CC 86 09 // 0x0986 INT Routine NR. 15; springt in INT-7 ließt SIO-0-K1D oder schreibt 0x16 in 0x0f01 bis 0x0f10
02CE 15 0B // 0x0b15 INT Routine NR. 16; und 8 SIO-K1C
02D0 00 00 // 0x0000 Restart
02D2 4D 0B // 0x0b4d INT Routine NR. 17; Rauschgenerator, ohne INT-Registersatz!
02D4 00 00 // 0x0000 Restart
02D6 00 00 // 0x0000 Restart
// PIO und CTC Steuerbytes, Initialisierung
------Anzahl| C |Steuerwörter
02D8 06 8A 18 18 04 10 01 1F // Länge 6, Port 0x8A SIO-0-Kanal1 Steuerbyte 18 Kanal rücksetzen,18 Empfangsunterbrechung,04,10 Suche Synch-Zeichen SDLC,01 Parity angefügt,1F Sendelogik
02E0 0C 8B 18 18 04 10 02 B0 01 1F 06 16 07 16 // Länge 12, Port 0x8B SIO-0-Kanal2 Steuerbyte 18 Kanal rücksetzen,18 Empfangsunterbrechung,04,10 Suche Synch-Zeichen SDLC,02 gerade Parity,B0 INT-1 0x02b0,01 Sendelogik,1F 4bit,06 Synch-Zeichen SDLC,16 Synch-Zeichen SDLC,07 Lesereigster 0,16 Leseregister 1
02EE 02 80 D0 03 // Länge 2, Port 0x80 CTC-Kanal 0 INT 0x02d0-> DI, Zeigeber, Vorteiler 16, neg. Flanke, Zeitkonst. Start, RESET
02F2 02 87 CF 08 // Länge 2, Port 0x87 PI0-0-B-C Bit-Mode 3 B0 ... B2 und B4 ... B7 Input, B3 Output
02F6 01 85 03 // Länge 1, Port 0x85 PIO-0-B-D Datenausgabe 03
02F9 02 8F CF C0 // Länge 2, Port 0x8F PIO-1-B-C Bit-Mode 3 B7, B6 Input, B0 ... B5 Output
02FD 01 8D 01 // Länge 1, Port 0x8D PIO-1-B-D B1 = 1
0300 02 86 CF FF // Länge 2, Port 0x86 PIO-0-A-C Bit-Mode 3: A0 ... A7 Input SLS
0304 01 81 03 // Länge 1, Port 0x81 CTC Kanal 1 DI, Zeigeber, Vorteiler 16, neg. Flanke, Zeitkonst. Start, RESET
// Abfrage SIO-0-K2, SDLC
0307 CD 86 06 CALL 0x0686 <-+ // Inital Speichern Alternativregister Teil1, INT-gespeert
030A DB 8C IN A, (0x8C) | // PIO-1-A-D
030C CB 7F BIT 7, A | // Bit 7 von A == 0?
030E C2 5D 03 JP NZ, 0x035D | // nein: Lese SIO-0-K1 und K2
0311 06 00 LD B, 0x00 | // ja: hier weiter
0313 CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0316 CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
0319 DB 8A IN A, (0x8A) | // SIO-0-K1C
031B CB 5F BIT 3, A | // Bit 3 von A == 0
031D 28 05 JR Z, 0x05 | >---\ // Ja dann Eingabe lesen
031F CD 2D 03 CALL 0x032D | | // nein: Bit 3 und 5 Prüfen
0322 18 E3 JR 0xE3 >----+ |
| |
0324 DB 8B IN A, (0x8B) | <---/ // SIO-0-K2C
0326 CB 5F BIT 3, A | // Bit 3 von A == 0
0328 C4 4D 03 CALL NZ 0x034D | // nein: Subroutine: Abfrage Startzeichen STZ = 0x55
032B 18 DA JR 0xDA >----/ // Ja
// Subroutine: SDCL bit 3 und 5 Prüfen
032D DB 8B IN A, (0x8B) // SIO-0-K2C
032F CB 6F BIT 5, A // Bit 5 von A == 0
0331 20 19 JR NZ, 0x19 >-------\ // nein Springe Return
0333 06 6A LD B, 0x6A | // ja hier weiter
0335 CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
|
0338 DB 8A IN A, (0x8A) <---\ | // SIO-0-K1C
033A CB 5F BIT 3, A | | // Bit 3 von A == 0
033C 28 0E JR Z, 0x0E | >-+ // ja dann Return
033E DB 8B IN A, (0x8B) | | // nein hier weiter SIO-0-K2C
0340 CB 6F BIT 5, A | | // Bit 5, von A == 0
0342 28 F4 JR Z, 0xF4 >---/ | // Ja dann neu einlesen
0344 06 D3 LD B, 0xD3 | // nein hier weiter
0346 CD 4D 08 CALL 0x084D | // Ausgabe SIO-0-K1C = 0x03, "B"
0349 CD B6 04 CALL 0x04B6 | // Prüfe Bit 4 und 3 von Eingabe
034C C9 RET <-------/
// Subroutine: Abfrage Startzeichen STZ = 0x55
034D CD AC 06 CALL 0x06AC // Lese SIO-0-K2 bis 0x55 in 0x0d08; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0350 C8 RET Z // SyncF falsch?
0351 CD 38 05 CALL 0x0538 // Kopiere Ein- Ausgabe LAMBDA von 0x0d08 nach 0x2A00
0354 06 6A LD B, 0x6A
0356 CD 43 08 CALL 0x0843 // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0359 CD 57 05 CALL 0x0557 // Rundenschlüssel erzeugen, Chiffrierung Daten mit Ergebnis LAMBDA
035C C9 RET
// Lese SIO-0-K1 und K2
035D 06 D3 LD B, 0xD3
035F CD 4D 08 CALL 0x084D // Ausgabe SIO-0-K1C = 0x03, "B"
0362 01 00 00 LD BC, 0x0000
0365 CD 61 08 CALL 0x0861 // Warteschleife; Übergabe BC (1 sec)
0368 3E 18 LD A, 0x18
036A D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein; A1 und A2 Bit 4 und 3
036C 01 00 00 LD BC, 0x0000
036F CD 61 08 CALL 0x0861 // Warteschleife; Übergabe BC (1 sec)
0372 3E FF LD A, 0xFF
0374 32 ED 0C LD (0x0CED), A
0377 47 LD B, A // Rette A
0378 3E 06 LD A, 0x06
037A D3 8A OUT (0x8A), A // SIO-0-K1C
037C 78 LD A, B // Hole A zurück
037D D3 8A OUT (0x8A), A // SIO-0-K1C
037F 3E 07 LD A, 0x07
0381 D3 8A OUT (0x8A), A // SIO-0-K1C
0383 78 LD A, B // Hole A zurück
0384 D3 8A OUT (0x8A), A // SIO-0-K1C
0386 DB 8A IN A, (0x8A) <--\ // SIO-0-K1C Inputschleife
0388 CB 67 BIT 4, A | // BIT 4 von A == 0
038A 20 FA JR NZ, 0xFA >--/ // nein: Sprung
038C 06 C1 LD B, 0xC1 // ja
038E CD 4D 08 CALL 0x084D // Ausgabe SIO-0-K1C = 0x03, "B"
0391 AF XOR A <-\ // Lösche A, beeinflusse Flags ?sonst? .03AE.
0392 32 10 0D LD (0x0D10), A | // Status 0x0d10
0395 32 11 0D LD (0x0D11), A | // Status 0x0d11
0398 D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
039A 06 00 LD B, 0x00 |
039C CD 57 08 CALL 0x0857 | // Ausgabe SIO-0-K2C = 0x03, "B"
039F CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
03A2 CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
03A5 DB 8A IN A, (0x8A) | // SIO-0-K1C
03A7 CB 5F BIT 3, A | // BIT 1 von A == 0
03A9 28 05 JR Z, 0x05 | >-\ // ja
03AB CD B9 03 CALL 0x03B9 | | >-\ <---\ // nein: Lese SIO-0-K2
03AE 18 E1 JR 0xE1 >-+ | | |
| | | |
03B0 DB 8B IN A, (0x8B) | <-/ | | // SIO-0-K2C
03B2 CB 5F BIT 3, A | | | // BIT 3 von A == 0
03B4 C4 4D 03 CALL NZ 0x034D | | | // nein; Subroutine: Abfrage Startzeichen STZ = 0x55
03B7 18 D8 JR 0xD8 >-/ | | // ja
| |
// Lese SIO-0-K2 | |
03B9 DB 8B IN A, (0x8B) <---/ | // SIO-0-K2C
03BB CB 6F BIT 5, A | // BIT 5 von A == 0
03BD C0 RET NZ >---------+ // nein return
03BE 06 6A LD B, 0x6A | // ja
03C0 CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
03C3 DB 8A IN A, (0x8A) <--\ | // SIO-0-K1C
03C5 CB 5F BIT 3, A | | // BIT 3 von A == 0
03C7 C8 RET Z | >------------/ // ja return
03C8 DB 8B IN A, (0x8B) | // nein lese Input SIO-0-K2C
03CA CB 6F BIT 5, A | // BIT 5 von A == 0
03CC 28 F5 JR Z, 0xF5 >--/ // ja lese Input
03CF CD B6 04 CALL 0x04B6 // nein: Prüfe Bit 4 und 3 von Eingabe
03D1 C9 RET
// SIO-o-K1 und K2, Prüfe Status 0x0d08
03D2 CD 86 06 CALL 0x0686 <------\ // Inital Speichern Alternativregister Teil1, INT-gespeert
03D5 06 00 LD B, 0x00 |
03D7 CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
03DA 06 6A LD B, 0x6A |
03DC CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
03DF 06 D3 LD B, 0xD3 | <--\
03E1 CD 57 08 CALL 0x0857 | | // Ausgabe SIO-0-K2C = 0x03, "B"
03E4 21 08 0D LD HL, 0x0D08 | | // Status 0x0d08
03E7 36 16 LD M, 0x16 | | // (0x0d08)=0x16
03E9 DB 8B IN A, (0x8B) | <--\ | // SIO-0-K2C
03EB CB 67 Bit 4, A | | | // BIT 4 von A == 0
03ED 20 1A JR NZ, 0x1A >--\ | | | // nein
03EF 06 C1 LD B, 0xC1 | | | | // ja
03F1 CD 57 08 CALL 0x0857 | | | | // Ausgabe SIO-0-K2C = 0x03, "B"
03F4 F3 DI | | | | // Sperre INT
03F5 D9 EXX | | | | // INT-Registersatz tauschen, BC/DE/HL
03F6 21 08 0D LD HL, 0x0D08 | | | | // Status 0x0d08; HL im Alternativ-Registersatz mit Adresse geladen
03F9 D9 EXX | | | | // Alternativ-Registersatz tauschen, BC/DE/HL
03FA FB EI | | | | // INT Freigabe
03FB 7E LD A, M | | | | // Wenn nicht durch INT-Routine geändert sollte es 0x16 sein
03FC FE 16 CP 0x16 | | | | // Status 0x0d08 == 0x16
03FE 28 09 JR Z, 0x09 >---+ | | |
0400 FE 55 CP 0x55 | | | | // Status 0x0d08 == 0x55; STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0402 20 DB JR NZ 0xDB | | | >-/
0404 CD 2E 04 CALL 0x042E | | | // Vorbereiten LAMBDA, SIO-0-K1C Initialisierung
0407 18 C9 JR 0xC9 | >---+ |
0409 FB EI <--/ | | // INT Freigabe
040A DB 8A IN A, (0x8A) | | // SIO-0-K1C
040C CB 5F BIT 3, A | | // BIT 3 von A == 0
040E 28 D9 JR Z 0xD9 | >--/ // ja
0410 CD 15 04 CALL 0x0415 | // nein; Initialisierung SIO-0-K2C
0413 18 BD JR 0xBD >--------/
// Subroutine: Initialisierung SIO-0-K2C
0415 06 00 LD B, 0x00 // Übergabe 0x00
0417 CD 57 08 CALL 0x0857 // Ausgabe SIO-0-K2C = 0x03, "B"
041A DB 8B IN A, (0x8B) // SIO-0-K2C
041C CB 6F BIT 5, A // BIT 5 von A == 0
041E 28 08 JR Z 0x08 >--\ // ja
0420 06 D3 LD B, 0xD3 | // nein; übergabe 0xd3
0422 CD 4D 08 CALL 0x084D | // Ausgabe SIO-0-K1C = 0x03, "B"
0425 CD B6 04 CALL 0x04B6 | // Prüfe Bit 4 und 3 von Eingabe
0428 06 02 LD B, 0x02 <--/
042A CD 48 08 CALL 0x0848 // Ausgabe SIO-0-K2C = 0x05, "B"
042D C9 RET
// Subroutine: Vorbereiten LAMBDA, SIO-0-K1C Initialisierung, Rundenschlüssel
042E CD 38 05 CALL 0x0538 // Kopiere Ein- Ausgabe LAMBDA von 0x0d08 nach 0x2A00
0431 06 6A LD B, 0x6A // 0x6a, 106
0433 CD 43 08 CALL 0x0843 // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0436 CD 57 05 CALL 0x0557 // Rundenschlüssel erzeugen, Chiffrierung Daten mit Ergebnis LAMBDA
0439 C9 RET
// Einsprung: Intitalsierung SIO-0-K2 und Alternativregistersatz
043A F3 DI <--------\ // Sperre INT, Keine Eingabe
043B 3E 02 LD A, 0x02 |
043D D3 8B OUT (0x8B), A | // SIO-0-K2C
043F 3E C0 LD A, 0xC0 |
0441 D3 8B OUT (0x8B), A | // SIO-0-K2C
0443 CD 86 06 CALL 0x0686 | // Inital Speichern Alternativregister Teil1, INT-gespeert
0446 06 82 LD B, 0x82 |
0448 CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
044B 06 6A LD B, 0x6A |
044D CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
0450 06 D3 LD B, 0xD3 |
0452 CD 4D 08 CALL 0x084D | // Ausgabe SIO-0-K1C = 0x03, "B"
0455 CD 57 08 CALL 0x0857 | // Ausgabe SIO-0-K2C = 0x03, "B"
0458 3E 16 LD A, 0x16 |
045A D3 89 OUT (0x89), A | // SIO-0-K2D
045C FB EI <---\ | // INT Freigabe
045D 06 00 LD B, 0x00 | |
045F DB 8B IN A, (0x8B) | | // SIO-0-K2C
0461 CB 5F BIT 3, A | | // BIT 3 von A == 0
0463 28 02 JR Z, 0x02 >--\ | | // Ja
0465 CB C8 SET 1, B | | | // nein
0467 CB 6F BIT 5, A <--/ | | // BIT 5 von A == 0
0469 28 02 JR Z, 0x02 >-\ | | // Ja
046B CB F8 SET 7, B | | | // nein
046D CD 43 08 CALL 0x0843 <-/ | | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0470 3E 04 LD A, 0x04 | |
0472 32 10 0D LD (0x0D10), A | | // Status 0x0d10
0475 18 E5 JR 0xE5 >---/ | // Setze Einlesen und Prüfen fort
//Einsprungadresse (HL) im Stack |
0477 3E 01 LD A, 0x01 |
0479 32 10 0D LD (0x0D10), A | // Status 0x0d10
047C 06 D3 LD B, 0xD3 |
047E CD 57 08 CALL 0x0857 | // Ausgabe SIO-0-K2C = 0x03, "B"
0481 06 C1 LD B, 0xC1 |
0483 CD 4D 08 CALL 0x084D | // Ausgabe SIO-0-K1C = 0x03, "B"
0486 06 82 LD B, 0x82 |
0488 CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
048B CD 98 05 CALL 0x0598 | // Initalisierung Wurmreihe/Dateneingabe für LAMBDA/ STZ-Kommando/Prüfsummen Wurmreihen
048E 3E 05 LD A, 0x05 |
0490 32 10 0D LD (0x0D10), A | // Status 0x0d10
0493 CD 02 05 CALL 0x0502 | // Bildung Wurmreihen
0496 C3 3A 04 JP 0x043A | // Intitalsierung SIO-0-K2 und Alternativregistersatz
0499 3E 02 LD A, 0x02 |
049B 32 10 0D LD (0x0D10), A | // Status 0x0d10
049E 06 D3 LD B, 0xD3 |
04A0 CD 4D 08 CALL 0x084D | // Ausgabe SIO-0-K1C = 0x03, "B"
04A3 06 C1 LD B, 0xC1 |
04A5 CD 57 08 CALL 0x0857 | // Ausgabe SIO-0-K2C = 0x03, "B"
04A8 CD 38 05 CALL 0x0538 | // Kopiere Ein- Ausgabe LAMBDA von 0x0d08 nach 0x2A00
04AB 06 EA LD B, 0xEA |
04AD CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
04B0 CD 57 05 CALL 0x0557 | // Rundenschlüssel erzeugen, Chiffrierung Daten mit Ergebnis LAMBDA
04B3 C3 3A 04 JP 0x043A >----------/ // Schleife bis Abbruch
// Prüfe Bit 4 und 3 von Eingabe
04B6 06 E0 LD B, 0xE0
04B8 CD 43 08 CALL 0x0843 // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
04BB DB 8A IN A, (0x8A) <--\ // SIO-0-K1C
04BD CB 67 BIT 4, A | // BIT 4 von A == 0
04BF 28 07 JR Z 0x07 | >---\ // ja
04C1 CB 5F BIT 3, A | | // nein; Bit 3 von A == 0
04C3 CA 37 05 JP Z, 0x0537 | | // ja -> Return
04C6 18 F3 JR 0xF3 >--/ | // nein Lese Input fortsetzen
|
04C8 06 C1 LD B, 0xC1 <---/
04CA CD 4D 08 CALL 0x084D // Ausgabe SIO-0-K1C = 0x03, "B"
04CD 3E 02 LD A, 0x02
04CF 32 11 0D LD (0x0D11), A // Status 0x0d11 = 0x02
04D2 21 09 0D LD HL, 0x0D09
04D5 3A ED 0C LD A, (0x0CED)
04D8 77 LD M, A // (0x0d09) = (0x0ced)
04D9 F3 DI <----\ // Sperre INT, Eingabe gesperrt
04DA D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
04DB 21 09 0D LD HL, 0x0D09 | // Lade HL mit Speicheradresse im ALternativ-Registersatz
04DE D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
04DF FB EI | // INT Freigabe
04E0 DB 8A IN A, (0x8A) | // SIO-0-K1C
04E2 CB 5F BIT 3, A | // BIT 1 von A == 0
04E4 28 51 JR Z 0x51 >---\ | // Ja
04E6 3A ED 0C LD A, (0x0CED) | | // nein
04E9 BE CP M | | // Änderung in (0x0d09) oder (0x0ced)
04EA 28 ED JR Z 0xED | >-/ // keine, Warte
04EC F3 DI | // Sperre INT, Eingabe gesperrt
04ED D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
04EE 21 08 0D LD HL, 0x0D08 |
04F1 D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
04F2 FB EI | // INT Freigabe
04F3 CD 98 05 CALL 0x0598 | // Initalisierung Wurmreihe/Dateneingabe für LAMBDA/ STZ-Kommando/Prüfsummen Wurmreihen
04F6 3E 16 LD A, 0x16 |
04F8 D3 89 OUT (0x89), A | // SIO-0-K2CD
04FA 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
04FD E6 07 AND 0x07 | // Maskiere bits 0, 1, 2, A = 0x00 bis 0x07
04FF 32 10 0D LD (0x0D10), A | // Status 0x0d10
|
// Subroutine: Bildung Wurmreihen | // LAMBDA Ein-Ausgabe
0502 CD 00 18 CALL 0x1800 | <------\ // LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
0505 21 10 0D LD HL, 0x0D10 | | // Status 0x0d10
0508 CB 5E BIT 3, M | | // BIT 3 von M == 0
050A 28 FC JR Z 0xFC | >---+ // ja Bildung Wurmreihen und Rundenschlüssel
050C CD EE 08 CALL 0x08EE | | // nein: XOR-Verknüpfung Wurmreihe XOR Daten
050F 3A 10 0D LD A, (0x0D10) | | // Status 0x0d10
0512 CB 9F RES 3, A | | // Lösche Bit 3, Wert: 0x00 ... 0x03
0514 32 10 0D LD (0x0D10), A | | // Status 0x0d10
0517 E6 A0 AND 0xA0 | | // Maskiere bit 7, 5
0519 20 19 JR NZ 0x19 | >--\ | // prüfe bit 7 und 5
051B DB 8A IN A, (0x8A) | | | // SIO-0-K1C
051D CB 5F BIT 3, A | | | // BIT 3 von A == 0
051F C2 02 05 JPNZ 0x0502 | | >--/ // nein: Bildung Wurmreihen
0522 06 00 LD B, 0x00 | | // Ja
0524 CD 43 08 CALL 0x0843 | | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0527 CD 00 18 CALL 0x1800 | | // LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
052A 21 10 0D LD HL, 0x0D10 | | // Status 0x0d10
052D CB 5E BIT 3, M | | <-\ // BIT 3 von M == 0
052F 28 FC JR Z, 0xFC | | >-/ // Ja: Warte auf INT
0531 CD EE 08 CALL 0x08EE | | // nein: XOR-Verknüpfung Wurmreihe XOR Daten
0534 CD 22 06 CALL 0x0622 | <--/ // Rundenschlüssel mit Initalwert 0x87, Prüfe auf RAM1 und RAM2
0537 C9 RET <---/
// Subroutine: Kopiere Ein-Ausgabe LAMBDA 0x0d08 nach 0x2A00
0538 CD 00 06 CALL 0x0600 // Aktivierung Alternativregistersatz, Steuer-Signale, Rückgabe (0x0e10, 0x0e11)[0x00, 0x0f]
053B 21 10 0D LD HL, 0x0D10 // Status 0x0d10
053E 7E LD A, M // A = (0x0d10)
053F E6 07 AND 0x07 // Maskiere unteren 3 Bits
0541 77 LD M, A // Status 0x0d10
0542 CB 5E BIT 3, M <-\ // BIT 3 von M == 0
0544 28 FC JR Z, 0xFC >-/ // ja: Tastendruck, Flanke abfragen
0546 CB 9E RES 3, M // nein: Lösche Bit 3 M
0548 21 08 0D LD HL, 0x0D08 // Kopie Ein- Ausgabe LAMBDA, Wurmreihe
054B 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihe
054E 06 08 LD B, 0x08 // Schleifenzähler = 8
0550 7E LD A, M <--\
0551 12 LD (DE), A | // 0x2a00 ... 0x2a07 mit 0x0d08 ... 0x0d01 laden
0552 13 INC DE | // Ein- Ausgabe LAMBDA
0553 2B DEC HL | // kopiert rückwärts!
0554 10 FA DJNZ 0xFA >--/
0556 C9 RET
// Subroutine: Rundenschlüssel erzeugen, Chiffrierung Daten mit Ergebnis LAMBDA
0557 3A ED 0C LD A, (0x0CED) // Steuerwort für SIO
055A D3 88 OUT (0x88), A // SIO-0-K1D
055C CD 00 18 CALL 0x1800 <------\ // LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
055F 21 10 0D LD HL, 0x0D10 | // Status 0x0d10
0562 CB 5E BIT 3, M >-\ | // BIT 3 von A == 0
0564 28 FC JR Z, 0xFC >-/ | // ja; Warte auf Interrupt-auslösende Änderung
0566 CB 9E RES 3, M | // Lösche Bit 3, Status 0x0d10 = 0x00 ... 0x37
0568 CB 4E BIT 1, M | // BIT 1 von M == 0
056A 20 06 JR NZ 0x06 >-\ | // nein
056C DB 8A IN A, (0x8A) | | // Ja; SIO-0-K1C
056E CB 5F BIT 3, A | | // BIT 3 von A == 0
0570 20 22 JR NZ 0x22 | >--\ | // nein
0572 3E 30 LD A, 0x30 <-/ | | // ja
0574 A6 AND M | | // 0011 0000 and M
0575 20 1D JR NZ 0x1D >--+ | // abbruch aus der Subroutine
0577 CD 36 09 CALL 0x0936 | | // XOR 8 byte Block, (0x2a00++) = (0x2a00++) XOR (0x0d08--)
057A 21 10 0D LD HL, 0x0D10 | | // Status 0x0d10
057D CB 7E BIT 7, M | | // BIT 7 von M == 0
057F 20 DB JR NZ, 0xDB | >-+ // nein
0581 CB FE SET 7, M | | // ja Bit 7 = 1
0583 3A ED 0C LD A, (0x0CED) | |
0586 32 08 0F LD (0x0F08), A | | // Adressbereich 0xf05 bis 0x0f08 füllen mit (0x0ced)
0589 32 07 0F LD (0x0F07), A | |
058C 32 06 0F LD (0x0F06), A | |
058F 32 05 0F LD (0x0F05), A | |
0592 18 C8 JR 0xC8 | >-/
0594 CD 6E 06 CALL 0x066E <--/ // Statussignal 0x0e11, Löschen 0x0e00 / 0x0f00 4 byte; Warteschleife
0597 C9 RET
// Initalisierung Wurmreihe/Dateneingabe für LAMBDA/ STZ-Kommando/Prüfsummen Wurmreihen
0598 3E 08 LD A, 0x08
059A D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/Aus
059C 21 EE 0C LD HL, 0x0CEE // aus 0x2a00 kopierte 9! byte; Ein- Ausgabe LAMBDA
059F 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
05A2 01 09 00 LD BC, 0x0009 // 9! Byte
05A5 ED B0 LDIR // (DE) = M von 0xcee nach 0x2a00, Ein- Ausgabe LAMBDA
05A7 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
05AA 06 08 LD B, 0x08 // Schleifenzähler = 8
05AC 7E LD A, M // A = 0x2aa = 0xcee
05AD BE CP M <--\ // M == (HL + 1) ?
05AE 20 06 JR NZ, 0x06 >--\ | // Ungleich?
05B0 23 INC HL | |
05B1 10 FA DJNZ 0xFA | >--/ // 7 Runden, vergleich M == (HL + 1)
05B3 C3 2B 01 JP 0x012B | // RST 0x38
05B6 AF XOR A <-/ // Lösche A, beeinflusse Flags
05B7 32 10 0E LD (0x0E10), A // Status 0x0e10 = 0x00
05BA 21 0C 0E LD HL, 0x0E0C //
05BD 3E 0F LD A, 0x0F
05BF 32 11 0E LD (0x0E11), A // Status 0x0e11 = 0x0f; Status; Werte 0x04, 0x05, 0x0e, 0x0f; 0x0e/0x0f Senden-Empfangen Speicherbereich
05C2 36 16 LD M, 0x16 // HL = 0x0ec0
05C4 2D DEC L
05C5 36 16 LD M, 0x16 // HL = 0x0ecb
05C7 2D DEC L
05C8 36 16 LD M, 0x16 // HL = 0x0eca
05CA 2D DEC L // STZ ?
05CB 36 55 LD M, 0x55 // HL = 0x0ec9 - 0x0e0c: 0x55 0x16 0x16 0x16 0x55; 0x55; ...0x00, 0x0f = STZ?; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
05CD 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
05D0 2D DEC L // HL = 0x0ec8
05D1 1A LD A, (DE) <--\ // Daten -> 0x0ec8 ... 0x0ec0
05D2 77 LD M, A | // kopiere (DE) nach M; 0x2a00 nach 0x0ecc; Ein- Ausgabe LAMBDA
05D3 13 INC DE | // 0x2a00 bis 0x2a0c; Ein- Ausgabe LAMBDA 8 byte
05D4 2D DEC L | // 0x0ec7
05D5 20 FA JR NZ, 0xFA >--/ // bis HL 0x0ec0
05D7 3A 08 2A LD A, (0x2A08) // Prüfbyte Summe 0x2a00 bis 0x2a07
05DA EE BC XOR 0xBC // Maskierung 1011 1100
05DC 77 LD M, A // 0x0ec7 = (0x2A08) XOR 0xbc
05DD 21 F9 0C LD HL, 0x0CF9 // Auszug aus Rauschgenerator-Daten
05E0 11 0A 0D LD DE, 0x0D0A
05E3 01 04 00 LD BC, 0x0004 // 4 bytes
05E6 ED B0 LDIR // Blockkopie (DE) = M, von 0x0cf9 nach 0x0d0a
05E8 F3 DI // Sperre INT, Eingabe gesperrt
05E9 D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
05EA 0E 00 LD C, 0x00
05EC 11 F7 0E LD DE, 0x0EF7
05EF 43 LD B, E // BC = 0xf700
05F0 ED 53 F5 0E LD (0x0EF5), DE // Startbereich STZ-Folge?
05F4 3E 55 LD A, 0x55 // STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
05F6 12 LD (DE), A <--\
05F7 1C INC E |
05F8 20 FC JR NZ, 0xFC >--/ // 0x0ef7 8byte füllen mit 0x55; SZT?; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
05FA 11 0D 0E LD DE, 0x0E0D
05FD D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
05FE FB EI // INT Freigabe
05FF C9 RET // Rückgabe DE=0x0e0d
// Subroutine: Aktivierung Alternativregistersatz, Steuer-Signale, Rückgabe (0x0e10, 0x0e11)[0x00, 0x0f]
0600 3E 10 LD A, 0x10
0602 D3 8D OUT (0x8D), A // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
0604 F3 DI // Sperre INT, Eingabe gesperrt
0605 D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
0606 21 08 0D LD HL, 0x0D08 // Lade HL und DE im Alternativ-Register-Satz
0609 11 0A 0E LD DE, 0x0E0A
060C D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
060D FB EI // INT Freigabe
060E 3A ED 0C LD A, (0x0CED)
0611 21 0A 0E LD HL, 0x0E0A
0614 77 LD M, A <--\ // fülle 0xe0a bis 0xe00 mit (0x0ced)
0615 2D DEC L |
0616 20 FC JR NZ, 0xFC >--/ // wiederholen wenn L > 0, ->0xe00
0618 AF XOR A // Lösche A, beeinflusse Flags
0619 32 10 0E LD (0x0E10), A // Status 0x0e10 = 0x00
061C 3E 0F LD A, 0x0F
061E 32 11 0E LD (0x0E11), A // Status 0x0e11 = 0x0f; Status; Werte 0x04, 0x05, 0x0e, 0x0f; 0x0e/0x0f Senden-Empfangen Speicherbereich
0621 C9 RET
// Rundenschlüssel mit Initalwert 0x87, Funktion Test Online mit aktuellen Schlüssel und Initialwert 0x87
0622 21 10 0D LD HL, 0x0D10 <--\ // Status 0x0d10
0625 CB 6E BIT 5, M | // bit 5 == 0
0627 C0 RET NZ | // nein Rücksprung
0628 21 10 0E LD HL, 0x0E10 | // ja: Status 0x0e10
062B AF XOR A | // Lösche A, beeinflusse Flags
062C BE CP M | // Ist (0xe10) == 0x00, sonst kann (0x0e10) == 0x08, 0x0a sein
062D 20 F3 JR NZ, 0xF3 >--/ // nein
062F 36 0A LD M, 0x0A // (0xe10) = 0x0a
0631 3A 11 0E LD A, (0x0E11) // Status; Werte 0x0e/0x0f Senden-Empfangen Speicherbereich
0634 67 LD H, A
0635 2E 0A LD L, 0x0A // HL = 0x0e0a oder 0x0f0a
0637 36 FF LD M, 0xFF <--\ // HL == 0x0e0a, 0x0f0a
0639 2D DEC L | // Fülle (HL) mit 0xff; 9 Runden; 0x0e09 - 0x0e01, bw. 0x0f09 - 0x0f01
063A 20 FB JR NZ 0xFB >--/ // bis HL == 0x0e00; 0x0f00;
063C 36 FF LD M, 0xFF // auch 0x0e00 oder 0x0f00 mit 0xff füllen
063E 21 57 13 LD HL, 0x1357 // Startvariablen 8 bytes, 0x87
0641 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
0644 01 08 00 LD BC, 0x0008 // Schleifenzähler = 8
0647 ED B0 LDIR // Kopiere (DE) = M, von 0x1357 nach 0x2a00, 8 bytes
0649 CD 00 18 CALL 0x1800 // LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
064C 21 95 0C LD HL, 0x0C95 // CFB-Modus, letzte Wurmreihe - 0x0c9c
064F 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
0652 06 08 LD B, 0x08 // Schleifenzähler = 8
0654 1A LD A, (DE) <--\ // Ein- Ausgabe LAMBDA, Wurmreihen
0655 AE XOR M | // A = Wurmreihe XOR M
0656 C2 40 01 JP NZ, 0x0140 | // A != M ERROR LED Blinken
0659 23 INC HL |
065A 13 INC DE |
065B 10 F7 DJNZ 0xF7 >--/ // Vergleiche M == (DE); Berechnete Wurmreihe ist mit festgelegter Identisch
065D EE FF XOR 0xFF // 0x2a08 NOT A
065F AE XOR M // A = A XOR (0x0c9D)
0660 AE XOR M // A = A XOR (0x0c9D)
0661 20 03 JR NZ 0x03 >--\ // A != 0
0663 C3 40 01 JP 0x0140 | // ERROR LED Blinken
0666 21 10 0D LD HL, 0x0D10 <---+ // Status 0x0d10
0669 CB 6E BIT 5, M | // bit 5 == 0
066B 28 F9 JR Z 0xF9 >--/ // ja
066D C9 RET // nein
// Subroutine: Statussignal 0x0e11, Löschen 0x0e00 / 0x0f00 4 byte; Warteschleife
066E 3A 11 0E LD A, (0x0E11) // Status 0x0e11; 0x00, 0x04, 0x05, 0x0e, 0x0f
0671 67 LD H, A // 0x0e oder 0x0f
0672 2E 04 LD L, 0x04 // HL = 0x0e04, 0x0f04
0674 36 FF LD M, 0xFF <--\
0676 2D DEC L |
0677 20 FB JR NZ, 0xFB >--/ // Fülle M mit 0xff von 0x0e04 bis 0x0e01; 0x0f04 ..
0679 3E 04 LD A, 0x04
067B 32 10 0E LD (0x0E11), A // Status 0x0e11 == 0x04
067E 21 10 0D LD HL, 0x0D10 // Status 0x0d10
0681 CB 6E BIT 5, M <-\ // Warte bis Bit 5 gesetzt, INT Routine!
0683 28 FC JR Z, 0xFC >-/ // Tastendruck? Flankenabfrage INT
0685 C9 RET
// Inital Speichern Alternativregister Teil1, INT-gespeert
0686 F3 DI // Sperre INT, Eingabe gesperrt
0687 AF XOR A // Lösche A, beeinflusse Flags
0688 32 11 0D LD (0x0D11), A // Status 0x0d11 = 0x00
// speichern Alternativregister Teil2
068B AF XOR A // Lösche A, beeinflusse Flags
068C 32 10 0D LD (0x0D10), A // Status 0x0d10
068F D3 8D OUT (0x8D), A // PIO-1-B-D LED AUS; A1 und A2 Bit 4 und 3
0691 32 10 0E LD (0x0E10), A // Status 0x0e10 = 0
0694 D9 EXX // INT-Registersatz, BC/DE/HL
0695 21 08 0D LD HL, 0x0D08 // Adressbereich Daten
0698 11 00 0F LD DE, 0x0F00 // RAM1
069B 06 16 LD B, 0x16 // BC = 0x16xx x = "A"; Der Inhalt von 0x1600 bis 0x17ff ist 0x7f == 7bit
069D 4F LD C, A // Rette A?
069E 3E FF LD A, 0xFF
06A0 12 LD (DE), A // 0x0f00 = 0xff
06A1 13 INC DE
06A2 D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
06A3 06 00 LD B, 0x00
06A5 CD 4D 08 CALL 0x084D // Ausgabe SIO-0-K1C = 0x03, "B"
06A8 CD 57 08 CALL 0x0857 // Ausgabe SIO-0-K2C = 0x03, "B"
06AB C9 RET
// Lese SIO-0-K2 bis 0x55 in 0x0d08; Abfrage STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
06AC 06 D3 LD B, 0xD3
06AE CD 57 08 CALL 0x0857 // Ausgabe SIO-0-K2C = 0x03, "B"
06B1 01 C8 00 LD BC, 0x00C8
06B4 11 14 00 LD DE, 0x0014
06B7 DB 8B IN A, (0x8B) <--\ // SIO-0-K2C
06B9 CB 67 BIT 4, A | // bit 4 == 0
06BB 28 0A JR Z, 0x0A >---\ | // ja
06BD CD 25 08 CALL 0x0825 | | // nein: Lese Input SIO-0-K2C, Übergabe BC, Rückgabe BC, A, Flag NZ/Z
06C0 C8 RET Z | | // Zerro Flag der vorherigen Funktion == 1?, Rücksprung
06C1 CD 33 08 CALL 0x0833 | | // SIO-0-K2C Lese Input, Rückgabe DE, A, NZ/Z
06C4 C8 RET Z | | // Zerro Flag der vorherigen Funktion == 1?, Rücksprung
06C5 18 F0 JR 0xF0 | >--/
06C7 06 C1 LD B, 0xC1 <---/
06C9 CD 57 08 CALL 0x0857 // Ausgabe SIO-0-K2C = 0x03, "B"
06CC 21 08 0D LD HL, 0x0D08 // Daten, 0x16 für STZ?
06CF 36 16 LD M, 0x16
06D1 01 C8 00 LD BC, 0x00C8
06D4 F3 DI <---\ // Sperre INT, Eingabe gesperrt
06D5 D9 EXX | // INT-Registersatz tauschen, BC/DE/HL
06D6 21 08 0D LD HL, 0x0D08 | // HL = 0x0d08 für Alternativ-Register-Satz
06D9 D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
06DA FB EI | // INT Freigabe
06DB CD 25 08 CALL 0x0825 | // Lese Input PIO-1-B-C, Übergabe BC, Rückgabe BC, A,Flag NZ/Z
06DE C8 RET Z | // Zerro Flag der vorherigen Funktion == 1?, Rücksprung
06DF CD 33 08 CALL 0x0833 | // PIO-1-A-C Lese Input, Rückgabe DE, A, NZ/Z
06E2 C8 RET Z | // Zerro Flag der vorherigen Funktion == 1?, Rücksprung
06E3 3E 55 LD A, 0x55 | // STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
06E5 BE CPM |
06E6 20 EC JR NZ 0xEC >---/ // M != 0x55 wiederholen; Zeichen nach STZ?; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
06E8 A7 AND A //
06E9 C9 RET
// Einsprung: Alternativregister umschalten, ?Blockchiffrierung?, Abfrage SIO-0-K2C
06EA CD 86 06 CALL 0x0686 // Inital Speichern Alternativregister Teil1, INT-gespeert
06ED CD 8B 06 CALL 0x068B <---\ // Inital Speichern Alternativregister Teil2
06F0 06 00 LD B, 0x00 |
06F1 CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
06F4 3A 11 0D LD A, (0x0D11) | // Status 0x0d11
06F7 A7 AND A | // A == 0?
06F8 28 05 JR Z, 0x05 >---\ | // A == 0
06FA CD 5E 07 CALL 0x075E | | // De- Chiffrierung; A == 1
06FD 18 ED JR 0xED | >---+
| |
0700 DB 8B IN A, (0x8B)<---/ | // lese SIO-0-K2C
0702 CB 5F BIT 3, A | // Bit 3 == 0
0704 28 E7 JR Z 0xE7 >---+ // ja
0706 CD B7 07 CALL 0x07B7 | // nein: Warte STZ ab, danach Dechiffrierung
0709 18 E2 JR 0xE2 >---/
// Einsprung: Alternativregister umschalten, ?Blockchiffrierung?, Abfrage SIO-0-K2C
070B CD 86 06 CALL 0x0686 // Inital Speichern Alternativregister Teil1, INT-gespeert
070E 3E 02 LD A, 0x02 <--\
0710 D3 8B OUT (0x8B), A | // SIO-0-K2C, 0x02
0712 3E B0 LD A, 0xB0 |
0714 D3 8B OUT (0x8B), A | // SIO-0-K2C, 0xb0
0716 CD 8B 06 CALL 0x068B | // Inital Speichern Alternativregister Teil2
0719 06 00 LD B, 0x00 |
071B CD 43 08 CALL 0x0843 | // Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
071E 06 6A LD B, 0x6A |
0720 CD 48 08 CALL 0x0848 | // Ausgabe SIO-0-K2C = 0x05, "B"
0723 06 D3 LD B, 0xD3 <--\ |
0725 CD 57 08 CALL 0x0857 | | // Ausgabe SIO-0-K2C = 0x03, "B"
0728 3A 11 0D LD A, (0x0D11)<\ | | // Status 0x0d11 = 0x00 ... 0x14
072B A7 AND A | | | // A == 0
072C 20 2B JR NZ 0x2B | | | >---\ // Sprung: Blockchiffrierung?
072E DB 8B IN A, (0x8B) | | | | // Lese SIO-0-K2C
0730 CB 67 BIT 4, A | | | | // bit 4 == 0
0732 20 F4 JR NZ 0xF4 >--/ | | | // nein
0734 06 C1 LD B, 0xC1 | | | // ja
0736 CD 57 08 CALL 0x0857 | | | // Ausgabe SIO-0-K2C = 0x03, "B"
0739 21 08 0D LD HL, 0x0D08 | | | // Daten, 0x16 für STZ
073C 36 16 LD M, 0x16 | | |
073E 3A 11 0D LD A, (0x0D11) <\ | | | // Status 0x0d11
0741 A7 AND A | | | | // A == 0
0742 20 15 JR NZ, 0x15 | | | >--+ // Sprung Blockchiffrierung?
0744 F3 DI | | | | // Sperre INT, Eingabe gesperrt
0745 D9 EXX | | | | // Alternativ-Registersatz tauschen, BC/DE/HL
0746 21 08 0D LD HL, 0x0D08 | | | |
0749 D9 EXX | | | | // Alternativ-Registersatz tauschen, BC/DE/HL
074A FB EI | | | | // INT Freigabe
074B 7E LD A, M | | | | // 0x0D11
074C FE 16 CP 0x16 | | | |
074E 28 EE JR Z 0xEE >--/ | | | // A == 0x16
0750 FE 55 CP 0x55 | | | // A == 0x55, STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0752 20 CF JR NZ 0xCF >-/ | | // nein
0754 CD BC 07 CALL 0x07BC | | // Ja: Folge 0x16, 0x55; Warte STZ ab, danach De- Chiffrierung; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0757 18 B5 JR 0xB5 >-+ |
0759 CD 5E 07 CALL 0x075E | <---/ // De- Chiffrierung
075C 18 B0 JR 0xB0 >-/
// Chiffrierung
075E 06 00 LD B, 0x00
0760 CD 57 08 CALL 0x0857 // Ausgabe SIO-0-K2C = 0x03, "B"
0763 06 6A LD B, 0x6A
0765 CD 48 08 CALL 0x0848 // Ausgabe SIO-0-K2C = 0x05, "B"
0768 DB 8B IN A, (0x8B) <-\ // Lese SIO-0-K2C
076A CB 6F BIT 5, A | // bit 5 == 0
076C 28 FA JR Z, 0xFA >--/ // Flankenabfrage
076E 01 DC 05 LD BC, 0x05DC // ja, Zeitwert für Warteschleife
0771 CD 61 08 CALL 0x0861 // Warteschleife; Übergabe BC
0774 AF XOR A // Lösche A, beeinflusse Flags
0775 32 10 0D LD (0x0D10), A // Status 0x0d10
0778 21 F7 0C LD HL, 0x0CF7 // Start; letzte gebildete Wurmreihe
077B 11 00 0D LD DE, 0x0D00 // Daten, 64 Bit + 9.Byte
077E 01 09 00 LD BC, 0x0009 // 9! Byte
0781 ED B0 LDIR // Blockkopie (DE) = M, von 0x0cf7 nach 0x0d00 8 bytes
0783 3A 01 0D LD A, (0x0D01) // kopiere Daten erstes byte nach 0x0d09
0786 32 09 0D LD (0x0D09), A // Kopie (0x0d09) = (0x0d01) = (0x0cf8)
0789 3A 00 0D LD A, (0x0D00) // Prüfbyte, aus 0x0cf7
078C EE FF XOR 0xFF // Inverse
078E 32 00 0D LD (0x0D00), A // (0x0d00) = not (0x0d00)
0791 CD 98 05 CALL 0x0598 // Initalisierung Wurmreihe/Dateneingabe für LAMBDA/ STZ-Kommando/Prüfsummen Wurmreihen
0794 3E 16 LD A, 0x16 // STZ ?
0796 D3 89 OUT (0x89), A // SIO-0-K2CD
0798 CD 00 18 CALL 0x1800 <---\ // LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
079B 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
079E CB 6F BIT 5, A | // bit 5 == 0
07A0 C0 RET NZ | // nein
07A1 3A 10 0E LD A, (0x0E10) | // ja; Status 0x0e10 = 0x00, 0x08
07A4 A7 AND A | // Prüfung auf 0x00; Flag N, C = 0; Zerro = 1 wenn A == 0x00
07A5 20 F4 JR NZ, 0xF4 >------+ // == 0?
07A7 CD EE 08 CALL 0x08EE | // XOR-Verknüpfung Wurmreihe XOR Daten
07AA 3A 11 0D LD A, (0x0D11) | // Schleifenzähler; Status 0x0d11 = 0x00 ... 0x14
07AD 3D DEC A |
07AE 32 11 0D LD (0x0D11), A | // Status 0x0d11 - 1
07B1 20 E5 JR NZ, 0xE5 >---/ // Schleife bis Status 0x0d11 == 0
07B3 CD 22 06 CALL 0x0622 // Rundenschlüssel mit Initalwert 0x87, Prüfe auf RAM1 und RAM2
07B6 C9 RET
// Warte STZ ab, danach Dechiffrierung
07B7 CD AC 06 CALL 0x06AC // Lese SIO-0-K2 bis 0x55 in 0x0d08; Abfrage STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
07BA 28 3A JR Z 0x3A >---\ // Zerro Flag der vorherigen Funktion == 1?, Sprung
|
// Chiffrierung |
07BC CD 38 05 CALL 0x0538 | // Kopiere Ein- Ausgabe LAMBDA von 0x0d08 nach 0x2A00
07BF CD 00 18 CALL 0x1800 | <---------\ // LAMBDA über 0x2a00 Ein-Ausgabe 64bit; 0x2800 Rundenschlüssel
07C2 21 10 0D LD HL, 0x0D10 | | // Status 0x0d10
07C5 CB 5E BIT 3, M <--\ | | // bit 3 == 0
07C7 28 FC JR Z, 0xFC >--/ | | // ja durch INT verändert M, Tastendruck?
07C9 CB 9E RES 3, M | | // Lösche Bit 3
07CB CB 66 BIT 4, M | | // bit 4 == 0
07CD 20 27 JR NZ 0x27 >---+ | // nein
07CF CD 36 09 CALL 0x0936 | | // ja-> XOR 8 byte Block, (0x2a00++) = (0x2a00++) XOR (0x0d08--)n
07D2 3A 11 0E LD A, (0x0E11) | | // Status 0x0e11; Status; Werte 0x04, 0x05, 0x0e, 0x0f; 0x0e/0x0f Senden-Empfangen Speicherbereich
07D5 EE 01 XOR 0x01 | | // Flip bit 0, A = 0x04 wird 0x05, A = 0x0f wird 0x0e
07D7 32 11 0E LD (0x0E11), A | | // Switch 0x04<>0x05; 0x0e0<>0x0f; Status 0x0e11 = 0x04, 0x05, 0x0e oder 0x0f invertiert Bit 0
07DA 21 08 0E LD HL, 0x0E08 | |
07DD 11 08 0F LD DE, 0x0F08 | |
07E0 1A LD A, (DE) | <--\ |
07E1 BE CP M | | |
07E2 20 0A JR NZ, 0x0A | >--\ | | // (DE) == M
07E4 2D DEC L | | | |
07E5 1D DEC E | | | |
07E6 20 F8 JR NZ 0xF8 | | >--/ |
07E8 DB 8D IN A, (0x8D) | | | // PIO-1-B-D Lese Tasteneingabe ANZEIGE, Schnittstellensignal DEE oder DÜE
07EA CB D7 SET 2, A | | | // Bit 2 = 1
07EC 18 04 JR 0x04 >--\ | | |
07EE DB 8D IN A, (0x8D) | | <--/ | // PIO-1-B-D Lese Tasteneingabe ANZEIGE; Schnittstellensignal DEE oder DÜE
07F0 CB 97 RES 2, A | | | // Bit 2 = 0
07F2 D3 8D OUT (0x8D), A<-/ | | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
07F4 18 C9 JR 0xC9 | >-------/
07F6 DB 8B IN A, (0x8B) <---/ // SIO-0-K2C Schnittstellensignal DEE oder DÜE
07F8 CB 67 BIT 4, A // bit 4 == 0
07FA C0 RET NZ // nein
07FB 3E 14 LD A, 0x14 // ja
07FD 32 11 0D LD (0x0D11), A // Status 0x0d11 = 0x14
0800 C9 RET
// Initalwerte nach RAM1, CTC Zeitkonstante; Übergabe HL, Warte auf INT17
0801 22 E0 0C LD (0x0CE0), HL // 0x0ce0 = M; Zeiger 0x0cee - abgelegt 9byte Wurm + Prüfbyte
0804 22 E2 0C LD (0x0CE2), HL // 0x0ce2 = M; Zeiger 0x0cf7 - abgelegt 9byte Wurm + Prüfbyte
0807 3E 08 LD A, 0x08
0809 32 E4 0C LD (0x0CE4), A // 0x0ce4 = 0x08; Schleifenvariable, Init = 8
080C 32 E9 0C LD (0x0CE9), A // 0x0ce9 = 0x08; Schleifenvariable, Init = 8
080F AF XOR A // Lösche A, beeinflusse Flags
0810 32 E6 0C LD (0x0CE6), A // 0x0ce6 = 0x00
0813 3E 87 LD A, 0x87 // EI, Zeitgeber, Vorteiler 16, neg. Flanke,Zeitkonst. Start, Zeitkonstante folgt, RESET
0815 D3 81 OUT (0x81), A // CTC Kanal 1 Zeitgeber
0817 3E 05 LD A, 0x05 // Zeitkonstante = 5 * 16 / f in ms
0819 D3 81 OUT (0x81), A // CTC Kanal 1 Takt
081B 21 EC 0C LD HL, 0x0CEC // RAM1
081E 36 40 LD M, 0x40 // 0x0cec = 0x40
0820 CB 7E BIT 7, M <---\ // Prüfe bit 7 (0x0cec)
0822 28 FC JR Z, 0xFC >---/ // wiederhole bis INT Routine 17 den Wert in (0x0cec) beeinflust
0824 C9 RET //
// Input PIO-1-B-C, Übergabe BC, Rückgabe A, BC
0825 DB 8B IN A, (0x8B) // SIO-0-K2C
0827 CB 5F BIT 3, A // Bit 3 == 0
0829 20 04 JR NZ, 0x04 >--\ // nein
082B 0B DEC BC | // ja BC--
082C 78 LD A, B | // A = B
082D B1 OR C | // A OR C
082E C9 RET | // Flag Z wird bei BC = 0 gesetzt, Rückgabe BC, A
|
082F 01 C8 00 LD BC, 0x00C8 <-/
0832 C9 RET // Rückgabe BC = 0x00c8 und A
// SIO-0-K1C Übergabe DE, Rückgabe A, DE
0833 DB 8A IN A, (0x8A) // SIO-0-K1C Lese
0835 EE 08 XOR 0x08 // toggel Bit 3 von A 0000 1000
0837 CB 5F BIT 3, A // Bit 3 == 0
0839 20 04 JR NZ, 0x04 >---\ // nein
083B 1B DEC DE | // ja
083C 7A LD A, D | // A = D
083D B3 OR E | // A = D or E
083E C9 RET | // SIO-0-K1C Rückgabewert DE, A und NZ/Z
|
083F 11 14 00 LD DE, 0x0014 <-/
0842 C9 RET // SIO-0-K1C Rückgabewert DE = 0x0014, A und NZ/Z
// Ausgabe SIO-0-K1C = 0x05, "B"; Übergabe B
0843 F3 DI // Sperre INT, Eingabe gesperrt
0844 3E 05 LD A, 0x05
0846 18 08 JR 0x08 >---\
|
// Ausgabe SIO-0-K2C = 0x05, "B" |
0848 F3 DI | // Sperre INT, Eingabe gesperrt
0849 3E 05 LD A, 0x05 |
084B 18 0D JR 0x0D | >-\
| |
// Ausgabe SIO-0-K1C = 0x03, "B" | |
084D F3 DI | | // Sperre INT, Eingabe gesperrt
084E 3E 03 LD A, 0x03 | |
0850 D3 8A OUT (0x8A),A </ | // SIO-0-K1C = 0x05 oder 0x03
0852 78 LD A, B |
0853 D3 8A OUT (0x8A), A | // SIO-0-K1C
0855 FB EI | // INT Freigabe
0856 C9 RET |
|
// Ausgabe SIO-0-K2C = 0x03, "B" |
0857 F3 DI | // Sperre INT, Eingabe gesperrt
0858 3E 03 LD A, 0x03 |
085A D3 8B OUT (0x8B), A <-/ // SIO-0-K2C 0x05 oder 0x03
085C 78 LD A, B
085D D3 8B OUT (0x8B), A // SIO-0-K2C
085F FB EI // INT Freigabe
0860 C9 RET
// Warteschleife; Übergabe BC
0861 F5 PUSH AF // Rette AF
0862 0B DEC BC <---\
0863 AF XOR A | // Lösche A, beeinflusse Flags
0864 B0 OR B |
0865 B1 OR C |
0866 20 FA JR NZ, 0xFA >--/ // BC 0 erreicht?
0868 F1 POP AF // Stelle AF wieder her
0869 C9 RET
// Fehlerbehandlungsroutine:
086A 3E 02 LD A, 0x02
086C D3 85 OUT (0x85), A // PI0-0-B-D
086E 16 02 LD D, 0x02
0870 3E 05 LD A, 0x05 <---\ // Kanal 5
0872 D3 8B OUT (0x8B), A | // SIO-0-K2C
0874 3E 02 LD A, 0x02 |
0876 D3 8B OUT (0x8B), A | // SIO-0-K2C
0878 01 E8 03 LD BC, 0x03E8 |
087B 0B DEC BC <--\ | // Zeitschleife 1/3 sec
087C AF XOR A | | // Lösche A, beeinflusse Flags
087D B0 OR B | |
087E B1 OR C | |
087F 20 FA JR NZ, 0xFA >--/ |
0881 3E 05 LD A, 0x05 | // Kanal 5
0883 D3 8B OUT (0x8B), A | // SIO-0-K2C
0885 3E 00 LD A, 0x00 |
0887 D3 8B OUT (0x8B), A | // SIO-0-K2C
0889 01 00 02 LD BC, 0x0200 |
088C 0B DEC BC <--\ | // Zeitschleife 1/4 sec
088D AF XOR A | | // Lösche A, beeinflusse Flags
088E B0 OR B | |
088F B1 OR C | |
0890 20 FA JR NZ, 0xFA >--/ |
0892 15 DEC D |
0893 20 DB JR NZ, 0xDB >----/
0895 F3 DI // Sperre INT, Eingabe gesperrt
0896 76 HALT // Fehler? Kann durch NMI oder Reset aus dem HALT geholt werden
// Fehler Systemhalt
0897 F3 DI // Sperre INT, Eingabe gesperrt
0898 3E 17 LD A, 0x17 // DI, Zeigeber, Vorteiler 16, neg. Flanke, Zeitgeberkonst. Start, Zeitkonstante folgt, RESET
089A D3 80 OUT (0x80), A // CTC Kanal 0 Zeitgber
089C 3E 20 LD A, 0x20 // Zeitgeberkonstante = 32 * 16 / f in ms
089E D3 80 OUT (0x80), A // CTC Kanal 0 Takt
08A0 3E 06 LD A, 0x06
08A2 D3 85 OUT (0x85), A // PI0-0-B-D
08A4 AF XOR A // Lösche A, beeinflusse Flags
08A5 D3 8D OUT (0x8D), A // PIO-1-B-D LED AUS; A1 und A2 Bit 4 und 3
08A7 DB 8C IN A, (0x8C) // PIO-1-A-D
08A9 E6 20 AND 0x20 // Maskiere Bit 5
08AB 20 12 JR NZ 0x12 >--\ // Bit 5 == 1
08AD 3E 05 LD A, 0x05 | // Routine Bit 5 == 0
08AF D3 8B OUT (0x8B), A | // SIO-0-K2C
08B1 3E 68 LD A, 0x68 |
08B3 D3 8B OUT (0x8B), A | // SIO-0-K2C
08B5 3E 05 LD A, 0x05 |
08B7 D3 8A OUT (0x8A), A | // SIO-0-K1C
08B9 3E 68 LD A, 0x68 |
08BB D3 8A OUT (0x8A), A | // SIO-0-K1C
08BD 18 10 JR 0x10 | >--\ // Bit 5 == 0
08BF 3E 05 LD A, 0x05 <--/ | // Kanal 5
08C1 D3 8B OUT (0x8B), A | // SIO-0-K2C
08C3 3E 6A LD A, 0x6A | // SIO-0-K1C
08C5 D3 8B OUT (0x8B), A | // SIO-0-K2C
08C7 3E 05 LD A, 0x05 | // Kanal 5
08C9 D3 8A OUT (0x8A), A | // SIO-0-K1C
08CB 3E EA LD A, 0xEA |
08CD D3 8A OUT (0x8A), A | // SIO-0-K1C
08CF 21 E6 08 LD HL, 0x08E6 <--/ // Datenbereich 0x08E6 Intitialisierung mittes OTIR
08D2 06 08 LD B, 0x08 // 8 Byte Länge
08D4 0E 8B LD C, 0x8B // SIO-0-K2C
08D6 ED B3 OTIR // Datenblock -> SIO-0-K2C Ausgabe
08D8 DB 8C IN A, (0x8C) // PIO-1-A-D
08DA E6 20 AND 0x20 // Bit 5 Maskieren
08DC 06 28 LD B, 0x28
08DE 28 02 JR Z, 0x02 >---\ // Bit 5 == 1 gebe (SIO-0-K2C) = 0x028 aus
08E0 06 2A LD B, 0x2A | // Bit 5 == 0 gebe (SIO-0-K2C) = 0x02a aus
08E2 ED 41 OUT (C), B <---/
08E4 F3 DI // Sperre INT, Eingabe gesperrt
08E5 76 HALT // ?Hardware? - Fehler? Kann durch NMI oder Reset aus dem HALT geholt werden
// Datenbereich für SIO-0-K2C Steuerbytes = 8
08E6 18 04 10 06 AA 07 AA 05 //
// XOR-Verknüpfung Wurmreihe XOR Daten
08EE 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
08F1 01 0D 0D LD BC, 0x0D0D // Daten Start
08F4 3A 11 0E LD A, (0x0E11) // Status 0x0e11 0x0e, 0x0f-> Senden/Empfangen
08F7 57 LD D, A // 0x0e oder 0x0f
08F8 1E 08 LD E, 0x08 // DE = 0x0e08 oder 0x0f08; Ablageort Chiffrat und Schleifenzähler 8byte
08FA 0A LD A, (BC) <--\ // A = (0x0d0d)
08FB AE XOR M | // Daten XOR Wurmreihe
08FC 12 LD (DE), A | // Kopie in (DE) abgelegt 0x0e00+n 0x0f00+n
08FD 77 LD M, A | // Ein- Ausgabe LAMBDA
08FE 0D DEC C | // 0x0d0d--
08FF 2C INC L | // 0x2a00++ (E schleifenzähler)
0900 1D DEC E | // von 0x0e08 bis 0x0e01; 0x2A00 - 0x2A07; 0x0d0d - 0x0d05
0901 20 F7 JR NZ, 0xF7 >--/ // 8 Bytes ablegen, XOR verknüft
0903 3E 08 LD A, 0x08
0905 32 10 0E LD (0x0E10), A // Status 0x0e10 = 0x08
0908 3A 00 0D LD A, (0x0D00) // Daten
090B 21 08 2A LD HL, 0x2A08 // Prüfbyte mit letztem Wert
090E AE XOR M // (0x0d00) XOR (0x2a08)
090F 12 LD (DE), A // (DE = 0x0e00) = A
0910 EE FF XOR 0xFF // invertiert A
0912 77 LD M, A // (0x2a08) = NOT(DE)
0913 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen mit Prüfbyte
0916 11 EE 0C LD DE, 0x0CEE // von 0x2a00 nach 0x0cee kopierte 9! byte
0919 01 09 00 LD BC, 0x0009 // Schleifenzähler = 9!
091C F3 DI // Interrupt verbieten
091D ED B0 LDIR // Blockkopie 9! bytes, von 0x2a00 nach 0x0cee
091F FB EI // INT Freigabe
0920 21 01 0D LD HL, 0x0D01 // Daten 0x0d01 - 0x0d05
0923 11 09 0D LD DE, 0x0D09 // Ziel 0x0d09 - 0x0d0d
0926 01 05 00 LD BC, 0x0005 // Schleifenzähler = 5
0929 ED B0 LDIR // Blockkopie 5 bytes, (DE) = M
092B 21 00 0C LD HL, 0x0C00
092E 3E 45 LD A, 0x45
0930 AE XOR M // 0x45 XOR (0x0c00) System-Signal
0931 C2 40 01 JP NZ, 0x0140 // 0x0c00 != 0x45 ERROR LED Blinken
0934 77 LD M, A // (0x0c00) = A = 0x45
0935 C9 RET
// XOR 8 byte Block, (0x2a00++) = (0x2a00++) XOR (0x0d08--)
0936 3A 11 0E LD A, (0x0E11) // Status 0x0e11; 0x0e, 0x0f
0939 57 LD D, A
093A 1E 08 LD E, 0x08 // DE = 0x0e08 oder 0x0f08
093C 7B LD A, E // A = 0x08
093D 32 10 0E LD (0x0E10), A // Status 0x0e10 = 0x08
0940 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
0943 01 08 0D LD BC, 0x0D08 // Daten
0946 0A LD A, (BC) <-\ // Hole Byte
0947 AE XOR M | // (0x0d08+x) XOR (0x2a00+x)
0948 12 LD (DE), A | // (DE) = (BC) XOR M
0949 0A LD A, (BC) | //
094A 77 LD M, A | // M = (BC)
094B 2C INC L | // 0x2a01 ...
094C 1D DEC E | // 0x0e07 ...
094D 0D DEC C | // 0x0d07 ...
094E 20 F6 JR NZ 0xF6 >-/ // bis C == 0
0950 C9 RET // 8 byte chiffriert
INT-Routine 7: Lese SIO-0-K1D Empfange Daten, bis 0x2aff gefüllt ist
0951 08 EX AF, AF' // INT-Registersatz, AF
0952 D9 EXX // INT-Registersatz, BC/DE/HL
0953 3A 11 0D LD A, (0x0D11) // Status 0x0d11
0956 A7 AND A // abfrage auf 0
0957 28 29 JR Z 0x29 >----\ // A == 0 Sprung, Lese SIO-0-Input
0959 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
095C CB 5F BIT 3, A |
095E 20 22 JR NZ, 0x22 >----+ // Bit 3 == 1 Sprung
0960 DB 88 IN A, (0x88) | // SIO-0-K1D Input
0962 77 LD M, A | // (0x2A00) = Input
0963 2D DEC L | // L--, M 0x2A00 ... 0x2AFF als Ringspeicher
0964 28 05 JR Z, 0x05 >---\ | // HL == 0x2A00
0966 08 EX AF, AF' | | <-\ // Alternativ-Registersatz tauschen, AF
0967 D9 EXX | | | // Alternativ-Registersatz tauschen, BC/DE/HL
0968 FB EI | | | // INT Freigabe
0969 ED 4D RETI | | | // Return, Beende INT Routine
| | |
096B 2E 10 LD L, 0x10 <---+ | | // HL != 0x2A00, HL = 0x2A10
096D CB DE SET 3, M | | | // Bit 3 (0x2A10), wenn 0x00 dann 0x08
096F 2E 0D LD L, 0x0D | | | // 0x2A0D
0971 3E FF LD A, 0xFF | | | // A = 0xff
0973 C5 PUSH BC | | |
0974 06 08 LD B, 0x08 | | | // Länge 8
0976 AE XOR M <--\ | | | // A = NOT (HL + x); 0x2a0d bis 0x2a06
0977 2D DEC L | | | |
0978 10 FC DJNZ 0xFC >--/ | | | // 8 bytes
097A 32 00 0D LD (0x0D00), A | | | // Ergebnis in 0x0d00 ablegen
097D C1 POP BC | | |
097E 2E 08 LD L, 0x08 | | | // HL = 0x2a08
0980 18 E4 JR 0xE4 | | >-+ // RETI
0982 DB 88 IN A, (0x88) | </ | // SIO-0-K1D Input
0984 18 E0 JR 0xE0 | >-/ // RETI
|
INT Routine NR. 15 | //springt in INT-7 ließt SIO-0-K1D oder schreibt 0x16 in 0x0f01 bis 0x0f10
0986 08 EX AF, AF' | // INT-Registersatz, AF
0987 D9 EXX | // INT-Registersatz, BC/DE/HL
0988 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
098B CB 47 BIT 0, A | //
098D 20 CD JR NZ 0xCD >-----/ // Bit 0 == 1
098F DB 88 IN A, (0x88) // SIO-0-K1D Bit 0 == 0
0991 FE FF CP 0xFF // vergleiche auf 0xff
0993 20 05 JR NZ 0x05 >--\ // Input == 0xff
0995 08 EX AF, AF' | // Alternativ-Registersatz tauschen, AF, Input != 0xff
0996 D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
0997 FB EI | // INT Freigabe
0998 ED 4D RETI | // Return Interruptprogramm Modus 2
|
099A 32 09 0D LD (0x0D09), A <--/ // Input == 0xff, rette A in 0x0d09
099D 3E 16 LD A, 0x16
099F 11 01 0F LD DE, 0x0F01
09A2 06 0F LD B, 0x0F // Länge 0x0f
09A4 12 LD (DE), A <--\ // (0x0f01) = 0x16
09A5 13 INC DE | // 0x0f01+1
09A6 10 FC DJNZ 0xFC >-- // (0x0f01) ... (0x0fff) = 0x16 fülle Stack mit 0x16
09A8 31 00 10 LD SP, 0x1000 // Stackpointer = 0x1000 bis 0x0e00; geradebiegen des Stackpointers
09AB 21 77 04 LD HL, 0x0477 // Einsprungadresse für SIO-0-K2 Intialisierung
09AE E5 PUSH HL // (0x0ffe) = 77, (0x0fff) = 04
09AF 21 08 0D LD HL, 0x0D08 // Daten byte 1
09B2 08 EX AF, AF' // Alternativ-Registersatz tauschen, AF
09B3 D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
09B4 ED 4D RETI // Return Interruptprogramm Modus 2
// INT Routine NR. 3 Lese SIO-0-K2CD, 256 byte, Vergleiche (HL) Inhalte
09B6 08 EX AF, AF' // INT-Registersatz, AF
09B7 D9 EXX // INT-Registersatz, BC/DE/HL
09B8 DB 89 IN A, (0x89) // SIO-0-K2CD
09BA 77 LD M, A // lege in 0x???? ab
09BB 2D DEC L // L - 1, Ringspeicher 0x00 ... 0xff
09BC 28 05 JR Z, 0x05 >--\ // L == 00
09BE 08 EX AF, AF' | // Alternativ-Registersatz tauschen, AF
09BF D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
09C0 FB EI | // INT Freigabe
09C1 ED 4D RETI | // Return, Beende INT Routine
|
09C3 2E 08 LD L, 0x08 <---+
09C5 7E LD A, M |
09C6 2D DEC L | // 0xYY07
09C7 BE CP M | // Vergleich HL == HL + 1; HL != HL + 1
09C8 06 05 LD B, 0x05 | // Länge 5
09CA 28 02 JR Z, 0x02 | >--------\ // L --
09CC 2D DEC L | | // L --
09CD 7E LD A, M | |
09CE 2D DEC L | <---------+ // HL != HL + 1 dann L + 2 sonst L + 1
09CF 28 09 JR Z, 0x09 | >--\ | // L == 0, Abbruch
09D1 BE CP M | | |
09D2 20 FA JR NZ, 0xFA | | >---+ // L--
09D4 10 F8 DJNZ 0xF8 | | >---/ // BC--
09D6 2E 10 LD L, 0x10 | |
09D8 CB E6 SET 4, M | |
09DA 2E 10 LD L, 0x10 | <--/
09DC CB DE SET 3, M |
09DE 3A 01 0D LD A, (0x0D01) |
09E1 F6 20 OR 0x20 | // Bit 6 setzen
09E3 47 LD B, A |
09E4 2E 08 LD L, 0x08 |
09E6 08 EX AF, AF' | // Alternativ-Registersatz tauschen, AF
09E7 D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
09E8 FB EI | // INT Freigabe
09E9 ED 4D RETI | // Return, Beende INT Routine
|
INT Routine NR. 11 | // Einsprung INT-3, Lese SIO-0-K2CD, Prüfe Startfolge; Übergabe SIO-0-K2C
09EB 08 EX AF, AF' | // INT-Registersatz, AF
09EC D9 EXX | // INT-Registersatz, BC/DE/HL
09ED 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
09F0 CB 4F BIT 1, A | // Bit A == 0
09F2 20 C4 JR NZ 0xC4 >--/ // nein
09F4 CB 57 BIT 2, A // Ja, Bit 2 == 0
09F6 DB 89 IN A,(0x89) // SIO-0-K2CD
09F8 28 2B JR Z, 0x2B >--\ // ja
09FA FE 55 CP 0x55 | // Input = 0x55; STZ?; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
09FC 28 34 JR Z 0x34 | >-\ // ja
09FE E5 PUSH HL | | // nein
09FF 2A F5 0E LD HL, (0x0EF5) | | // Starbereich STZ-Folge?
0A02 BE CP M | | // A == M
0A03 28 0C JR Z 0x0C | | >-\ // ja
0A05 3E 55 LD A, 0x55 | | | // STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0A07 BE CP M | | | // M == 0x55; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0A08 28 17 JR Z, 0x17 | | | >-\ // ja
0A0A 3A 10 0D LD A, (0x0D10) | | | | // nein Status 0x0d10
0A0D C6 40 ADD A, 0x40 | | | | // A = 0x40 + Status 0x0d10
0A0F 18 05 JR 0x05 | | | >-\ |
| | | | |
0A11 3A 10 0D LD A, (0x0D10) | | <-/ | | // Status 0x0d10
0A14 E6 3F AND 0x3F | | | | // Maske 0011 1111 (7bit)
0A16 32 10 0D LD (0x0D10), A | | <-+ | // Status 0x0d10
0A19 36 55 LD M, 0x55 | | | | // STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0A1B 2C INC L | | | |
0A1C 20 03 JR NZ, 0x03 | | | >--+ // STZ gefunden
0A1E 21 F7 0E LD HL, 0x0EF7 | | | | // Ansonsten Zeigerkopie?
0A21 22 F5 0E LD (0x0EF5), HL | | | <-/ // Startbereich STZ-Folge?
0A24 E1 POP HL | | |
0A25 3E 03 LD A, 0x03 <---/ | |
0A27 D3 8B OUT (0x8B), A | | // SIO-0-K2C
0A29 3E D3 LD A, 0xD3 | |
0A2B D3 8B OUT (0x8B), A | | // SIO-0-K2C
0A2D 08 EX AF, AF' | | // Alternativ-Registersatz tauschen, AF
0A2E D9 EXX | | // Alternativ-Registersatz tauschen, BC/DE/HL
0A2F FB EI | | // INT Freigabe
0A30 ED 4D RETI | | // Return Interrupt
| |
0A32 06 16 LD B, 0x16 <------/ |
0A34 31 00 10 LD SP, 0x1000 | // Setzte Stackpointer auf 0x1000; geradebiegen des Stackpointers
0A37 21 99 04 LD HL, 0x0499 | // HL = 0x0499
0A3A E5 PUSH HL | // Rette HL (in 0x0fff)
0A3B 08 EX AF, AF' | // Alternativ-Registersatz tauschen, AF
0A3C D9 EXX | // Alternativ-Registersatz tauschen, BC/DE/HL
0A3D ED 4D RETI | // Return, Beende INT Routine
|
// INT Routine NR. 5 | // Einsprung INT 11, 3; Ausgabe SIO-0-K1D
0A3F 08 EX AF, AF' | // INT-Registersatz, AF
0A40 D9 EXX | // INT-Registersatz, BC/DE/HL
0A41 1D DEC E |
0A42 28 08 JR Z, 0x08 >-\ | // E == 0
0A44 1A LD A, (DE) | | // E == 1
0A45 D3 88 OUT (0x88), A | | // SIO-0-K1D
0A47 08 EX AF, AF' | | // Alternativ-Registersatz tauschen, AF
0A48 D9 EXX | | // Alternativ-Registersatz tauschen, BC/DE/HL
0A49 FB EI | | // INT Freigabe
0A4A ED 4D RETI | | // Return, Ende INT Routine
| |
0A4C 3A 10 0E LD A, (0x0E10)<-+ | // Status 0x0e10 = 0x04, 0x05, 0x08, 0x0e, 0x0f
0A4F A7 AND A | | // Vergleich auf (0x0e10) == 0x00
0A50 28 0E JR Z 0x0E | >-\ | // Status 0x0e10 == 0
0A52 5F LD E, A | | | // Status 0x0e10 = 0x04, 0x05, 0x08, 0x0e, 0x0f
0A53 7A LD A, D | | |
0A54 32 11 0E LD (0x0E11), A | | | // Status 0x0e11 = "D"
0A57 EE 01 XOR 0x01 | | | // toggle Bit 0 (0x05 oder 0x0e)
0A59 57 LD D, A | | | // Rette A
0A5A AF XOR A | | | // Lösche A, beeinflusse Flags
0A5B 32 10 0E LD (0x0E10), A | | | // Status 0x0e10 = 0x00
0A5E 18 E4 JR 0xE4 | | >-/ // goto 0x0a16
| |
0A60 3A 10 0D LD A, (0x0D10) | <-+ // Status 0x0d10
0A63 CB EF SET 5, A | | // Bit 5 = 1
0A65 32 10 0D LD (0x0D10), A | | // Status 0x0d10 = 0x10 ... 0x1f, 0x30 ... 0x3f
0A68 3E 28 LD A, 0x28 | |
0A6A D3 8A OUT (0x8A), A | | // SIO-0-K1C
0A6C 18 D9 JR 0xD9 >-----/ | // goto 0x0a4c
|
// INT Routine NR. 13 | // Einsprung INT-5, 11, 3; Ausgabe SIO-0-K1C
0A6E 08 EX AF, AF' | // INT-Registersatz, AF
0A6F D9 EXX | // INT-Registersatz, BC/DE/HL
0A70 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
0A73 CB 4F BIT 1, A |
0A75 20 CA JR NZ 0xCA >----/ // Bit 1 == 0 goto 0x0a60
0A77 3E 28 LD A, 0x28 // Bit 1 == 1
0A79 D3 8A OUT (0x8A), A // SIO-0-K1C
0A7B 08 EX AF, AF' // Alternativ-Registersatz tauschen, AF
0A7C D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
0A7D FB EI // INT Freigabe
0A7E ED 4D RETI // Return, beende INT Routine
// INT Routine Nr. 1: Ausgabe SIO-0-K2CD
0A80 08 EX AF, AF' // INT-Registersatz, AF
0A81 D9 EXX // INT-Registersatz, BC/DE/HL
0A82 1D DEC E // E - 1
0A83 28 0C JR Z,0x0C >---\ // E == 0x00; Error
0A85 CB CA SET 1, D | <-------\ // E > 0x00, D Bit 1 = 1
0A87 1A LD A, (DE) | |
0A88 D3 89 OUT (0x89), A | | // SIO-0-K2CD
0A8A A9 XOR C | | // (DE) XOR C
0A8B 4F LD C, A | | // C = (DE) XOR C
0A8C 08 EX AF, AF' | <---\ | // Alternativ-Registersatz tauschen, AF
0A8D D9 EXX | | | // Alternativ-Registersatz tauschen, BC/DE/HL
0A8E FB EI | | | // INT Freigabe
0A8F ED 4D RETI | | | // Return, beende INT Routine
ERROR | | |
0A91 1A LD A, (DE) <---/ | |
0A92 A9 XOR C | | // A = (DE) XOR C
0A93 EE FF XOR 0xFF | | // A = NOT ((DE) XOR C)
0A95 4F LD C, A | | // C = NOT ((DE) XOR C)
0A96 C2 40 01 JP 0x0140 | | // ERROR LED Blinken
| |
0A99 EE FF XOR 0xFF | | // NOT A
0A9B 20 03 JR NZ, 0x03 >---\ | | // A == 0x00
0A9D C3 40 01 JP 0x0140 | | | // A > 0x00 ERROR LED Blinken
Einsprung aus INT-9 | | | // Rückgabe DE 0x0Enn, 0x0fnn
0AA0 3A 10 0E LD A, (0x0E10) <--/ | | // Status 0x0e10
0AA3 A7 AND A | | // (0x0e10) == 0?
0AA4 28 10 JR Z, 0x10 >---\ | | // Status 0x0e10 == 0x00
0AA6 5F LD E, A | | | // Status 0x0e10 > 0x00
0AA7 3A 11 0E LD A, (0x0E11) | | | // Status 0x0e11; 0x0e, 0x0f
0AAA 57 LD D, A | | | // DE 0x0Enn 0x0Fnn
0AAB EE 01 XOR 0x01 | | | // Switch 0x0e<>0x0f;
0AAD 32 11 0E LD (0x0E11), A | | | // Switch 0x0e<>0x0f; Status 0x0e11; 0x04, 0x05, 0x0e, 0x0f
0AB0 AF XOR A | | | // A = 0
0AB1 32 10 0E LD (0x0E10), A | | | // Status 0x0e10 = 0x00
0AB4 18 CF JR 0xCF | | >-+
| | |
0AB6 3A 10 0D LD A, (0x0D10) <--/ | | // Status 0x0d10
0AB9 CB EF SET 5, A | | // Bit 5 = 1
0ABB 32 10 0D LD (0x0D10), A | | // Status 0x0d10 = 0x10 ... 0x1f, 0x30 ... 0x3f
0ABE 3E 28 LD A, 0x28 | |
0AC0 D3 8B OUT (0x8B),A | | // SIO-0-K2C
0AC2 18 C8 JR 0xC8 >-/ |
|
// INT Routine Nr. 9 | // läuft in INT-1 weiter, oder ERROR
0AC4 08 EX AF, AF' | // INT-Registersatz, AF
0AC5 D9 EXX | // INT-Registersatz, BC/DE/HL
0AC6 3A 10 0D LD A, (0x0D10) | // Status 0x0d10
0AC9 CB 47 Bit 0, A |
0ACB 28 34 JR Z, 0x34 >--\ | // Status 0x0d10 Bit 0 == 0
0ACD 1D DEC E | | // Status 0x0d10 Bit 0 == 1
0ACE 20 B5 JR NZ, 0xB5 | >-------/ // E != 0x00 nach INT-Nr.1
0AD0 1A LD A, (DE) | // E == 0x00
0AD1 A9 XOR C | // A = A XOR C
0AD2 EE FF XOR 0xFF | // Invers
0AD4 4F LD C, A | // C = NOT (A XOR C)
0AD5 C2 40 01 JP 0x0140 | // ERROR LED Blinken
|
0AD8 EE FF XOR 0xFF | // NOT A, prüfe auf != 0xff
0ADA 20 03 JR NZ, 0x03 | >---\ // A != 0xff
0ADC C3 40 01 JP 0x0140 | | // A == 0xff ERROR LED Blinken
| |
0ADF 1C INC E | <---/ // A != 0xff
0AE0 1A LD A, (DE) |
0AE1 F6 20 OR 0x20 | // A Bit 5 wird gesetzt
0AE3 16 0E LD D, 0x0E |
0AE5 58 LD E, B |
0AE6 47 LD B, A |
0AE7 1A LD A, (DE) |
0AE8 FE 55 CP 0x55 | // STZ; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0AEA 28 0A JR Z, 0x0A | >---\ // (DE) == 0x55; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0AEC 3A 10 0D LD A, (0x0D10) | | // (DE) != 0x55; Status 0x0d10; ist die SyncF korrekt wird LED 109.1 Signal eingeschaltet
0AEF CB FF SET 7, A | | // RAM Wert: 0x80 ... 0xff
0AF1 32 10 0D LD (0x0D10), A | | // Status 0x0d10
0AF4 18 08 JR 0x08 | | >---\
| | |
0AF6 78 LD A, B | <--/ |
0AF7 12 LD (DE), A | |
0AF8 43 LD B, E | |
0AF9 04 INC B | | // B++, Zerro Flag wenn B == 0x00 wird
0AFA 20 02 JR NZ, 0x02 | >-----+ // B != 0xFF
0AFC 06 F7 LD B, 0xF7 | | // B == 0xFF, B = 0xf7
0AFE C3 A0 0A JP 0x0AA0 | <---/ // weiter bei 0x0aa0, INT-1
|
0B01 78 LD A, B <--/
0B02 D3 89 OUT (0x89), A // SIO-0-K2CD
0B04 06 16 LD B, 0x16
0B06 08 EX AF, AF' // Alternativ-Registersatz tauschen, AF
0B07 D9 EXX // Alternativ-Registersatz tauschen, BC/DE/HL
0B08 FB EI // INT Freigabe
0B09 ED 4D RETI // Return, beende INT Routine
// INT Progr Nr. 6 SIO-K1C
0B0B 08 EX AF, AF' // INT-Registersatz, AF
0B0C DB 8A IN A, (0x8A) // SIO-0-K1C
0B0E 18 1E JR 0x1E >--\
|
// INT Progr Nr. 2 SIO-K2C |
0B10 08 EX AF, AF' | // INT-Registersatz, AF
0B11 DB 8B IN A, (0x8B) | // SIO-0-K2C
0B13 18 30 JR 0x30 | >--\
| |
// INT Progr Nr. 8 und 16 SIO-K1C | |
0B15 08 EX AF, AF' | | // INT-Registersatz, AF
0B16 3E 30 LD A, 0x30 | | // SIO-0-K1C Ausgabe
0B18 18 16 JR 0x16 | | >---\
| |
// INT Progr Nr. 4 und 12 SIO-K2C | | |
0B1A 08 EX AF, AF' | | | // INT-Registersatz, AF
0B1B 3E 30 LD A, 0x30 | | | // SIO-0-K2C Ausgabe
0B1D 18 28 JR 0x28 | | | >-\
| | | |
// INT Routine NR. 14 SIO-K1C | | | |
0B1F 08 EX AF, AF' | | | | // INT-Registersatz, AF
0B20 DB 8A IN A, (0x8A) | | | | // SIO-0-K1C
0B22 CB 67 BIT 4, A | | | |
0B24 20 08 JR NZ, 0x08 >-+ | | | // Bit 4 == 1
0B26 3E 03 LD A, 0x03 | | | | // Bit 4 == 0
0B28 D3 8A OUT (0x8A), A | | | | // SIO-0-K1C
0B2A 3E C3 LD A, 0xC3 | | | |
0B2C D3 8A OUT (0x8A), A | | | | // SIO-0-K1C
0B2E 3E 10 LD A, 0x10 <-/ | | |
0B30 D3 8A OUT (0x8A), A | <---/ | // SIO-0-K1C
0B32 08 EX AF, AF' | | // Alternativ-Registersatz tauschen, AF
0B33 FB EI | | // INT Freigabe
0B34 ED 4D RETI | | // Return, Beende INT Routine
| |
// INT Routine NR. 10 SIO-K2C | |
0B36 08 EX AF, AF' | | // INT-Registersatz, AF
0B37 DB 8B IN A, (0x8B) | | // SIO-0-K2C
0B39 CB 67 BIT 4, A | |
0B3B 20 08 JR NZ, 0x08 >---+ | // Bit 4 == 1
0B3D 3E 03 LD A, 0x03 | | // Bit 4 == 0
0B3F D3 8B OUT (0x8B), A | | // SIO-0-K2C
0B41 3E C3 LD A, 0xC3 | |
0B43 D3 8B OUT (0x8B), A | | // SIO-0-K2C
0B45 3E 10 LD A, 0x10 <-----/ |
0B47 D3 8B OUT (0x8B), A <---------------/ // SIO-0-K2C
0B49 08 EX AF, AF' // Alternativ-Registersatz tauschen, AF
0B4A FB EI // INT Freigabe
0B4B ED 4D RETI // Return Interruptprogramm Modus 2
// INT Routine NR. 17 Rauschgenerator; Idealwert 0x4d - im Bereich 0x17 bis 0x67
0B4D F5 PUSH AF // Register A, BC, DE, HL retten
0B4E C5 PUSH BC
0B4F D5 PUSH DE
0B50 E5 PUSH HL
0B51 DB 8D IN A, (0x8D) // PIO-1-B-D Lese Tasteneingabe ANZEIGE, Schnittstellensignal DEE oder DÜE
0B53 CB 6F BIT 5, A // Bit 5 == 0
0B55 28 06 JR Z, 0x06 >---\ // ja; LED Ein/Aus/POP/RETI
0B57 CB AF BIT 5, A | // nein, Flankenwechsel
0B59 D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2; Ausgabe lt. Z80Sim (0x8d) = 0x0f
0B5B 18 07 JR 0x07 | >-\
| |
0B5D CB EF SET 5, A <-/ | // setze Bit 5
0B5F D3 8D OUT (0x8D), A | // PIO-1-B-D LED Ein/AUS; A1 und A2 Bit 0 und 2
0B61 C3 E2 0B JP 0x0BE2 | >------\ // POP/RETI
| |
0B64 21 E5 0C LD HL, 0x0CE5 <-----/ | // Zählervariable 50/50 0/1 Anzahl
0B67 DB 8D IN A, (0x8D) | // PIO-1-B-D Lese Tasteneingabe ANZEIGE; Schnittstellensignal DEE oder DÜE
0B69 CB 77 BIT 6, A |
0B6B 28 02 JR Z, 0x02 >-\ | // Bit 6 == 1
0B6D CB C6 SET 0, (HL) | | // Bit 6 == 0 (0x0ce5); falls M 0x4d war ist es jetzt 0x4c
0B6F 7E LD A, M <-/ | // 0x0ce5
0B70 FE 4D CP 0x4D | // Prüfung der Zufallsfolge auf 0x4d, BArch 549 Seite 22; 0100 1101
0B72 20 07 JR NZ, 0x07 >-----\ | // 0x0ce5 != 0x4d
0B74 21 E6 0C LD HL, 0x0CE6 | | // 0x0ce6; Schleifenvariable
0B77 34 INC M | | // (0x0ce6)++
0B78 20 01 JR NZ, 0x01 >-----+ | // (0x0ce6) > 0
0B7A 35 DEC M | | // (0x0ce6) == 0 dann (0x0ce6)--
0B7B 21 E9 0C LD HL, 0x0CE9 <-----/ |
0B7E 35 DEC M | // (0x0ce9)--
0B7F 28 07 JR Z, 0x07 >-\ | // (0x0ce9) == 0
0B81 21 E5 0C LD HL, 0x0CE5 | | // (0x0ce9) != 0
0B84 CB 26 SLA M | | // Shift Left (0x0ce5) null -> 0 -> 7 -> carry
0B86 18 5A JR 0x5A | >---------+ // POP/RETI
0B88 36 08 LD M, 0x08 <-/ | // (0x0ce9) = 0x08
0B8A 21 E5 0C LD HL, 0x0CE5 | // Anzahl Zufall im Bereich; Prüfwert 0x4d
0B8D 7E LD A, M |
0B8E CB 26 SLA M | // Shift Left (0x0ce5), null -> 0 -> 7 -> carry
0B90 2A E0 0C LD HL, (0x0CE0) | // Zeiger auf Adresse 0x0cee
0B93 77 LD M, A | // Kopie vor SLA, 0x0ce5 -> 0x0ce0
0B94 23 INC HL | // Schleife
0B95 22 E0 0C LD (0x0CE0), HL | // ++Zeiger ab: 0x0cee
0B98 21 EB 0C LD HL, 0x0CEB |
0B9B AE XOR M | // (0x0ce0) XOR (0x0ceb); Schleife
0B9C 77 LD M, A | // in 0x0ceb abgelegt
0B9D 21 E4 0C LD HL, 0x0CE4 | // Schleifenvariable, Init = 8
0BA0 35 DEC M |
0BA1 20 3F JR NZ, 0x3F >-------------+ // (0x0ce4) > 0, POP/RETI
0BA3 36 08 LD M, 0x08 | // (0x0ce4) == 0, (0x0ce4) = 0x08
0BA5 3A EB 0C LD A, (0x0CEB) |
0BA8 2A E0 0C LD HL, (0x0CE0) | // Zeiger auf 0x0cee
0BAB 77 LD M, A | // Kopiere (0xceb) nach (0xcee)
0BAC 2A E2 0C LD HL, (0x0CE2) | // Lade Kopie des Zeiger zurück; Zeiger auf 0x0cf7 (Kopie von 0x0cee)
0BAF 22 E0 0C LD (0x0CE0), HL | // Umkopieren der Zeiger 0x0ce0/0x0ce2 der Adressen 0x0cee/0x0cf7
0BB2 21 EB 0C LD HL, 0x0CEB |
0BB5 36 00 LD M, 0x00 | // (0x0ceb) = 00; 0x0c00
0BB7 21 E7 0C LD HL, 0x0CE7 |
0BBA 35 DEC M | // (0x0ce7) - 1
0BBB 20 25 JR NZ 0x25 >-------------+ // (0x0ce7) > 0; POP/RETI
0BBD 3A E6 0C LD A, (0x0CE6) | // (0x0ce7) == 0
0BC0 FE 17 CP 0x17 | // Zu wenig?
0BC2 38 04 JR C, 0x04 >---\ | // A < 0x17 ?
0BC4 FE 67 CP 0x67 | | // Zu viel?
0BC6 38 11 JR C 0x11 | >-\ | // A < 0x67 ?
0BC8 3A EA 0C LD A, (0x0CEA)<-/ | | // A < 0x017, A = (0x0cea)
0BCB 3D DEC A | | // A - 1
0BCC 32 EA 0C LD (0x0CEA), A | | // (0x0cea) - 1
0BCF 3E C0 LD A, 0xC0 | | // A = 0xc0
0BD1 28 08 JR Z, 0x08 | >-\ | // Zerro Flag bei DEC A auf 0?
0BD3 AF XOR A | | | // Lösche A, beeinflusse Flags
0BD4 32 E6 0C LD (0x0CE6), A | | | // (0x0ce6) = 0
0BD7 18 09 JR 0x09 | | >-+ // POP/RETI
0BD9 3E 80 LD A, 0x80 <-/ | |
0BDB 32 EC 0C LD (0x0CEC), A <-------/ | // (0x0cea) == 0, (0x0cec) = 0xc0
0BDE 3E 03 LD A, 0x03 | // (0x0cea) != 0, (0x0cec) = 0x80
0BE0 D3 81 OUT (0x81), A | // CTC Kanal 1 DI, Zeitgeber Vorteiler 16, neg. Flanke, Zeitkonst. Start, RESET
0BE2 E1 POP HL <-----------/ // Register A, BC,DE HL wiederherstellen
0BE3 D1 POP DE
0BE4 C1 POP BC
0BE5 F1 POP AF
0BE6 FB EI // INT Freigabe
0BE7 ED 4D RETI // Return, beende INT Routine
NMI-Programm:
0BE9 F5 PUSH AF
0BEA DB 85 IN A, (0x85) // PI0-0-B-D Lese Input
0BEC CB 5F BIT 3, A // bit 3 == 0
0BEE 28 05 JR Z, 0x05 >-\ // ja, RETN
0BF0 3E 14 LD A, 0x14 | // nein Status 0x0d11 = 0x14
0BF2 32 11 0D LD (0x0D11), A | // Status 0x0d11 = 0x14
0BF5 F1 POP AF <-/
0BF6 ED 45 RETN // Return NMI Programm
0BF8 7F // Füllbytes
...
0BFF 7F // Füllbytes
// Start RAM CPU Karte
0C00
0C0B ... 0C2B Datenbereich
... RAM Stack
0FFF
// Ende RAM CPU Karte
// Einlesen Schlüssel, Erstelle Rundenschlüssel
1000 21 08 0C LD HL, 0x0C08 // Startadresse Schlüssel
1003 06 27 LD B, 0x27 // 39 Byte
1005 36 00 LD (HL), 0x00 <--\
1007 23 INC HL |
1008 10 FB DJNZ 0xfb >--/ // Lösche 0x0c08 bis 0x0c2f
100A CD 44 12 CALL 0x1244 <--\ // SLS Lesen; übergabe Register C; Rückgabe C Wert, Start- Ende- Kennung
100D CD 3C 12 CALL 0x123C <--\ | // Schlüsseleinlesen Maske 11011, Rückgabe C Wert, Start- Ende- Kennung
1010 3E 09 LD A, 0x09 | <-\ | // Kennung 0x09 No2: 100 10
1012 B9 CP C | | | // C == 0x09, Anfangskennung No1: 100 10, Kanal 123T45
1013 20 F8 JR NZ, 0xF8 >--/ | | // Sprung != 0x09
1015 CD 3C 12 CALL 0x123C | | // Schlüsseleinlesen Maske 11011, Rückgabe C Wert, Start- Ende- Kennung
1018 3E 12 LD A, 0x12 | | // Anfangskennung 01001
101A B9 CP C | | // C == 0x12 Anfangskennung No2: 010 01, Kanal 123T45
101B 20 F3 JR NZ, 0xF3 >--/ | // Sprung != 0x12
101D 16 00 LD D, 0x00 | // Schleifenzähler
101F 21 08 0C LD HL, 0x0C08 | // Startbereich Speicherung des Schlüssels
1022 CD 3C 12 CALL 0x123C<---\ | // Schlüsseleinlesen Maske 11011, Rückgabe C Wert, Start- Ende- Kennung
1025 79 LD A,C | | // Bit 1 und 2; Bsp: 0x18; 0x11
1026 CB 0F RRC A | | // Rechts Rotieren A0->A7----->A0 A0->carry
1028 CB 0F RRC A | | // Bit 6, 7 = 0
102A CB 0F RRC A | | // 0x03 -> 0x03; 001 1000 -> 0000 0011; 0x22
102C 2F CPL | | // 0xfc -> 1111 1100; Complement accumulator; 0xdd
102D E6 03 AND 0x03 | | // nur 2 Bits= 0000 0000 -> 0; 0x01
102F 47 LD B,A | | // Sichere A
1030 79 LD A,C | | // letzten gelesenen Wert; 0x18
1031 E6 03 AND 0x03 | | // Maskiere ; 0x01
1033 B8 CP B | | // Prüfung Bit 1+5 und 0+4
1034 20 D4 JR NZ, 0xD4 | >---+ // Bit 0,1 != 4,5 Neustart Schlüssel einlesen; Prüfung 1/2 = NOT 4/5
1036 CB 09 RRC C | | // C0 -> C7, carry == C.0 == bit 0 == 0, C = 0x0c; 0000 1100
1038 CB 1B RR E | | // Rechts Rorieren E.0->C[C.carry]->E.7->... E0, Fülle E mit Bit C.0 (Bsp.: 1)
103A CB 09 RRC C | | // C0 -> C7, carry == C.0 == bit 0, C = 0xc0 Carry == C.0 == bit 1
103C CB 1B RR E | | // Rechts Rorieren E.0->C[C.carry]->E.7->...E.0 E = 0xc0
103E 14 INC D | | // D++; Schleifenzähler 0 ... 7
103F 7A LD A,D | | // A = counter
1040 E6 03 AND 0x03 | | // 2 * 4 eingelesen = 8bit; Modular-3 funktion
1042 20 DE JR NZ, 0xDE >--+ | // hole nächsten Bits vom SL, wenn weniger als 8 bit gesammelt
1044 73 LD M,E | | // Speichere E in M 0x0c08 ...0x0c2f
1045 23 INC HL | | // Nächste Adresse
1046 7A LD A,D | | // Schleifenzähler
1047 FE 9C CP 0x9C | | // 156 * 2bit gesammelt?; 312 bit = 24 KG + 256bit + 32 CRC; 0x0c08 - 0x0c20 - 0x0c40
1049 20 D7 JR NZ, 0xD7 >-/ | // nein, hole nächstes Byte vom SL
104B 21 08 0C LD HL, 0x0C08 | // ja, in 0x0c08 steht KG - Schlüssel - CRC-false - CRCtrue
104E 11 FF FF LD DE, 0xFFFF | // Initialisierungsvektor 0xffff CRC-16
1051 06 23 LD B, 0x23 | // Länge 0x23, 35 bytes == 280 bits, 32 byte Schlüssel + 3 bytes Kenngruppe
1053 7E LD A, M <-\ | // CRC-Schleife
1054 CD ED 1A CALL 0x1AED | | // CRC2-16, Übergabe DE, A; Rückgabe DE
1057 23 INC HL | | // bis 0x0c2a
1058 10 F9 DJNZ 0xF9 >--/ | // 35 Runden
105A 2A 2B 0C LD HL, (0x0C2B) | // FALSCH-CRC vom SL; 0x0c2b 0x0c2c low - high
105D A7 AND A | // carry-Zero löschen
105E ED 52 SBC HL, DE | // DE = berechnete CRC; CRCTrue != CRCFalse->vom SL
1060 28 A8 JR Z, 0xA8 >--+ // Z = 1 fehler gestanzter CRC mit berechneten CRC gleich, neustart schlüssel einlesen
1062 2A 2D 0C LD HL, (0x0C2D) | // soweit richtig, RICHTIG-CRC vom SL; 0x0c2d 0x0c2e low - high
1065 A7 AND A | // carry-Zero löschen, zweiter crc muß richtig sein
1066 ED 52 SBC HL, DE | // DE = berechnete CRC == CRC vom SL
1068 C2 0A 10 JP NZ, 0x100A >--/ // Z = 0 gestanzter CRC mit berechneten CRC gleich, sonst neustart Schlüssel einlesen
106B 21 0B 0C LD HL, 0x0C0B // Schlüssel1 256 bit: RAM1
106E 11 90 28 LD DE, 0x2890 // Schlüssel2 256 bit: RAM2
1071 01 20 00 LD BC, 0x0020 // Länge = 0x20, 32 bytes = 256 bit
1074 ED B0 LDIR // Schlüssel2 RAM2
1076 21 90 28 LD HL, 0x2890 // Schlüssel2 RAM2
1079 11 B0 28 LD DE, 0x28B0 // Schlüssel3 RAM2
107C 01 20 00 LD BC, 0x0020 // Länge = 0x20, 32 bytes = 256 bit
107F ED B0 LDIR // Schlüssel3 RAM2
1081 21 B0 28 LD HL, 0x28B0 // Schlüssel3 RAM2
1084 11 00 28 LD DE, 0x2800 // Rundenschlüssel
1087 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
108A 21 93 28 LD HL, 0x2893 // Versatz 3 Bytes, länge 4 bytes
108D 11 04 28 LD DE, 0x2804
1090 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1093 21 96 28 LD HL, 0x2896
1096 11 08 28 LD DE, 0x2808
1099 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
109C 21 99 28 LD HL, 0x2899
109F 11 0C 28 LD DE, 0x280C
10A2 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10A5 21 9C 28 LD HL, 0x289C
10A8 11 10 28 LD DE,0x2810
10AB CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10AE 21 9F 28 LD HL,0x289F
10B1 11 14 28 LD DE,0x2814
10B4 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10B7 21 A2 28 LD HL,0x28A2
10BA 11 18 28 LD DE,0x2818
10BD CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10C0 21 A5 28 LD HL,0x28A5
10C3 11 1C 28 LD DE,0x281C
10C6 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE; No. 8
10C9 CD 04 12 CALL 0x1204 // Blockrotieren Schlüssel3 RAM2:0x28b0 ... 0x28c7, RAM2 4*6 = 24 Bytes
10CC 21 B0 28 LD HL,0x28B0 // Schlüssel3 RAM2
10CF 11 20 28 LD DE,0x2820
10D2 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10D5 21 B3 28 LD HL,0x28B3
10D8 11 24 28 LD DE,0x2824
10DB CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10DE 21 B6 28 LD HL, 0x28B6
10E1 11 28 28 LD DE,0x2828
10E4 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10E7 21 B9 28 LD HL,0x28B9
10EA 11 2C 28 LD DE,0x282C
10ED CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10F0 21 BC 28 LD HL, 0x28BC
10F3 11 30 28 LD DE,0x2830
10F6 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
10F9 21 BF 28 LD HL,0x28BF
10FC 11 34 28 LD DE,0x2834
10FF CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1102 21 C2 28 LD HL, 0x28C2
1105 11 38 28 LD DE,0x2838
1108 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
110B 21 C5 28 LD HL,0x28C5
110E 11 3C 28 LD DE,0x283C
1111 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE; No. 8
1114 CD 04 12 CALL 0x1204 // Blockrotieren Schlüssel3 RAM2:0x28b0 ... 0x28c7, RAM2 4*6 = 24 Bytes
1117 21 B0 28 LD HL,0x28B0 // Schlüssel3 RAM2
111A 11 40 28 LD DE,0x2840
111D CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1120 21 B3 28 LD HL,0x28B3
1123 11 44 28 LD DE,0x2844
1126 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1129 21 B6 28 LD HL, 0x28B6
112C 11 48 28 LD DE,0x2848
112F CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1132 21 B9 28 LD HL,0x28B9
1135 11 4C 28 LD DE,0x284C
1138 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
113B 21 BC 28 LD HL, 0x28BC
113E 11 50 28 LD DE,0x2850
1141 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1144 21 BF 28 LD HL,0x28BF
1147 11 54 28 LD DE,0x2854
114A CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
114D 21 C2 28 LD HL, 0x28C2
1150 11 58 28 LD DE,0x2858
1153 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1156 21 C5 28 LD HL,0x28C5
1159 11 5C 28 LD DE,0x285C
115C CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE; No. 8
115F CD 04 12 CALL 0x1204 // Blockrotieren Schlüssel3 RAM2:0x28b0 ... 0x28c7, RAM2 4*6 = 24 Bytes
1162 21 B0 28 LD HL,0x28B0 // Schlüssel3 RAM2
1165 11 78 28 LD DE,0x2878
1168 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
116B 21 B3 28 LD HL,0x28B3
116E 11 7C 28 LD DE,0x287C
1171 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1174 21 B6 28 LD HL, 0x28B6
1177 11 70 28 LD DE,0x2870
117A CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
117D 21 B9 28 LD HL,0x28B9
1180 11 74 28 LD DE,0x2874
1183 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1186 21 BC 28 LD HL, 0x28BC
1189 11 68 28 LD DE,0x2868
118C CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
118F 21 BF 28 LD HL,0x28BF
1192 11 6C 28 LD DE,0x286C
1195 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
1198 21 C2 28 LD HL, 0x28C2
119B 11 60 28 LD DE,0x2860
119E CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
11A1 21 C5 28 LD HL,0x28C5
11A4 11 64 28 LD DE,0x2864
11A7 CD D4 11 CALL 0x11D4 // Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE; No. 8
11AA 21 A8 28 LD HL,0x28A8
11AD 11 80 28 LD DE,0x2880 // 64bit
11B0 01 04 00 LD BC,0x0004 // 0x08, könnte folgende 4 Zeilen sparen
11B3 ED B0 LDIR // bearbeiteter Schlüssel
11B5 21 AC 28 LD HL,0x28AC
11B8 11 84 28 LD DE,0x2884
11BB 01 04 00 LD BC,0x0004
11BE ED B0 LDIR // optimierungsbedarf!
11C0 21 00 28 LD HL,0x2800 // Rundenschlüssel
11C3 06 88 LD B, 0x88 // 136 bytes
11C5 11 FF FF LD DE, 0xFFFF // CRC Vektor 0xffff
11C8 7E L0209: LD A, M <--\ // CRC Schleife
11C9 CD ED 1A CALL 0x1AED | // CRC2-16, Übergabe DE, A; Rückgabe DE
11CC 23 INC HL |
11CD 10 F9 DJNZ 0xf9 >--/ // 136 Runden
11CF ED 53 88 28 LD (0x2888), DE // Lege CRC des bearbeiteten Schlüssels am Ende ab
11D3 C9 RET // CRC über Runden-Schlüssel
// Schlüsselauszug 4Byte Übergabe HL, DE, Rückgabe DE
11D4 7E LD A, M // Übergabevariablen HL und DE
11D5 23 INC HL // A = M, HL+1
11D6 06 00 LD B, 0x00 // B = 0
11D8 CB 3F SRL A // Schiebe null -> 7 -> 0 -> carry
11DA CB 18 RR B // Rotiere rechts A:carry->B.7
11DC CB 3F SRL A // schiebe null -> 7 -> 0 -> carry
11DE CB 18 RR B // Rotiere rechts A:carry - >B.7 und B.6 aus A.0 und A.1
11E0 12 LD (DE), A // (DE) = 00xx xxxxxx von A
11E1 13 INC DE // DE++
11E2 4E LD C, M // hole aus M; wird später wiederhergestellt wg. RLD
11E3 ED 6F RLD // A.high unverändert, M.low = A.low; A.low = M.high, M.high = M.low;
11E5 E6 0F AND 0x0F // Maskiere, entspricht M.high, Lösche carry
11E7 CB 38 SRL B // Schiebe null -> 7 -> 0 -> carry
11E9 CB 38 SRL B // Schiebe null -> 7 -> 0 -> carry
11EB B0 OR B // A OR B; M.high OR 00xx 0000
11EC 12 LD (DE), A // in (DE) sichern
11ED 13 INC DE // DE++
11EE ED 6F RLD // A.high unverändert, M.low = A.low; A.low = M.high, M.high = M.low;
11F0 E6 0F AND 0x0F // Maskiere, entspricht M.high
11F2 71 LD M, C // schreibe M zurück, wiederherstellen wg. RLD
11F3 23 INC HL // HL++
11F4 46 LD B, M //
11F5 CB 20 SLA B // Schiebe null -> 0 -> 7 -> carry
11F7 17 RLA // Rotiere carry -> A.0 -> A.7 -> carry; B.7 nach A.0
11F8 CB 20 SLA B // Schiebe null -> 0 -> 7 -> carry
11FA 17 RLA // Rotiere carry -> A.0 -> A.7 -> carry; B.7 nach A.0
11FB 12 LD (DE), A // (DE) = A; A.0 A.1 aus B.7 B.6
11FC 13 INC DE // DE++
11FD CB 38 SRL B // Schiebe null -> 7 -> 0 -> carry
11FF CB 38 SRL B // Schiebe null -> 7 -> 0 -> carry
1201 78 LD A, B // A.3 ... A.0 = B.7 ... B.4; A.high = 0000
1202 12 LD (DE), A // (DE) = B
1203 C9 RET // DE Rückgabe
// Blockrotieren Schlüssel3 RAM2:0x28b0 ... 0x28c7, RAM2 4*6 = 24 Bytes
1204 11 B0 28 LD DE,0x28B0 // Schlüssel3 RAM2; Datenbereich 0x28b0 ... 0x28b5
1207 CD 1D 12 CALL 0x121D // 5 bytes rotieren 10*; Übergabe DE, Rückgabe im RAM (DE)+10
120A 11 B6 28 LD DE, 0x28B6 // Datenbereich 0x28b6 ... 0x28bb
120D CD 1D 12 CALL 0x121D // 5 bytes rotieren 10*; Übergabe DE, Rückgabe im RAM (DE)+10
1210 11 BC 28 LD DE, 0x28BC // Datenbereich 0x28bc ... 0x28c1
1213 CD 1D 12 CALL 0x121D // 5 bytes rotieren 10*; Übergabe DE, Rückgabe im RAM (DE)+10
1216 11 C2 28 LD DE, 0x28C2 // Datenbereich 0x28c2 ... 0x28c7
1219 CD 1D 12 CALL 0x121D // 5 bytes rotieren 10*; Übergabe DE, Rückgabe im RAM (DE)+10
121C C9 RET // Schleife über 24 bytes
// 5 bytes rotieren 10*; Übergabe DE, Rückgabe im RAM (DE)+10
121D 3E 0B LD A, 0x0B // Schleifenzähler = 11
121F 62 LD H,D // Übergabe der Startadresse
1220 6B LD L,E // HL = DE
1221 CB 3E SRL M <----\ // Schiebe null -> 7 -> 0 -> carry
1223 23 INC HL | // HL + 1
1224 CB 1E RR M | // Rotiere rechts carry - > 7 -> 0 -> carry
1226 23 INC HL | // HL + 2
1227 CB 1E RR M | // Rotiere rechts carry - > 7 -> 0 -> carry
1229 23 INC HL | // HL + 3
122A CB 1E RR M | // Rotiere rechts carry - > 7 -> 0 -> carry
122C 23 INC HL | // HL + 4
122D CB 1E RR M | // Rotiere rechts carry - > 7 -> 0 -> carry
122F 23 INC HL | // HL + 5
1230 CB 1E RR M | // Rotiere rechts carry - > 7 -> 0 -> carry
1232 62 LD H,D | // Übergabe der Startadresse
1233 6B LD L,E | // HL wieder auf Start = DE
1234 30 02 JR NC, 0x02>--\ | // carry der letzten RR M
1236 CB FE SET 7,M | | // Übertrag; HL+5 Bit 0-> C -> HL bit 7
1238 3D DEC A <--/ | // Schleifenzähler
1239 20 E6 JR NZ, 0xE6 >--/ // 10 Runden
123B C9 RET //
// Schlüsseleinlesen Maske 11011, Rückgabe C Wert, Start- Ende- Kennung
123C 0E 00 LD C, 0x00 // C = 0
123E DB 84 L0213: IN A,(0x84) <--\ // PIO-0-A-D Schlüssellochstreifenleser Bit 0, 1 ... 3, 4
1240 E6 1B AND 0x1B | // Eingabe maskieren 11011, Prüfe auf Gültigkeit; keine 0x00; eines der bits 0,1,3,4 muß 1 sein
1242 28 FA JR Z,L0213 >--/ // A != 0x1b, A soll 0x03, 0x0a, 0x11, 0x18, 0x1b sein.
// SLS Lesen; Anfangskennung gefunden - bei Einsprung 0x123C// A != 0; Schlüssellochstreifenleser Bit 0, 1 ... 3, 4
1244 06 08 LD B, 0x08 <------\ // 8 Loch Takte = ein gelesenes 1/4Byte
1246 DB 84 IN A, (0x84) <--\ | // PIO-0-A-D, Schlüssellochstreifenleser Bit 0, 1 ... 3, 4
1248 E6 1B AND 0x1B | | // maskieren 11011, Prüfe auf Gültigkeit; bit 2 ungenutzt
124A 28 04 JR Z, 0x04 >-\ | | // Schleife Anfangskennung; Flankenwechsel
124C B1 OR C | | | // ungleich 0x1b; A Or C, für Flagabfrage; Achtung bei Einsprung aus der Funktion 0x123C ist C = 0; bei direkten Einsprung ist C = ??
// Register C ist das Sammelregister der eingelesenen Bytes
124D 4F LD C, A | | | // A = C, in C die letzte Eingabe
124E 18 F6 JR 0xF6 | >--/ | // Lese Eingabe
// weiter | | // wenn A != 0x03, 0x0a, 0x11, 0x18, 0x1b; Ende des Schlüssels
1250 DB 84 IN A, (0x84)<---+ | // PIO-0-A-D, Schlüssellochstreifenleser Bit 0 ... 4
1252 E6 1B AND 0x1B | | // Eingabe maskieren Bits 4, 3, 1, 0, Prüfe auf Gültigkeit bit 0 or 1 or 3 or 4 == 1
1254 20 EE JR NZ, 0xEE | >----/ // Keine Ende-Kennnung
1256 10 F8 DJNZ 0xF8 >--/ // Lese Eingabe 8 mal
1258 C9 RET // Rückgabewert in C
// Prüfe CRC 16 im Speicherbereich 0x2800 bis 0x2888; Rückgabe Z-Flag; Rundenschlüssel
1259 21 00 28 LD HL, 0x2800 // Speicher Rundenschlüssel
125C 11 FF FF LD DE, 0xFFFF // CRC Vektor 0xffff
125F 06 88 LD B, 0x88 // 136 Bytes
1261 7E L0217: LD A,M <-\ // CRC Schleife
1262 CD ED 1A CALL 0x1AED | // CRC2-16, Übergabe DE, A; Rückgabe DE
1265 23 INC HL | // bis 0x2887
1266 10 F9 DJNZ 0xf9 >-/ // 136 Runden
1268 7E LD A,M // A = (0x2888)
1269 BB CP E // A == Rückgabe der CRC 16
126A C0 RET NZ // nein Return
126B 23 INC HL // ja, 0x2889
126C 7E LD A,M // A = (0x2889)
126D BA CP D // A == Rückgabe der CRC 16
126E C9 RET // Return, Flags beachten im Rücksprung
// Prüf-Funktion Rundenschlüssel; Rückgabe Z-Flag
126F 21 CF 12 LD HL, 0x12CF // Prüfschlüssel-Rundenschlüssel 0x12cf in den RAM 0x2800
1272 11 00 28 LD DE, 0x2800 // Ziel RAM: Schlüsselbereich
1275 01 88 00 LD BC, 0x0088 // 136 Bytes
1278 ED B0 LDIR // Kopiere nach RAM
127A 21 57 13 LD HL, 0x1357 // Test-Variablen 8 bytes, 0x87
127D 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
1280 01 08 00 LD BC, 0x0008 // Schleifenzähler = 8 Bytes
1283 ED B0 LDIR // Blockkopie von 0x1357 = 0x87 in den RAM 0x2a00
1285 06 01 LD B, 0x01 // Schleifenzähler, 1 Runde! In der Beschreibung BArch 549 Seite 22 ist von 75mal die Rede!
1287 C5 PUSH BC <---\ // rette Schleifenzähler
1288 CD 00 18 CALL 0x1800 | // LAMBDA über 0x2a00, Klartext 64bit; Quell- und Zieladresse 0x2A00, Rundenschlüssel 0x2800
128B C1 POP BC |
128C 10 F9 DJNZ 0xf9 >---/ // Rufe die Routine 1mal auf
128E 21 0B 0C LD HL,0x0C0B // RAM1, Schlüssel + CRC
1291 11 00 28 LD DE,0x2800 // Ziel Rundenschlüssel
1294 01 88 00 LD BC, 0x0088 // Schleifenzähler = 0x88 Bytes
1297 ED B0 LDIR // Kopiere Schlüssel nach RAM2; Wiederherstellen
1299 06 08 LD B, 0x08 // Schleifenzähler = 8, Vergleichen
129B 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
129E 11 5F 13 LD DE, 0x135F // Prüfwerte BitPermutation, Vergleich mit RAM2:0x2a00
12A1 1A LD A,(DE) <--\
12A2 BE CP M | // Vergleiche RAM2 mit EPROM
12A3 C0 RET NZ | // A != 0 wenn das ergebnis NIO
12A4 23 INC HL |
12A5 13 INC DE |
12A6 10 F9 DJNZ 0xF9 >---/
12A8 AF XOR A // Lösche AF, A = 0 wenn das Ergbnis OK
12A9 C9 RET
// Blockkopie Rundenschlüssel 0x2800; LAMBDA Ein-Ausgabe Initialwerte 0x87 ... Initale Bildung Wurmreihen
12AA 21 00 28 LD HL, 0x2800 // Rundenschlüssel
12AD 11 0B 0C LD DE, 0x0C0B // Schlüssel1 0x0c0b - 0x0c93
12B0 01 88 00 LD BC, 0x0088 // 0x88 Bytes, 136 bytes
12B3 ED B0 LDIR // Überschreibe Schlüssel1 mit rotierten Schlüssel3 RAM2
12B5 21 57 13 LD HL, 0x1357 // Initialwert EPROM 0x87
12B8 11 00 2A LD DE, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
12BB 01 08 00 LD BC, 0x0008 // Schleifenzähler 8 Bytes
12BE ED B0 LDIR // 8 * 0x87, Initialwerte
12C0 CD 00 18 CALL 0x1800 // LAMBDA Ein-Ausgabe 0x2a00, 64bit; Rundenschlüssel 0x2800
12C3 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
12C6 11 95 0C LD DE, 0x0C95 // Wurmreihe abgelegt, für CFB?; Für Testfunktion Online mit Aktualschlüssel
12C9 01 08 00 LD BC, 0x0008 // Schleifenzähler 8 Bytes
12CC ED B0 LDIR // Blockkopie 8 bytes von 0x2a00 nach 0x0c95 - 0x09c; Wurmreihen
12CE C9 RET // -> 0x01c6
// Datenbereich 0x87 bytes, 136bytes : ENDE = 0x1356 // Rundenschlüssel Test-Schlüssel
12CF 00
12D0 12 0D 05 19 38 26 2B 33 1E 3F 3E 37 0B 2A 18 1D
12E0 25 10 32 04 00 04 23 11 16 1E 09 2A 3C 37 2F 0D
12F0 16 00 24 1A 0A 33 31 14 31 26 3D 3F 3D 2E 17 09
1300 06 3B 0A 21 24 08 00 2F 1E 22 2C 3C 13 15 39 27
1310 22 1A 2C 01 08 34 15 1C 2E 29 23 0D 3B 3F 3B 10
1320 00 12 0D 36 15 03 08 2B 33 1E 3D 05 19 38 26 31
1330 0D 17 26 3D 3A 0A 33 06 10 20 00 24 1B 2C 2A 3F
1340 36 39 1D 13 06 1B 37 28 2B 0F 04 35 18 02 11 FE
1350 DC BA 98 76 54 32 10
// Startvariablen 8 bytes // Kopiert in RAM: 0x2a00 bis 0x2a07
1357 87 87 87 87 87 87 87 87
// Prüfwerte Chiffrat Feisel, Vergleich mit RAM2:0x2a00
135f 87
1360 D4
1361 18
1362 F0
1363 FC
1364 28
1365 30
1366 7A
// Konstantenberich IX: ROM CRC-16 Start/Länge/Prüfsummen
1367 00 00 // IX+0 + 1 Startbereich 0x0000, 1. EPROM -CPU Karte-
1369 00 04 // + 2, + 3 Länge 0x0400
136B 50 B6 // + 4, + 5 Prüfsumme 0xb650
136D 00 04 // IX+0 + 1 Startbereich 0x0400, 2. EPROM -CPU Karte-
136F 00 04 // + 2 + 3 Länge 0x0400
1371 58 3A // + 4 + 5 Prüfsumme 0x3a58
1373 00 08 // IX+0 + 1 Startbereich 0x0800, 3. EPROM -CPU Karte-
1375 00 04 // + 2 + 3 Länge 0x0400
1377 46 F4 // + 4 + 5 Prüfsumme 0xf446
1379 00 14 // IX+0 + 1 Startbereich 0x1400, 5. EPROM -ROM/RAM Karte-
137B 00 04 // + 2 + 3 Länge 0x0400
137D 90 69 // + 4 + 5 Prüfsumme 0x6990
137F 00 18 // IX+0 + 1 Startbereich 0x1800, 6. EPROM -ROM/RAM Karte-
1381 00 04 // + 2 + 3 Länge 0x0400
1383 9B C2 // + 4 + 5 Prüfsumme 0xc29b; Nach Programmänderung neu berechnet 0x1f31 !!
1385 00 10 // IX+0 + 1 Startbereich 0x1000, 4. EPROM -ROM/RAM Karte-
1387 89 03 // + 2 + 3 Länge 0x0389, Teilsegment 0x1000 ... 0x1389
1389 50 D3 // + 4 + 5 Prüfsumme 0xd350; Nach Programmänderung neu berechnet 0xA2E2 !!
// ungeprüfter ROM
138B 91 13 // IX+0 + 1 Startbereich 0x1391, Teilsegment -ROM/RAM Karte-
138D 6F 00 // + 2 + 3 Länge 0x006f, Teilsegment 0x1391 ... 0x1400
138F 37 41 // + 4 + 5 Prüfsumme 0x4137;
// ab hier wieder geprüfter ROM
1391 26 00 // IX+0 + 1 Startbereich 0x0026, Teilsegment mit der Prüfsumme 0x0000! ?? 0x26 Kennzeichen für Abbruch -> 0x00f7
1393 00 04 // + 2 + 3 Länge 0x0400, Segmentbereich 0x0026 ... 0x0426 Absicht die Prüfsumme muß hier falsch sein!
1395 00 00 // + 4 + 5 Prüfsumme 0x0000
1397 00 00 //
1399 00 00 //
139B 7F //
... // Füllbytes
13FF 7F //
// Datenbereich 0x1400 ... 0x15ff = 0x200 Bytes == 512 bytes Auffällig H-bytes und L-Bytes
// K-Box Subsitution der Bits
// S0
1400 E0 00 40 F0 D0 70 10 40 20 E0 F0 20 B0 D0 80 10 // 64 H-bytes
1410 30 A0 A0 60 60 C0 C0 B0 50 90 90 50 00 30 70 80
1420 40 F0 10 C0 E0 80 80 20 D0 40 60 90 20 10 B0 70
1430 F0 50 C0 B0 90 30 70 E0 30 A0 A0 00 50 60 00 D0
1440 0F 03 01 0D 08 04 0E 07 06 0F 0B 02 03 08 04 0E // 64 L-Bytes
1450 09 0C 07 00 02 01 0D 0A 0C 06 00 09 05 0B 0A 05
1460 00 0D 0E 08 07 0A 0B 01 0A 03 04 0F 0D 04 01 02
1470 05 0B 08 06 0C 07 06 0C 09 00 03 05 02 0E 0F 09
// S1
1480 A0 D0 00 70 90 00 E0 90 60 30 30 40 F0 60 50 A0 // 64 H-bytes
1490 10 20 D0 80 C0 50 70 E0 B0 C0 40 B0 20 F0 80 10
14A0 D0 10 60 A0 40 D0 90 00 80 60 F0 90 30 80 00 70
14B0 B0 40 10 F0 20 E0 C0 30 50 B0 A0 50 E0 20 70 C0
14C0 07 0D 0D 08 0E 0B 03 05 00 06 06 0F 09 00 0A 03 // 64 L-Bytes
14D0 01 04 02 07 08 02 05 0C 0B 01 0C 0A 04 0E 0F 09
14E0 0A 03 06 0F 09 00 00 06 0C 0A 0B 01 07 0D 0D 08
14F0 0F 09 01 04 03 05 0E 0B 05 0C 02 07 08 02 04 0E
// S2
1500 20 E0 C0 B0 40 20 10 C0 70 40 A0 70 B0 D0 60 10 // 64 H-bytes
1510 80 50 50 00 30 F0 F0 A0 D0 30 00 90 E0 80 90 60
1520 40 B0 20 80 10 C0 B0 70 A0 10 D0 E0 70 20 80 D0
1530 F0 60 90 F0 C0 00 50 90 60 A0 30 40 00 50 E0 30
1540 0C 0A 01 0F 0A 04 0F 02 09 07 02 0C 06 09 08 05 // 64 L-Bytes
1550 00 06 0D 01 03 0D 04 0E 0E 00 07 0B 05 03 0B 08
1560 09 04 0E 03 0F 02 05 0C 02 09 08 05 0C 0F 03 0A
1570 07 0B 00 0E 04 01 0A 07 01 06 0D 00 0B 08 06 0D
// S3
1580 40 D0 B0 00 20 B0 E0 70 F0 40 00 90 80 10 D0 A0 // 64 H-bytes
1590 30 E0 C0 30 90 50 70 C0 50 20 A0 F0 60 80 10 60
15A0 10 60 40 B0 B0 D0 D0 80 C0 10 30 40 70 A0 E0 70
15B0 A0 90 F0 50 60 00 80 F0 00 E0 50 20 90 30 20 C0
15C0 0D 01 02 0F 08 0D 04 08 06 0A 0F 03 0B 07 01 04 // 64 L-Bytes
15D0 0A 0C 09 05 03 06 0E 0B 05 00 00 0E 0C 09 07 02
15E0 07 02 0B 01 04 0E 01 07 09 04 0C 0A 0E 08 02 0D
15F0 00 0F 06 0C 0A 09 0D 00 0F 03 03 05 05 06 08 0B
1600 7F
...
17FF 7F // Füllbytes
// LAMBDA Ein-Ausgabe 0x2A00, Klartext 64bit; Rundenschlüssel 0x2800
// 0x2A00 Ein-Ausgabe LAMBDA, 0x2800 Rundenschlüssel
1800 3E 45 LD A, 0x45 // A = 0x45; Systeminformation
1802 32 00 0C LD (0x0C00), A // (0x0c00) = 0x45
1805 21 00 2A LD HL, 0x2A00 // Ein- Ausgabe LAMBDA, Wurmreihen
1808 46 LD B, M // B = (0x2a00) = 0x87 oder Wurmeihen
1809 2C INC L
180A 4E LD C, M // BC = 0x8787 oder Wurmeihen
180B 2C INC L // = 0x2a02
180C C5 PUSH BC
180D DD E1 POP IX // IX = BC = 0x8787 oder Wurmeihen
180F 56 LD D, M // D = (0x2a02) = 0x87 oder Wurmeihen
1810 2C INC L // = 0x2a03
1811 5E LD E, M // DE = 0x8787
1812 D5 PUSH DE // SP = 0x0fff
1813 FD E1 POP IY // IY = DE = 0x8787 oder Wurmeihen
1815 2C INC L // = 0x2a04
1816 46 LD B, M // B = (0x2a04) = 0x87 oder Wurmeihen
1817 2C INC L // = 0x2a05
1818 4E LD C, M // BC = 0x8787
1819 2C INC L // = 0x2a06
181A 56 LD D, M // D = (0x2a06) = 0x87 oder Wurmeihen
181B 2C INC L // = 0x2a07
181C 5E LD E, M // DE = 0x8787 oder Wurmeihen
181D 3E 10 LD A, 0x10 // A = 0x10; Schleifenzähler 16 bytes
181F 21 00 28 LD HL, 0x2800 // HL = 0x2800; Rundenschlüssel
// Weiter LAMBDA
1822 F5 PUSH AF <------\
1823 C5 PUSH BC |
1824 D5 PUSH DE |
1825 E5 PUSH HL |
1826 AF XOR A | // A = 0, lösche Flags
1827 CB 5B BIT 3, E | // Prüfe Bit 3 von E
1829 28 02 JR Z, 0x02 >-\ |
182B F6 01 OR 0x01 | | // Setze A Bit 0
182D CB 5A BIT 3, D <---/ | // Prüfe Bit 3 von D
182F 28 02 JR Z, 0x02 >-\ |
1831 F6 02 OR 0x02 | | // Setze A Bit 1
1833 CB 62 BIT 4, D <---/ | // Prüfe Bit 4 von D
1835 28 02 JR Z, 0x02 >-\ |
1837 F6 04 OR 0x04 | | // Setze A Bit 2
1839 CB 48 BIT 1,B <--/ | // Prüfe Bit 1 von B
183B 28 02 JR Z, 0x02 >-\ |
183D F6 08 OR 0x08 | | // Setze A Bit 3
183F CB 41 BIT 0, C >--/ | // Prüfe Bit 0 von C
1841 28 02 JR Z, 0x02 >-\ |
1843 F6 10 OR 0x10 | | // Setze A Bit 4
1845 CB 7B BIT 7, E <--/ | // Prüfe Bit 7 von E
1847 28 02 JR Z, 0x02 >-\ |
1849 F6 20 OR 0x20 | | // Setze A Bit 5
184B AE XOR M <--/ | // A XOR P-Box((H) = 0x2a00); A kann max bit 0...5 gesetzt sein 0x3f
184C 26 14 LD H, 0x14 | // HL = 0x1400 ...
184E 6F LD L, A | // HL = 0x14 (A XOR M); Tabellenauswahl hole H-Bytes (0x1400 ... 0x143f) LZS
184F 7E LD A,M | // Permutation der Bits, A = (M = (0x14xx); Permutation der Bits
1850 E1 POP HL | // HL = 0x2800, Speicherplatz von vormals PUSH HL, Zeile 0x1825,; Rundenschlüssel
1851 F5 PUSH AF | // Rette AF, (0x14xx)
1852 2C INC L | // HL = 0x2801
1853 E5 PUSH HL | // Rette HL
1854 3E 40 LD A, 0x40 | // Lade A = 0x40
1856 CB 78 BIT 7, B | // Prüfe Bit 7 von B
1858 28 02 JR Z, 0x02 >-\ |
185A F6 01 OR 0x01 | | // setze Bit 0 von A, = 0x41
185C CB 7A BIT 7, D <--/ | // Prüfe Bit 7 von D
185E 28 02 JR Z, 0x02 >-\ |
1860 F6 02 OR 0x02 | | // Setze Bit 1 von A, = 0x4x
1862 CB 63 BIT 4, E <-/ | // Prüfe Bit 4 von E
1864 28 02 JR Z, 02 >-\ |
1866 F6 04 OR 0x04 | | // Setze Bit 2 von A, = 0x4x
1868 CB 61 BIT 4, C <--/ | // Prüfe Bit 4 von C
186A 28 02 JR Z, 0x02 >-\ |
186C F6 08 OR 0x08 | | // Setze Bit 3 von A, = 0x4x
186E CB 5B BIT 3,E <--/ | // Prüfe Bit 3 von E
1870 28 02 JR Z, 0x02 >-\ |
1872 F6 10 OR 0x10 | | // Setze Bit 4 von A, = 0x4x
1874 CB 5A BIT 3, D <--/ | // Prüfe Bit 3 von D
1876 28 02 JR Z, 0x02 >-\ |
1878 F6 20 OR 0x20 | | // Setze Bit 5 von A, = 0x4x
187A AE XOR M <--/ | // A max. 0x7f
187B 26 14 LD H, 0x14 | // Hole aus Tabelle l-Bytes (0x1440 ... 0x147f)
187D 6F LD L, A | // Adresse HL = 0x14 (A XOR (0x2a00))
187E 7E LD A, M | // Permutation der Bits, A = 0x147f
187F E1 POP HL | // HL 0x2801
1880 F5 PUSH AF | // Rette AF
1881 2C INC L | // HL = 0x2802
1882 E5 PUSH HL | // Rette HL
1883 3E 80 LD A, 0x80 | // A = 0x80
1885 CB 58 BIT 3, B | // Prüfe Bit 3 von B
1887 28 02 JR Z, 0x02 >-\ |
1889 F6 01 OR 0x01 | | // Setze Bit 0 von A, = 0b1000 000y (0x81)
188B CB 73 BIT 6, E <--\ | // Prüfe Bit 6 von E
188D 28 02 JR Z, 0x02 >-\ |
188F F6 02 OR 0x02 | | // Setze Bit 1 von A, = 0b1000 00yx
1891 CB 4A BIT 1, D <--/ | // Prüfe Bit 1 von D
1893 28 02 JR Z, 0x02 >-\ |
1895 F6 04 OR 0x04 | | // Setze Bit 2 von A, 0b1000 0yxx
1897 CB 49 BIT 1, C <--/ | // Prüfe Bit 1 von C
1899 28 02 JR Z, 0x02 >-\ |
189B F6 08 OR 0x08 | | // Setze Bit 3 von A, 0b1000 yxxx
189D CB 78 BIT 7,B <-/ | // Prüfe Bit 7 von B
189F 28 02 JR Z, 0x02 >-\ |
18A1 F6 10 OR 0x10 | | // Setze Bit 4 von A, 0b100y xxxx
18A3 CB 7A BIT 7, D <--/ | // Prüfe Bit 7 von D
18A5 28 02 JR Z, 0x02 >-\ |
18A7 F6 20 OR 0x20 | | // setze Bit 5 von A, 0b10yx xxxx
18A9 AE XOR M <--/ | // A XOR (0x2802)
18AA 26 14 LD H, 0x14 | // Feste Permutationstabelle
18AC 6F LD L, A | // Hole aus Tablle H-bytes (0x1480 ... 0x14bf)
18AD 7E LD A,M | // Permutation der Bits, A = (0x14yy)
18AE E1 POP HL | // HL = 0x2802
18AF F5 PUSH AF | // Rette AF
18B0 2C INC L |
18B1 E5 PUSH HL | // HL = 0x2803
18B2 3E C0 LD A, 0xC0 |
18B4 CB 70 BIT 6, B | // Prüfe Bit 6 von B
18B6 28 02 JR Z, 0x02 >-\ |
18B8 F6 01 OR 0x01 | | // Setze Bit 0 von A, A = 0x0c + 1
18BA CB 71 BIT 6, C <--/ | // Prüfe Bit 6 von C
18BC 28 02 JR Z, 0x02 >-\ |
18BE F6 02 OR 0x02 | | // Setze Bit 1 von A, A + 2
18C0 CB 4B BIT 1,E <--/ | // Prüfe Bit 1 von E
18C2 28 02 JR Z, 0x02 >-\ |
18C4 F6 04 OR 0x04 | | // Setze Bit 2 von A, A + 4
18C6 CB 72 BIT 6, D <--/ | // Prüfe Bit 6 von D
18C8 28 02 JR Z, 0x02 >-\ |
18CA F6 08 OR 0x08 | | // Setze Bit 3 von A, A + 8
18CC CB 58 BIT 3, B <-/ | // Prüfe Bit 3 von B
18CE 28 02 JR Z, 0x02 >-\ |
18D0 F6 10 OR 0x10 | | // Setze Bit 4 von A, A + 0x10
18D2 CB 73 BIT 6, E <--/ | // Prüfe Bit 6 von E
18D4 28 02 JR Z, 0x02 >-\ |
18D6 F6 20 OR 0x20 | | // setze Bit 5 von A, A + 0x20
18D8 AE XOR M <--/ | // A XOR (0x2803)
18D9 26 14 LD H, 0x14 |
18DB 6F LD L,A | // Hole aus Tabelle L-bytes (0x14c0 ... 0x14ff)
18DC 7E LD A,M | // Permutation der Bits, A = (0x14yy )
18DD E1 POP HL | // HL = 0x2803
18DE F5 PUSH AF | // Rette AF
18DF 2C INC L |
18E0 E5 PUSH HL | // Rette HL = 0x2804
18E1 AF XOR A | // Lösche AF
18E2 CB 43 BIT 0, E | // Prüfe Bit 0 von E
18E4 28 02 JR Z, 0x02 >-\ |
18E6 F6 01 OR 0x01 | | // Setze Bit 0 von A, A = 1
18E8 CB 51 BIT 2, C <--/ | // Prüfe Bit 2 von C
18EA 28 02 JR Z, 0x02 >-\ |
18EC F6 02 OR 0x02 | | // setze Bit 1 von A, A + 2
18EE CB 42 BIT 0, D <--/ | // Prüfe Bit 0 von D
18F0 28 02 JR Z, 0x02 >-\ |
18F2 F6 04 OR 0x04 | | // Setze Bit 2 von A, A + 4
18F4 CB 40 BIT 0, B <--/ | // Prüfe Bit 0 von B
18F6 28 02 JR Z, 0x02 >-\ |
18F8 F6 08 OR 0x08 | | // setze Bit 3 von A, A + 8
18FA CB 70 BIT 6, B <--/ | // Prüfe Bit 6 von B
18FC 28 02 JR Z, 0x02 >-\ |
18FE F6 10 OR 0x10 | | // Setze Bit 4 von A, A + 0x10
1900 CB 71 BIT 6, C <--/ | // Prüfe Bit 6 von C
1902 28 02 JR Z, 0x02 >-\ |
1904 F6 20 OR 0x20 | | // setze Bit 5 von A, A = 0x20
1906 AE XOR M <--/ | // A XOR (0x2804)
1907 26 15 LD H, 0x15 | // Feste Permutationstabelle
1909 6F LD L,A | // Hole aus Tabelle byte (0x11500 ... 0x153f)
190A 7E LD A,M | // Permutation der Bits, A = (0x15yy)
190B E1 POP HL | // Hole HL = 0x2804
190C F5 PUSH AF | // Rette AF
190D 2C INC L |
190E E5 PUSH HL | // Rette HL = 0x2805
190F 3E 40 LD A, 0x40 | // A = 0x40
1911 CB 6A BIT 5, D | // Prüfe Bit 5 von D
1913 28 02 JR Z, 0x02 >-\ |
1915 F6 01 OR 0x01 | | // Setze A Bit 0
1917 CB 79 BIT 7, C <--/ | // Prüfe Bit 7 von C
1919 28 02 JR Z, 0x02 >-\ |
191B F6 02 OR 0x02 | | // Setze A Bit 1
191D CB 68 BIT 5, B <-/ | // Prüfe Bit 5 von B
191F 28 02 JR Z, 0x02 >-\ |
1921 F6 04 OR 0x04 | | // Setze A Bit 2
1923 CB 6B BIT 5, E <-/ | // Prüfe Bit 5 von E
1925 28 02 JR Z, 0x02 >-\ |
1927 F6 08 OR 0x08 | | // Setze A Bit 3
1929 CB 43 BIT 0, E <---/ | // Prüfe Bit 0 von E
192B 28 02 JR Z, 0x02 >-\ |
192D F6 10 OR 0x10 | | // Setze A Bit 5
192F CB 51 BIT 2, C <--/ | // Prüfe Bit 2 von C
1931 28 02 JR Z, 0x02 >-\ |
1933 F6 20 OR 0x20 | | // Setze A Bit 6
1935 AE XOR M <--/ | // A XOR (0x2805)
1936 26 15 LD H, 0x15 |
1938 6F LD L, A | // Hole aus Tabelle byte (0x1540 ... 0x157f)
1939 7E LD A,M | // Permutation der Bits, A = (0x15yy)
193A E1 POP HL | // HL = 0x2805
193B F5 PUSH AF | // Rette AF
193C 2C INC L |
193D E5 PUSH HL | // Rette HL = 0x2806
193E 7B LD A,E | // 0x181C LD E, M »> DE = (0x2a06), (0x2a07)
193F E6 04 AND 0x04 | // A = A AND 0x04, Bit 7-4 2-0 = 0, Bit 3 1/0
1941 F6 80 OR 0x80 | // A = 0b1000 x000
1943 CB 59 BIT 3, C | // Prüfe Bit 3 von C
1945 28 02 JR Z, 0x02 >-\ |
1947 F6 08 OR 0x08 | | // Setze A Bit 3 (0x88)
1949 CB 52 BIT 2, D <---/ | // Prüfe Bit 2 von D
194B 28 02 JR Z, 0x02 >-\ |
194D F6 01 OR 0x01 | | // Setze A Bit 0
194F CB 50 BIT 2, B <---/ | // Prüfe Bit 2 von B
1951 28 02 JR Z, 0x02 >-\ |
1953 F6 02 OR 0x02 | | // Setze A Bit 1
1955 CB 6A BIT 5, D <--/ | // Prüfe Bit 5 von D
1957 28 02 JR Z, 0x02 >-\ |
1959 F6 10 OR 0x10 | | // Setze A Bit 4
195B CB 79 BIT 7, C <---/ | // Prüfe Bit 7 von C
195D 28 02 JR Z, 0x02 >-\ |
195F F6 20 OR 0x20 | | // Setze A Bit 5
1961 AE XOR M <--/ | // A XOR (0x2806)
1962 26 15 LD H, 0x15 |
1964 6F LD L, A | // Hole aus Tabelle L-bytes (0x1580 ... 0x15bf)
1965 7E LD A,M | // Permutation der Bits, A = (0x15yy)
1966 E1 POP HL | // HL = 0x2806
1967 F5 PUSH AF | // Rette AF
1968 2C INC L |
1969 E5 PUSH HL | // HL = 0x2807
196A 79 LD A, C | // 0x1817: LD C, M » BC = (0x2a04), (0x2a05)
196B E6 01 AND 0x01 | // A = 0b0000 000x
196D F6 C0 OR 0xC0 | // Setze A Bit 6 und7
196F CB 7B BIT 7, E | // Prüfe Bit 7 von E
1971 28 02 JR Z, 0x02 >-\ |
1973 F6 02 OR 0x02 | | // Setze A Bit 1
1975 CB 60 BIT 4, B <--/ | // Prüfe Bit 4 von B
1977 28 02 JR Z, 0x02 >-\ |
1979 F6 04 OR 0x04 | | // Setze A Bit 2
197B CB 69 BIT 5, C <--/ | // Prüfe Bit 5 von C
197D 28 02 JR Z, 0x02 >-\ |
197F F6 08 OR 0x08 | | // Setze A Bit 3
1981 CB 52 BIT 2, D <--/ | // Prüfe Bit 2 von D
1983 28 02 JR Z, 0x02 >-\ |
1985 F6 10 OR 0x10 | | // Setze A Bit 4
1987 CB 50 BIT 2, B <---/ | // Prüfe Bit 2 von B
1989 28 02 JR Z, 0x02 >-\ |
198B F6 20 OR 0x20 | | // Setze A Bit 5
198D AE XOR M <-/ | // Hole aus Tabelle L-bytes (0x15c0 ... 0x15ff)
198E 26 15 LD H, 0x15 | // H = 0x15
1990 6F LD L, A | // L = A XOR (0x2807)
1991 5E LD E, M | // Permutation der Bits, E = (0x15, A XOR (0x2807))
1992 E1 POP HL | // HL = 0x2807
1993 2C INC L | // HL = 0x2808
1994 F1 POP AF | // A = eingesammelte Bits
1995 B3 OR E | // A OR E
1996 5F LD E, A | // E = A or E
1997 F1 POP AF | // A = (0x15yy)
1998 57 LD D, A | // D = A
1999 F1 POP AF | // A = (0x15yy)
199A B2 OR D |
199B 57 LD D, A | // D = A OR D
199C F1 POP AF | // A = (0x14yy)
199D 4F LD C, A | // C = A
199E F1 POP AF | // A = (0x14yy)
199F B1 OR C |
19A0 4F LD C, A | // C = C OR A
19A1 F1 POP AF | // A = (A XOR (0x2a00))
19A2 47 LD B, A | // B = A
19A3 F1 POP AF | // A = (0x14xx)
19A4 B0 OR B |
19A5 47 LD B,A | // B = B OR (0x14xx)
19A6 E5 PUSH HL | // Rette HL
19A7 DD E5 PUSH IX | // Rette IX
19A9 E1 POP HL | // HL = IX
19AA 7C LD A, H | // A = 0x28
19AB A8 XOR B |
19AC 47 LD B,A | // B = 0x28 XOR B
19AD 7D LD A, L | // A = 0x08
19AE A9 XOR C |
19AF 4F LD C,A | // C = 0x08 XOR C
19B0 FD E5 PUSH IY | //
19B2 E1 POP HL | // HL = IY
19B3 7C LD A, H |
19B4 AA XOR D |
19B5 57 LD D,A | // D = D XOR H
19B6 7D LD A,L |
19B7 AB XOR E |
19B8 5F LD E,A | // E = E XOR L
19B9 E1 POP HL | // HOLE HL
19BA FD E1 POP IY | // HOLE IY
19BC DD E1 POP IX | // HOLE IX
19BE F1 POP AF | // HOLE AF
19BF FE 09 CP 0x09 | // A == 0x09?
19C1 28 2A JR Z, 0x2A >----\ | // JA
19C3 3D DEC A | | // Nein, --A
19C4 C2 22 18 JP NZ, 0x1822 >--> | >+ // A <> 0; Schleife
19C7 21 00 2A LD HL, 0x2A00 | | // Ein- Ausgabe LAMBDA, Wurmreihen
19CA 70 LD M,B | | // (0x2a00) = B
19CB 2C INC L | | // (0x2a01)
19CC 71 LD M,C | | // (0x2a01) = C
19CD 2C INC L | | // (0x2a02)
19CE 72 LD M,D | | // (0x2a02) = D
19CF 2C INC L | | // (0x2a03)
19D0 73 LD M,E | | // (0x2a03) = E
19D1 2C INC L | | // (0x2a04)
19D2 DD E5 PUSH IX | |
19D4 C1 POP BC | | // LD BC, IX
19D5 70 LD M,B | | // (0x2a04) = B
19D6 2C INC L | |
19D7 71 LD M,C | | // (0x2a05) = C
19D8 2C INC L | | // (0x2a06)
19D9 FD E5 PUSH IY | |
19DB C1 POP BC | | // LD BC, IY
19DC 70 LD M,B | | // (0x2a06) = B
19DD 2C INC L | |
19DE 71 LD M,C | | // (0x2a07) = C
19DF AF XOR A | | // Lösche A
19E0 21 00 2A LD HL, 0x2A00 | | // Ein- Ausgabe LAMBDA, Wurmreihen
19E3 06 08 LD B, 0x08 | | // Länge = 8
19E5 AE XOR M <-\ | | // A XOR (0x2a00) Ein- Ausgabe LAMBDA XOR Daten
19E6 23 INC HL | | | // (0x2a01)
19E7 10 FC DJNZ 0xFC >-/ | | // bis (0x2a07)
19E9 32 08 2A LD (0x2A08), A | | // Prüfbyte Summe über Ein- Ausgabe LAMBDA, Wurmreihen
19EC C9 RET | |
| |
19ED E5 L0315: PUSH HL <-------/ | // Rette HL
19EE FD E5 PUSH IY | // Manipulierter Stack über die Push/POPs
19F0 E1 POP HL | // HL = IY
19F1 3A 83 28 LD A,(0x2883) | // A = (0x2883)
19F4 85 ADD A,L | // A = A + L
19F5 6F LD L,A | // L = A
19F6 3A 82 28 LD A,(0x2882) | // A = (0x2882)
19F9 8C ADC A,H | // A = A + Carry + H
19FA 67 LD H,A | // H = A
19FB E5 PUSH HL |
19FC FD E1 POP IY | // IY = HL
19FE DD E5 PUSH IX |
1A00 E1 POP HL | // HL = IX
1A01 3A 81 28 LD A,(0x2881) | // A = (0x2881)
1A04 8D ADC A,L | // A = A + Carry + L
1A05 6F LD L,A | // L = A
1A06 3A 80 28 LD A,(0x2880) | // A = (0x2880)
1A09 8C ADC A,H | // A = A + Carry + H
1A0A 67 LD H,A | // H = A
1A0B E5 PUSH HL |
1A0C DD E1 POP IX | // IX = HL
1A0E 3A 87 28 LD A,(0x2887) | // A = (0x2887)
1A11 83 ADD A,E | // A = A + E
1A12 5F LD E,A | // E = A
1A13 3A 86 28 LD A,(0x2886) | // A = (0x2886)
1A16 8A ADC A,D | // A = A + Carry + D
1A17 57 LD D,A | // D = A
1A18 3A 85 28 LD A,(0x2885) | // A = (0x2885)
1A1B 89 ADC A,C | // A = A + Carry + C
1A1C 4F LD C,A | // C = A
1A1D 3A 84 28 LD A,(0x2884) | // A = (0x2884)
1A20 88 ADC A,B | // A = A + Carry + B
1A21 47 LD B,A | // B = A
1A22 3E 08 LD A, 0x08 | // A = 8
1A24 E1 POP HL | // HL zurück, Zeile 0x19ed-> 0x19a6-> 0x1993
1A25 C3 22 18 JP 0x1822 >--------/ // Schleife
// Testwerte 0x1a41 RAM Check
1A28 FF 00 FF 55 FF AA 55 FF
1A30 AA 55 AA 00 AA FF 00 AA 00 55 00 FF 55 00 55 AA
1A40 FF
// Prüfprogramm RAM CHECK, Übergabe IX; Rückgabe Z-Flag
1A41 DD 4E 02 L0322: LD C, (IX+02) // Übergabe IX; 0x029B; 0x02a3; Größe der RAM Bereiche
1A44 DD 46 03 LD B, (IX+03) // BC = 0x0320; = 0x036f
1A47 78 LD A, B // Prüfung BC == 0
1A48 B1 OR C
1A49 28 4A JR Z, 0x4A // Return IY;
1A4B DD 6E 00 LD L, (IX+00) // Übergabe IX; 0x0299; 0x02a1; Speicheradresse der RAM Bereiche
1A4E DD 66 01 LD H, (IX+01) // HL = 0x0ce0; = 0x2b90
1A51 5D LD E, L
1A52 54 LD D, H // HL = DE = -> Speicherbereiche
1A53 13 INC DE // 0x0ce1; 0x2b91
1A54 3A 28 1A LD A, (0x1A28) // A = 0xff
1A57 77 LD M, A // M = 0xff
1A58 0B DEC BC // BC = Länge = 0x0320 - 1; 0x036f - 1;
1A59 ED B0 LDIR // Fülle RAM mit 0xff; HL = HL + BC
1A5B 11 28 1A LD DE, 0x1A28 // BC == 0x0000, HL = 0xffff; DE = 0x1000 // HL von 0x2b91 bis 0x2f00
1A5E DD 4E 02 L0321: LD C, (IX+02) <---\
1A61 DD 46 03 LD B, (IX+03) | // Größe der RAM 0x029B; 0x02a3
1A64 1A L0319: LD A, (DE) <-------\ | // A = 0xff
1A65 AE XOR M | | // A = A XOR M; HL = 0xffff; HL = 0x2f00
1A66 20 2D JR NZ, 0x2D >---\ | | // A == HL ?
1A68 13 INC DE | | | // = 0x1a29
1A69 1A LD A, (DE) | | | // A = 0x00
1A6A 77 LD M, A | | | // M = 0x00
1A6B 1B DEC DE | | | // = 0x1A28
1A6C 2B DEC HL | | | // = 0xfffe; 0x2eff
1A6D 0B DEC BC | | | // 0x031f; 0x036e
1A6E 79 LD A, C | | | // A = 1f; 6e
1A6F B0 OR B | | | // A or B
1A70 20 F2 JR NZ, 0xf2 | >--/ | // BC == 0x0000 ?, Schleife RAM Check 0xff und 0x00
1A72 13 INC DE | | // = 0x1a29
1A73 23 INC HL | | // = 0xffff; 0x2f00
1A74 DD 4E 02 LD C, (IX+02) | |
1A77 DD 46 03 LD B, (IX+03) | | // Größe der RAM 0x029B; 0x02a3
1A7A 1A L0320: LD A, (DE) <-\ | | // A == 0x00
1A7B AE XOR M | | | // A = 0x00 XOR M
1A7C 20 17 JR NZ, 0x17 | >--+ | // HL == 0x00 ?
1A7E 13 INC DE | | | // DE = 0x1a2a (0xff)
1A7F 1A LD A, (DE) | | | // A = 0xff
1A80 77 LD M, A | | | // M = 0xff
1A81 1B DEC DE | | |
1A82 23 INC HL | | |
1A83 0B DEC BC | | |
1A84 79 LD A, C | | |
1A85 B0 OR B | | |
1A86 20 F2 JR NZ, 0xF2 >-/ | | // BC == 0x00 ? RAM Check auf 0xff
1A88 2B DEC HL | |
1A89 13 INC DE | | // DE = 0x1a2a
1A8A 3E 40 LD A, 0x40 | |
1A8C AB XOR E | |
1A8D 20 CF JR NZ, 0xCF | >--/ // bis 0x1A40 abgearbeitet?
1A8F 0E 04 LD C, 0x04 |
1A91 DD 09 ADD IX, BC | // IX = 0x029B; 0x02a3; + 0x0004
1A93 18 AC JR 0xAC | // Springe in den Anfang der Subroutine 0x1a41
1A95 FD E9 L0318: JP (IY) <-----/ // Beenden Rückgabe Z-Flag
//// CRC1-16 nur für ROM ///////////////////////////////////////////////////
// Übergabe IX = 0x1367 Daten: Start/Länge/Prüfsumme //
// Rücksprungadresse im Speicher IY = 0x00f7 //
////////////////////////////////////////////////////////////////////////////
1A97 DD 4E 02 L0325: LD C, (IX+02)<-------\ // C = (IX+2); 00 ; IX = 0x136d,
1A9A DD 46 03 LD B, (IX+03) | // B = (IX+3); Länge des Prüfbereichse 04 -> 0x0400; 0x0400
1A9D 78 LD A, B | // A = (IX+3)
1A9E B1 OR C | // A = (IX+3) or (IX+2)
1A9F 28 4A JR Z, 0x4A >--\ | // JUMP (IY) wenn BC == 0x0000 keine weiteren EPROM Prüfen
1AA1 DD 6E 00 LD L, (IX+00) | | // L = (IX); 00
1AA4 DD 66 01 LD H, (IX+01) | | // H = (IX+1); Startbereich der Daten 00 -> ab 0x0000; ab 0x0400;
1AA7 11 FF FF LD DE, 0xFFFF | | // DE = 0xffff; CRC Startvektor
1AAA 7E L0324: LD A, M <-\ | | // A = (ix+1,ix) M
1AAB AA XOR D | | | // D = 0xff
1AAC 57 LD D, A | | | // D = A XOR D
1AAD 0F RRCA | | | // Rotiere Rechts A über Carry, A.7 > A.0
1AAE 0F RRCA | | |
1AAF 0F RRCA | | |
1AB0 0F RRCA | | | // 4 * RRCA
1AB1 E6 0F AND 0x0F | | | // Maskiere A, nur Lowbyte
1AB3 AA XOR D | | | // A = A.low XOR D
1AB4 57 LD D, A | | | // D = A
1AB5 0F RRCA | | | // rotiere rechts A.7 > A.0
1AB6 0F RRCA | | |
1AB7 0F RRCA | | | // 3 * RRCA
1AB8 E6 1F AND 0x1F | | | // Maskiere A, 0x1f, bits 4 - 0
1ABA AB XOR E | | | // A = A XOR E
1ABB 5F LD E, A | | | // E = A
1ABC 7A LD A, D | | | // A = D
1ABD 0F RRCA | | | // rotiere rechts A.7 > A.0
1ABE 0F RRCA | | |
1ABF 0F RRCA | | |
1AC0 0F RRCA | | | // 4 * RRCA
1AC1 E6 F0 AND 0xF0 | | | // Maskiere obere 4 bytes
1AC3 AB XOR E | | | // A = A XOR E
1AC4 5F LD E, A | | | // E = A
1AC5 7A LD A, D | | | // A = D
1AC6 0F RRCA | | | // rotiere rechts A.7 > A.0
1AC7 0F RRCA | | |
1AC8 0F RRCA | | | // 3 * RRCA
1AC9 E6 E0 AND 0xE0 | | | // maskiere 0xe0, bit 7 - 5
1ACB AA XOR D | | | // A = A XOR D
1ACC 53 LD D, E | | | // D = E
1ACD 5F LD E, A | | | // E = A
1ACE 23 INC HL | | | // HL + 1
1ACF 0B DEC BC | | | // BC - 1
1AD0 78 LD A, B | | | // A = B
1AD1 B1 OR C | | | // A = B or C
1AD2 20 D6 JR NZ, 0xD6 >-/ | | // bis BC == 0, Länge 0x0400; Debug
1AD4 DD 73 04 LD (IX+04), E | | // ??(IX+4) = E; 50 In den ROM schreiben Debugversion?? -> NOP NOP NOP ersetzen
1AD7 DD 72 05 LD (IX+05), D | | // ??(IX+5) = D; B6 Prüfsummen: 0x50b6; 0x583a ... -> NOP NOP NOP ersetzen
1ADA DD 6E 04 LD L, (IX+04) | | // Prüfsumme EPROM Nr. x low
1ADD DD 66 05 LD H, (IX+05) | | // Prüfsumme EPROM Nr. y High
1AE0 ED 52 SBC HL, DE | | // HL = HL - DE
1AE2 20 07 JR NZ, 0x07 >-+ | // ungleich null-> Prüfsumme Falsch
1AE4 01 06 00 LD BC, 0x0006 | | // BC = 0x06 -> Prüfsumme richtig
1AE7 DD 09 ADD IX, BC | | // IX = IX + 6; 0x136d
1AE9 18 AC JR 0xAC | >-/ // Beginn der Subroutine
1AEB FD E9 L0323: JP (IY) <---/ // Ende CRC über ROM, Übergabe Z-Flag = 1 alle EPROM OK, = 0 mind. ein EPROM fehlerhaft
// CRC2-16, Übergabe DE, A; Rückgabe DE
1AED AA XOR D // A XOR D
1AEE 57 LD D,A // D = D XOR A
1AEF 0F RRCA // A.7 > A.6 > ... A.0 > C, A.7 = C
1AF0 0F RRCA
1AF1 0F RRCA
1AF2 0F RRCA // 4 mal rechts rotation SWAP HIGH <> LOW
1AF3 E6 0F AND 0x0F // Maskiere untere 4 Bits
1AF5 AA XOR D //
1AF6 57 LD D,A // D = D XOR A (bit 4 ... 0)
1AF7 0F RRCA // Rotiere Rechts
1AF8 0F RRCA
1AF9 0F RRCA // A.0 > A.5, A.1 > A.6, A.2 > A.7, A.3 > A.0, ...
1AFA F5 PUSH AF // Rette AF
1AFB E6 1F AND 0x1F // Maskiere untere 5bits
1AFD AB XOR E
1AFE 5F LD E,A // E = E XOR A(bit 4 ... 0)
1AFF F1 POP AF // AF zurück
1B00 F5 PUSH AF // AF Retten
1B01 0F RRCA
1B02 E6 F0 AND 0xF0 // Maskiere oberen bits 7 ... 4
1B04 AB XOR E
1B05 5F LD E,A // E = E XOR A (bit 7 ... 4)
1B06 F1 POP AF // AF zurück
1B07 E6 E0 AND 0xE0 // Maskiere Bit 4 ... 5
1B09 AA XOR D // A = D XOR A(bit 7 ... 5)
1B0A 53 LD D,E // D = E
1B0B 5F LD E,A // E = A
1B0C C9 RET // Rückgabe DE
1B0D 7F // Füllbytes
...
1BFF 7F // Füllbytes
// ROM 7 - 9 nicht belegt:
1c00 ... 27ff
// Start ROM/RAM Karte RAM Speicher 2kbyte:
2800 ... 2fff