ATAMON V1.3

Inhaltsverzeichnis

• ATAMON V1.3

  • Inhaltsverzeichnis

  • Vorwort

  • Was ist ATAMON?

• Technische Dokumentation

  • Maschinensprachemonitor für den Atari 800XL

  • 1. Allgemeine Übersicht

  • 2. Speicherbelegung

  • 3. Startmechanismus

    • Registersicherung ($401C)

  • 4. Hauptbefehlsschleife

    • Eingabeaufforderung und Registeranzeige

  • 5. Programm in ATAMON laden

    • Der Doppelагenten-Plan

    • Haltepunkte im Programm setzen

  • 6. Befehlsreferenz

    • Syntaxkonventionen

    • G [aaaa] — Go (Ausführen)

    • M aaaa — Memory (Speicher anzeigen)

    • E ssss — E (Diskettensektor lesen)

    • D aaaa[,bbbb] — Disassemble (Disassemblieren)

    • L aaaa,bbbb,xx — Locate Non-Matching (Abweichende Bytes finden)

    • W ssss — Write (Diskettensektor schreiben)

    • V aaaa,bbbb,cccc — Verify (Speicher vergleichen)

    • F aaaa,bbbb,bb — Fill (Speicher füllen)

    • T aaaa,bbbb,cccc — Transfer (Speicher kopieren)

    • H aaaa,bbbb,DsuchfolgeD — Hunt (Speicher durchsuchen)

    • S aaaa — Scan (Binär-Echtzeitmonitor)

    • C aaaa,bbbbbbbb — Code (Binärbytes in Speicher schreiben)

    • P [E|T] — Printer (Druckerverwaltung)

    • R — Registers (Register anzeigen)

    • X — eXit (Beenden)

    • Z nn,cc[,aaaa,llll] — IOCB (CIO-Kanal-Operation)

      • Das CIO-System kurz erklärt

      • IOCB-Kanäle

      • Z-Syntax

    • I aaaa,DdatenD — Input String (Text in Speicher schreiben)

    • # — Dezimal → Hexadezimal-Umrechnung

    • $ — Hexadezimal → Dezimal-Umrechnung

    • % — Binäreingabe

    • ; aaaa BB BB BB BB XXXXXXXX — Set (Alle Register auf einmal laden)

    • ! aaaa — Binary (Hexadezimal → Binär-Umrechnung)

    • * OP aaaa,bbbb — Arithmetic (Rechenwerk)

    • : aaaa bb bb bb bb bb bb bb bb — Enter (Bytes in Speicher eingeben)

    • , aaaa bb [bb ...] — Enter with Disassembly (Eingabe mit Disassemblierung)

  • 7. Interne Variablen (Zeropage)

  • 8. Wichtigste Unterprogramme

  • 9. Nutzung des Atari-Betriebssystems

  • 10. Interne Datentabellen

    • Banner und Registerformat ($4F44)

    • Hex-Ziffern + Befehlstabelle ($4F8D)

    • Dispatch-Tabelle ($4FC8)

    • Interne Disassembler-Tabellen ($4FF9+)

  • 11. ATAMON benutzen

    • Start

    • Sondertasten

    • Typische Startanzeige

    • Beispielsitzung

  • 12. Historische Anmerkungen

  • 13. Technische Hinweise zur Disassemblierung

    • Bekannte illegale 6502-Opcodes

    • JMP-Indirect-Fehler

  • Anhang A — Zeropage-Glossar ($00–$FF)

    • Atari-OS-Variablen (vom System reserviert)

    • Von ATAMON verwendete Variablen

  • Anhang B — Die 56 offiziellen 6502-Mnemoniken

    • Laden / Speichern

    • Registertransfers

    • Stapel

    • Arithmetik

    • Inkrementieren / Dekrementieren

    • Logische Operationen

    • Schieben und Rotieren

    • Vergleiche

    • Bedingte Sprünge

    • Sprünge und Aufrufe

    • Software-Interrupt

    • Flag-Operationen

    • Sonstiges

  • Anhang C — Illegale / undokumentierte 6502-Opcodes

    • Fatale Befehle

    • Kombinierte Lese-Modifizier-Schreib-Befehle

    • Kombiniertes Laden / Speichern

    • Akkumulator-Befehle

    • Instabile Speicherbefehle (abhängig von addr_hi)

    • Illegale NOPs (mehrere Bytes, kein Effekt)

  • Anhang D — Bekannte Atari-Bezeichner

    • Zeropage — OS-Variablen ($00–$FF)

    • Seite 2 — Interrupt-Vektoren ($0200–$02FF)

    • Seite 3 — SIO-DCB ($0300–$035F)

    • Hardwareregister — GTIA ($D000)

    • Hardwareregister — POKEY ($D200)

    • Hardwareregister — PIA ($D300)

    • Hardwareregister — ANTIC ($D400)

    • OS-ROM-Einsprungpunkte ($E4xx)

    • Math-ROM ($D8xx)

  • Anhang E — Atari 800XL Hardwareregister — Kurzübersicht

    • GTIA — Graphic Television Interface Adaptor ($D000–$D01F)

    • POKEY — Potentiometer and Keyboard ($D200–$D20F)

    • PIA — Peripheral Interface Adaptor ($D300–$D303)

    • ANTIC — Alphanumeric Television Interface Circuit ($D400–$D40F)

  • Korrektur des C-Befehls-Fehlers (Patch)

    • Der Fehler

    • Die Korrektur

    • Den Patch anwenden

  • Quellenverzeichnis

    • 6502-Prozessor

    • Atari 800XL Dokumentation

    • AtariWiki

    • .PRO-Diskettenformat

    • Verwendeter Emulator

Vorwort

Die Dokumentation von ATAMON (ATAri MONitor) ist seit über 40 Jahren unauffindbar.

Was Sie hier lesen, ist eine inoffizielle Dokumentation — das Ergebnis stundenlanger Arbeit, Versuche, Dekompilierung und Abfassung auf Basis des disassemblierten ATAMON-Codes.

Ich hoffe, Sie finden Gefallen daran ;-)

Atarinside — März 2026

Das Programm ist hier zu finden: https://www.atarinside.com/blog/index.php/atarinside-items/atamon/

Was ist ATAMON?

Sie haben soeben ATAMON, den Maschinensprachemonitor von ATARI, geladen. Aber wozu dient ein Monitor eigentlich?

Ihr Atari 800XL wird von einem Prozessor angetrieben — dem 6502 — der Tausende von Befehlen pro Sekunde ausführt. Diese Befehle — auch „Maschinensprache" genannt — sind als Zahlen im Speicher abgelegt. ATAMON ist das Werkzeug, mit dem Sie diese Befehle direkt ansehen, ändern und ausführen können, ohne eine Zwischensprache wie BASIC zu benötigen.

Konkret ermöglicht ATAMON Folgendes:

• In den Speicher schauen: Zeigen Sie beliebige Bereiche des RAM Ihres Atari Byte für Byte an.

• Speicher verändern: Ändern Sie Werte direkt, korrigieren Sie einen Fehler in einem Programm oder passen Sie ein Spiel nach Ihren Wünschen an.

• Ein Programm disassemblieren: ATAMON übersetzt rohe Maschinensprache in lesbare Mnemoniken (wie LDA, JMP, STA…), sodass Sie verstehen können, wie ein Programm funktioniert.

• Ausführen und debuggen: Starten Sie ein Programm und übernehmen Sie an jedem BRK-Haltepunkt wieder die Kontrolle — unerlässlich für die Fehlersuche.

• Sektoren sichern: Lesen und schreiben Sie Diskettensektoren direkt (über die Befehle E und W).

• Rechnen: Führen Sie Additionen, Subtraktionen, logisches UND und ODER direkt in Hexadezimal oder Binär durch.

Für wen? ATAMON richtet sich an Programmierer und Enthusiasten, die das Innenleben ihres Atari verstehen wollen, oder an alle, die Maschinenprogramme untersuchen und verändern möchten. Keine zusätzliche Hardware erforderlich: ATAMON läuft vollständig auf Ihrem Atari mit dem normalen Diskettenlaufwerk.

Wie fangen Sie an? Wählen Sie im Atari-DOS-Menü L. BINARY LOAD, tippen Sie D:ATAMON und drücken Sie die Eingabetaste. Das Programm lädt sich ab Adresse $4000 in den Speicher, zeigt sein Banner an, und der Atari-Cursor signalisiert die Bereitschaft zur Befehlseingabe. Alle Befehle bestehen aus einem einzigen Buchstaben — schnell und effizient.

Technische Dokumentation

Maschinensprachemonitor für den Atari 800XL

Quelldatei: Atamon - D7 - DXG 5724.PRO → ATAMON Kennung: *** ATAMON V1.3 - (c) 1983 by ATARI *** Typ: 6502-Maschinensprache-Monitor / Debugger Größe: 4.404 Byte Format: Atari XEX (mehrere Segmente) Ladeadresse: $4000 Startadresse (RUNAD): $4000 Quellsprache: 6502-Assembler Herausgeber: Atari Deutschland GmbH — ATAMON ist ein Produkt von Atari Deutschland, Katalognummer DXG 5724 Autor: Nicht identifiziert — die Binärdatei enthält keinen Programmierernamen, nur (c) 1983 by ATARI Wahrscheinliches Assembler-Werkzeug: Atari Macro Assembler oder MAC/65 (OSS) — aus der Struktur der 256-Byte-XEX-Segmente (252 Byte Code + 4-Byte-Header) erschlossen

1. Allgemeine Übersicht

ATAMON ist ein professioneller Maschinensprachemonitor, der 1983 von ATARI entwickelt wurde. Er ermöglicht einem Programmierer:

• RAM zu untersuchen und zu verändern

• 6502-Register anzuzeigen und zu verändern (Programmzähler, Stapelzeiger, Akkumulator, X, Y, Flags)

• 6502-Code direkt im Speicher zu disassemblieren

• Code auszuführen und an jedem BRK-Haltepunkt die Kontrolle zurückzugewinnen

• Diskettensektoren zu lesen und zu schreiben

• Speicherbereiche zu überprüfen und zu übertragen

• Hexadezimalberechnungen durchzuführen

ATAMON gehört zur Familie der Maschinensprachemonitore, die in den 1980er Jahren 8-Bit-Computern auf vielen Plattformen beilagen.

2. Speicherbelegung

Adresse      Inhalt
---------    --------------------------------
$4000        Haupteinsprungpunkt (RUNAD)
$4000-$52B1  ATAMON-Code und -Daten
$4F3C-$4F42  CPU-Registersicherungsbereich
$4E3C        Tastatureingabepuffer (Befehlszeile)
$4F44        ASCII-Banner + Registeranzeigeformat
$4F8D        Hex-Zifferntabelle + Befehlszeichen
$4F9D        Befehlsdispatch-Tabelle
$4FC8        Handler-Adresstabelle (Vektoren)
$4FF9+       Interne 6502-Disassembler-Tabellen

Speicherbedarf: ca. 4,5 KB von $4000 bis $52B1. ATAMON setzt außerdem MEMLO = $5300, um seinen Code zu schützen.

3. Startmechanismus

Der Einsprungpunkt bei $4000 nutzt eine klassische Technik: den BRK-Vektor ($0206–$0207).

xxxxxxxxxx
$4000  LDA #$40         ; BRK-Handler installieren
$4002  STA $0207        ; VBREAK hi = $40
$4005  LDA #$0B
$4007  STA $0206        ; VBREAK lo = $0B  →  Handler bei $400B
$400A  BRK              ; BRK absichtlich auslösen
; === Der 6502 legt (aktuelle Adresse + 2) und Flags auf den Stapel, springt über $0206 ===
$400B  LDA #$40         ; VBREAK für zukünftige Verwendung neu konfigurieren
$400D  STA $0207
$4010  LDA #$1A
$4012  STA $0206        ; Neuer VBREAK = $401A
$4015  LDA #$43         ; 'C' = Kennzeichen "Eintritt über Start"
$4017  JMP $401C        ; → CPU-Zustand sichern

Warum diese Technik? Der BRK-Befehl legt automatisch die Adresse des nächsten Befehls (aktuelle Adresse + 2) sowie das Statusregister auf den Stapel. ATAMON liest diese Werte anschließend aus, um eine vollständige Momentaufnahme des Prozessorzustands beim Eintritt in den Monitor zu erstellen.

Registersicherung ($401C)

xxxxxxxxxx
$401C  STA $E4          ; Eintrittskennzeichen sichern (vom Aufrufer übergeben)
$401E  PLA              ; A zurückholen (vom OS-Handler vor BRK per PHA gesichert)
$401F  STA $4F3D        ; A sichern
$4022  STY $4F3F        ; Y sichern
$4025  STX $4F3E        ; X sichern
$4028  PLA              ; P (Flags, vom BRK-Stapel) zurückholen
$4029  STA $4F40        ; P sichern
$402C  CLC
$402F  PLA              ; PCL (niederwertiges Adressbyte, vom BRK-Stapel) zurückholen
$4030  ADC #$FF         ; 1 subtrahieren (16-Bit: BRK legt addr+1 ab, wir kehren zur echten Adresse zurück)
$4032  STA $4F41        ; bereinigtes PCL sichern
$4035  PLA              ; PCH (höherwertiges Adressbyte, vom BRK-Stapel) zurückholen
$4036  ADC #$FF         ; 16-Bit-Subtraktion mit Übertrag fortsetzen
$4038  STA $4F42        ; bereinigtes PCH sichern
$403B  TSX
$403C  STX $4F3C        ; SP sichern
$403F  LDX #$FD
$4041  TXS              ; Stapel auf $FD zurücksetzen

Hinweis zum Eintrittsmechanismus: Der Atari-OS-Handler (ROM-IRQ) legt Register A per PHA auf den Stapel, bevor er den VBREAK-Vektor aufruft. Deshalb führt SAVE_CPU vier aufeinanderfolgende PLAs aus (A, P, PCL, PCH), obwohl der BRK-Befehl selbst nur drei ablegt (P, PCL, PCH).

Registersicherungsbereich ($4F3C–$4F42):

xxxxxxxxxx
$4F3C  SP  Stapelzeiger
$4F3D  A   Akkumulator
$4F3E  X   X-Register
$4F3F  Y   Y-Register
$4F40  P   Statusregister (Flags NV\BDIZC)
$4F41  PCL Niederwertiges Byte der nächsten Befehlsadresse (angepasst -1)
$4F42  PCH Höherwertiges Byte der nächsten Befehlsadresse

Dieses Layout wird durch den G-Handler (Go) bestätigt: LDA $4F3D stellt A wieder her, LDA $4F40; PHA; PLP stellt P wieder her, JMP ($4F41) springt zur Adresse $4F42:$4F41.

4. Hauptbefehlsschleife

Nach der Initialisierung zeigt ATAMON sein Banner an und tritt in die Befehlsschleife ($4064) ein:

xxxxxxxxxx
1. Stapel auf $FD zurücksetzen
2. Eingabepuffer leeren ($4E3C ← $9B)
3. Kanal E: (Bildschirmeditor) über CIO öffnen
4. Zeile über CIO (IOCB 0) lesen
5. Erstes Nicht-Leerzeichen suchen
6. Dieses Zeichen in Tabelle $4F9D nachschlagen
7. Wenn gefunden → Handler-Adresse aus $4FC8/$4FC9 laden
8. Handler über indirektes RTS ausführen (hi-1 / lo-1 ablegen, RTS)
9. Zu Schritt 1 zurückkehren

Eingabeaufforderung und Registeranzeige

ATAMON zeigt keine explizite Eingabeaufforderung an: Die Eingabeaufforderung ist der Atari-Bildschirmeditor-Cursor (blinkender Inversionsblock), der automatisch vom Betriebssystem verwaltet wird. Wenn dieser Cursor sichtbar ist, wartet ATAMON auf einen Befehl.

Die Kopfzeilen *R, *B, *C sind ATAMON-Anzeigevorspänne, kein Prompt. Das Sternchen * (Code $2A) wird von ATAMON vor der Registeranzeige ausgegeben, gefolgt von einem Buchstaben, der den Eintragskontext anzeigt:

• *C — Eintritt über Start oder G

• *R — Befehl R

• *B — Rückkehr nach BREAK (Unterbrechung eines Programms)

Beispiel einer Registeranzeige (nach dem Befehl R oder nach einem BRK):

xxxxxxxxxx
*R
  PC  SP AC XR YR NV\BDIZC
; 400B FB 0B 20 01 00110001

Die Wertzeile beginnt immer mit ;. Bedeutung der einzelnen Felder:

Diese Zeile wird nach jeder Programmrückkehr (nach einem BRK oder G) automatisch aktualisiert, um den tatsächlichen Prozessorzustand zu diesem Zeitpunkt widerzuspiegeln.

5. Programm in ATAMON laden

Der Atari speichert die automatische Startadresse des zuletzt geladenen Programms an einer bestimmten Speicherstelle bei Adresse $02E0 (dem Systemvektor namens RUNAD).

Wenn Sie Ihr Spiel laden, wird seine Startadresse in $02E0 eingetragen. Laden Sie danach ATAMON, überschreibt ATAMONs Startadresse ($4000) die Ihres Spiels!

Um dies zu umgehen und ATAMON als Werkzeug zu nutzen, kehren wir die Ladereihenfolge um — mit Hilfe einer anderen DOS-Menüoption (M).

Der Doppelagenten-Plan

Schritt 1: Den Monitor „verdeckt" installieren

1. Wählen Sie im DOS-Menü L, um ATAMON zu laden.

2. ATAMON erscheint auf dem Bildschirm. Geben Sie den Befehl X (eXit) ein.

3. Sie kehren zum DOS-Menü zurück, aber ATAMON bleibt unsichtbar im Speicher (ab $4000).

Schritt 2: Ihr Spiel lautlos laden

1. Zurück im DOS, laden Sie Ihr Programm erneut mit L und hängen /N an (kein Leerzeichen nach dem Dateinamen) — Beispiel: MYPROG.BIN/N.

2. Das Spiel lädt sich in den Speicher, und das Betriebssystem schreibt seine Startadresse in $02E0. Da wir /N verwendet haben, springt DOS nicht zu dieser Adresse, führt das geladene Programm nicht aus und bleibt im Menü.

Schritt 3: ATAMON aufwecken

1. Wählen Sie im DOS-Menü die Option M (Run at address).

2. Geben Sie 4000 (die Adresse, wo ATAMON schläft) ein und drücken Sie die Eingabetaste.

3. Das ATAMON-Banner erscheint — Sie sind wieder im Monitor!

Schritt 4: Die magische Adresse lesen

1. Zeigen Sie in ATAMON den Speicher bei $02E0 an:

xxxxxxxxxx
Eingabe:
M 02E0

2. Drücken Sie sofort BREAK, um das Scrollen anzuhalten.

3. Schauen Sie sich die ersten zwei Bytes der angezeigten Zeile an.

Achtung — Little Endian: Der Atari speichert Adressen „verkehrt herum" (niederwertiges Byte zuerst, dann höherwertiges).

• Zeigt ATAMON :02E0 00 50 ..., ist die Adresse Ihres Programms $5000.

• Zeigt er :02E0 00 2A ..., ist die Adresse $2A00.

Das war's! Verwenden Sie nun den G-Befehl mit der gefundenen Adresse (z. B. G 5000), um Ihr Programm zu starten — ATAMON ist bereit, jeden Absturz oder Haltepunkt (BRK) abzufangen.

Haltepunkte im Programm setzen

Warnung: ATAMON verfügt über keine garantierte asynchrone Unterbrechungsfunktion.

Die einzige zuverlässige Methode, um die Kontrolle mitten in einem Programm an ATAMON zurückzugeben, ist das bewusste Einfügen eines Software-Haltepunkts:

1. Ersetzen Sie ein Byte Ihres Programms vorübergehend durch den BRK-Befehl (Hexcode $00).

2. Wenn der Prozessor dieses $00 ausführt, löst er einen Software-Interrupt aus.

3. ATAMON hat den System-Interruptvektor (VBREAK bei $0206–$0207) beim Laden umgeleitet.

4. Der Prozessor springt direkt zu ATAMON, das alle Register (A, X, Y, PC...) sichert und mit *B anzeigt, dass es einen BRK abgefangen hat.

Zusammenfassung: Wenn Ihr Programm eine Endlosschleife ohne BRK-Befehl ist, hilft Ihnen die BREAK-Taste nicht weiter (außer Ihr Code ruft OS-Tastaturprogramme auf). Ein Reset wird notwendig! Setzen Sie Ihre $00-Haltepunkte immer strategisch, bevor Sie Ihren Code mit G starten.

6. Befehlsreferenz

Die Befehlstabelle beginnt bei $4F9D. Befehle werden in Großbuchstaben eingegeben. Wenn ein Befehl mehrere Argumente hat, werden sie durch Kommas getrennt (kein Leerzeichen zwischen Argumenten). Vor dem ersten Argument ist ein Leerzeichen erlaubt.

Syntaxkonventionen

• aaaa = 16-Bit-Adresse in Hexadezimal (z. B. 4000)

• bb = 8-Bit-Byte in Hexadezimal (z. B. FF)

• [...] = optionales Argument

G [aaaa] — Go (Ausführen)

Startet die Programmausführung bei Adresse aaaa. Ohne Argument: setzt ab dem gesicherten Programmzähler (PC-Register) fort. Stellt alle gesicherten CPU-Register wieder her, bevor JMP aaaa ausgeführt wird.

Warnung: G aaaa springt direkt zur angegebenen Adresse. Enthält diese kein gültiges Programm (z. B. uninitialiserter RAM mit Nullen), führt der 6502 beliebige Befehle aus und das System hängt sich auf. G allein (ohne Adresse) ist sicher: Es setzt ab dem beim letzten BRK gesicherten PC fort.

Erste Verwendung nach dem Start: Beim Start ist der gesicherte PC $400B (ATAMON-Initialisierungs-Einsprungpunkt). G allein führt daher den ATAMON-Start neu aus: Das Banner erscheint erneut, gefolgt von *C und dem Registerzustand.

Beispiele:

​x

Eingabe:
G

*** ATAMON V1.3 - (c) 1983 by ATARI  ***
*C
  PC  SP AC XR YR NV\BDIZC
; 400B FD 00 00 00 00110000

Eingabe:
G 4000
; Startet Ausführung bei $4000 — ATAMON tritt zurück, solange Ihr Programm läuft.
; Kontrolle erst zurück, wenn das Programm BRK ausführt.

M aaaa — Memory (Speicher anzeigen)

Zeigt den Speicherinhalt ab Adresse aaaa an, 8 Byte pro Zeile in Hexadezimal. ATAMON scrollt unbegrenzt — BREAK drücken zum Anhalten.

Format: : + Adresse + 8 Hex-Bytes + ATASCII-Spalte rechts.

Beispiel:

xxxxxxxxxx

Eingabe:
M 4000

Ergebnis (scrollt endlos — BREAK zum Anhalten):
:4000  A9 40 8D 07 02 A9 0B 8D  ©@♦ ©.♦
:4008  06 02 A9 43 4C 1C 40 48  . ©CL @H
:4010  68 48 8C 3F 4F A8 B9 40  hH♦?O¨¹@
; ... (läuft automatisch weiter)

E ssss[,aaaa[,nn]] — E (Diskettensektor lesen)

Liest Diskettensektor ssss (hexadezimal) von Laufwerk D1: in den Puffer bei aaaa (Standard: $0680). Zeigt OK bei Erfolg an.

Optionale Argumente:

• aaaa: Zieladresse des Puffers (Standard: $0680)

• nn: Anzahl aufeinanderfolgender Sektoren (Standard: 01) — Puffer rückt pro Sektor um $80 (128 Byte) vor

ssss ist eine Sektornummer (keine Speicheradresse). Atari-Diskette einfacher Dichte: $0001–$02D0.

xxxxxxxxxx

Eingabe:
E 0168
Ergebnis:
OK

Eingabe:
E 0001,0700
Ergebnis:
OK
; Sektor 1 in $0700 geladen (statt Standard $0680)

Eingabe:
E 0001,0700,02
Ergebnis:
OK
; Sektor 1 → $0700, Sektor 2 → $0780

Eingabe:
E 0001
Ergebnis bei Fehler:
I/O ERROR #138

D aaaa[,bbbb] — Disassemble (Disassemblieren)

Disassembliert 6502-Code ab Adresse aaaa und zeigt die Mnemoniken an. Verwendet die internen Tabellen bei $4FF9, die die 56 6502-Mnemoniken und Adressierungsmodusdekodierungsinformationen enthalten.

Wichtig: Die Endadresse bbbb wird syntaktisch akzeptiert, aber ignoriert — ATAMON disassembliert unbegrenzt, überschreitet $FFFF und beginnt bei $0000 neu. BREAK drücken zum Anhalten.

xxxxxxxxxx

Eingabe:
D 4000,400C

Ergebnis (scrollt endlos — BREAK zum Anhalten):
4000  A9 40     LDA #$40
4002  8D 07 02  STA $0207
4005  A9 0B     LDA #$0B
4007  8D 06 02  STA $0206
400A  A9 43     LDA #$43
400C  4C 1C 40  JMP $401C
; ... (läuft automatisch weiter)

Jede Zeile enthält: die Adresse, die rohen Bytes im Speicher, dann den disassemblierten Befehl.

L aaaa,bbbb,xx — Locate Non-Matching (Abweichende Bytes finden)

Durchsucht den Speicherbereich von aaaa bis bbbb und zeigt Adressen an, wo das Byte ungleich xx ist.

In der Praxis: L ermittelt Bytes, die einem Referenzwert „nicht entsprechen". Nützlich, um nach einer Kopie schnell Unterschiede zwischen zwei Bereichen zu erkennen oder veränderte Bytes in einem Programm zu finden.

L allein (ohne Argument) → Fehler ? — alle drei Argumente sind erforderlich.

Hinweis: ATAMON besitzt keinen Befehl zum Laden von Dateien. Programme müssen vor dem Start von ATAMON über das Atari-DOS geladen werden (Option L. BINARY LOAD).

xxxxxxxxxx

Eingabe:
F 6000,60FF,EA ; ($6000–$60FF mit $EA füllen)

Eingabe:
: 6000 A9 FF 8D 00 D0 4C 00 40 ; (einige Bytes bei $6000 ändern)

Eingabe:
L 6000,60FF,EA ; Durchsucht $6000–$60FF und zeigt Adressen an, wo Byte ≠ $EA

Ergebnis (7 Adressen pro Zeile — BREAK drücken zum Anhalten, zeigt *B):
6000  6001  6002  6003  6004  6005  6006
6007
*B
; → Adressen $6000–$6007 enthalten Bytes ≠ $EA
; Adressen, wo das Byte genau $EA ist, werden NICHT angezeigt

W ssss[,aaaa[,nn]] — Write (Diskettensektor schreiben)

Schreibt den Speicherpuffer bei Adresse aaaa (Standard: $0680) auf Diskettensektor ssss (hexadezimal).

Optionale Argumente: identisch mit E — Quelladresse des Puffers und Sektoranzahl.

Achtung: überschreibt den Sektor auf der Diskette direkt — nicht rückgängig zu machen. ssss ist eine Sektornummer in Hexadezimal (1 bis $02D0 = 720 bei einer Diskette einfacher Dichte).

E und W arbeiten zusammen: E zum Lesen eines Sektors, Änderungen mit M oder :, dann W zum Zurückschreiben.

xxxxxxxxxx

Eingabe:
E 0001 ; 1. Sektor 1 in den Puffer lesen ($0680)

; (Puffer ggf. mit : 0680 A9 FF ... ändern)

Eingabe:
W 0001 ; 2. Puffer auf Sektor 1 zurückschreiben

Ergebnis: OK
; Bei Fehler: I/O ERROR #xxx

V aaaa,bbbb,cccc — Verify (Speicher vergleichen)

Vergleicht den Speicherbereich aaaa→bbbb mit dem Bereich ab cccc (Speicher-zu-Speicher-Vergleich). Meldet Adressen, an denen die Bytes abweichen. Es werden keine Änderungen vorgenommen.

Nützlich, um zu prüfen, ob eine mit T erstellte Kopie mit dem Original übereinstimmt, oder um zwei Programmversionen zu vergleichen.

xxxxxxxxxx

Eingabe:
T 6000,600F,6100 ; ($6000–$600F nach $6100 kopieren)

Eingabe:
V 6000,600F,6100 ; $6000–$600F mit $6100–$610F vergleichen

Ergebnis wenn alles übereinstimmt:
OK

; Um Unterschiede zu sehen, ein Byte vor dem Vergleich ändern:

Eingabe:
: 6100 FF FF 00 00 00 00 00 00

Eingabe:
V 6000,600F,6100 ; $6100 und $6101 geändert → ATAMON meldet $6000 und $6001

Ergebnis (7 Adressen pro Zeile):
6000  6001
; Nur die QUELL-Adressen mit abweichenden Bytes werden angezeigt — nicht die Werte.

Hinweis: Wenn der Zielbereich nicht initialisiert ist (beliebiger RAM), erscheinen nahezu alle Adressen des Bereichs im Ergebnis.

F aaaa,bbbb,bb — Fill (Speicher füllen)

Füllt den Speicherbereich aaaa→bbbb mit Byte bb.

Sicherer Bereich: ATAMON belegt $4000–$52B1. Adressen ab $5300 verwenden (z. B. $6000+).

xxxxxxxxxx

Eingabe:
F 6000,60FF,EA

Ergebnis:
OK
; ATAMON zeigt „OK" an und kehrt zum Prompt zurück
; $6000 bis $60FF (256 Bytes) enthält jetzt $EA (NOP-Opcode)
; Nützlich, um einen Bereich zu „bereinigen" oder vor dem Patchen NOPs zu schreiben

; Zur Überprüfung, dass die NOPs geschrieben wurden:

Eingabe:
M 6000

Ergebnis:
:6000  EA EA EA EA EA EA EA EA  nnnnnnn
:6008  EA EA EA EA EA EA EA EA  nnnnnnn
; ... (BREAK drücken zum Anhalten)
; Rechte Spalte = ATASCII von $EA (Zeichen 'n' in inversem ATASCII)

T aaaa,bbbb,cccc — Transfer (Speicher kopieren)

Kopiert den Speicherblock von aaaa bis bbbb zum Ziel cccc (Speicher-zu-Speicher). Führt danach eine byteweise Überprüfung durch und meldet Unterschiede.

Überlappende Bereiche: Wenn Quelle und Ziel sich im Speicher überschneiden, würde eine naive Kopie von Anfang bis Ende noch nicht gelesene Quell-Bytes überschreiben. ATAMON vermeidet das: Liegt das Ziel vor der Quelle, wird von links nach rechts kopiert (erstes Byte zuerst); liegt das Ziel nach der Quelle (Überlappung rechts), wird von rechts nach links kopiert (letztes Byte zuerst). Das Ergebnis ist immer korrekt, unabhängig von der Konstellation.

Sicherer Bereich: ATAMON belegt $4000–$52B1. Für Tests einen Bereich ab $5300 verwenden (z. B. $6000–$7FFF, freier RAM).

xxxxxxxxxx

Eingabe:
T 6000,60FF,6100 ; $6000–$60FF nach $6100 kopieren

Ergebnis: OK

Eingabe:
T 6000,6008,6004 ; Überlappungsfall: ATAMON kopiert rückwärts, um die Quelle nicht zu überschreiben
; Ergebnis: (kein Anzeigetext — korrekt behandelt)

H aaaa,bbbb,DsuchfolgeD — Hunt (Speicher durchsuchen)

Durchsucht aaaa–bbbb nach Bytefolge DsuchfolgeD. Zeigt gefundene Adressen an, dann OK.

D = beliebiges Trennzeichen (", /...). Daten: Hex-Paare oder 'Zeichenkette' in einfachen Anführungszeichen.

Nur Suche — kein Ersetzen. Mindestens drei Argumente erforderlich (H oder H aaaa,bbbb → ?).

xxxxxxxxxx

Eingabe:
H 4000,52B0,"'ATARI'"
Ergebnis:
4D99  4E4A  4F62
OK

Eingabe:
H 4000,52B0,"4154415249"
Ergebnis:
4D99  4F62
OK
; Hex-Form liefert 2 Treffer (kein Selbsttreffer); Form mit Anführungszeichen 3 (Eingabepuffer-Treffer).

S aaaa — Scan (Binär-Echtzeitmonitor)

Zeigt in Echtzeit die 4 Bytes ab Adresse aaaa als 8-Bit-Binärwerte an. Dieselbe Zeile wird kontinuierlich aktualisiert (kein Scrollen): ATAMON liest und zeigt dieselben 4 Bytes in einer Schleife an, um das Verhalten von Hardware-Registern in Echtzeit zu beobachten.

S allein (ohne Argument) → Fehler ? — Adresse ist erforderlich.

Der Befehl gibt die Kontrolle nicht zurück — BREAK (oder SYSTEM RESET) drücken zum Anhalten.

Hinweis: ATAMON besitzt keinen Einzelschrittmodus (Single-Step). Um ein Programm schrittweise zu debuggen, muss man manuell BRK-Befehle an den gewünschten Stellen im Code einfügen.

Beispiel mit fester Adresse:

xxxxxxxxxx

Eingabe:
S 4000

Ergebnis (eine einzige Zeile aktualisiert sich in einer Schleife):
10101001 01000000 10001101 00000111
; Die 4 Bytes an $4000–$4003 werden kontinuierlich angezeigt und aktualisiert
; BREAK drücken, um zum Prompt zurückzukehren

Beispiel mit einem Hardware-Register in Echtzeit:

xxxxxxxxxx

Eingabe:
S 0014 ; RTCLOK ($0014–$0017) überwachen — Atari-Uhr, 60× pro Sekunde inkrementiert

Ergebnis (Zeile ändert sich sichtbar):
00000000 00000001 01001100 00000000
00000000 00000001 01001101 00000000
; Das Byte bei $0016 wird kontinuierlich inkrementiert — Beweis, dass der Atari läuft
; BREAK drücken zum Anhalten

Besonders nützlich zum Überwachen von Hardware-Registern (POKEY, GTIA, ANTIC, RTCLOK-Uhr), die sich in Echtzeit ändern, oder um die Entwicklung einer Variable während der Programmausführung zu beobachten.

C aaaa,bbbbbbbb — Code (Binärbytes in Speicher schreiben)

Schreibt Bytes ab aaaa. Jedes Byte = 8 Binärziffern (0 oder 1), durch Kommas getrennt.

C allein → ?

Hinweis: Dieser Befehl ist in der Original-V1.3 fehlerhaft — er schreibt $2C (Komma) statt die Binärargumente zu interpretieren und liefert ?. Die folgenden Beispiele beschreiben das Verhalten der gepatchten Version (Atamon - D7 - DXG 5724-Patched Atarinside.atr). Siehe Korrektur des C-Befehls-Fehlers.

xxxxxxxxxx

Eingabe:
C 6000,10110001 ; Schreibt $B1 (10110001 binär) an Adresse $6000

Ergebnis:
; (keine Anzeige — der Atari-Cursor erscheint wieder)

; Überprüfung:

Eingabe:
M 6000
Ergebnis:
:6000  B1 xx xx xx xx xx xx xx  [...]
; → $B1 wurde korrekt nach $6000 geschrieben (BREAK drücken, um das Scrollen zu stoppen)

Beispiel mit mehreren Bytes:

xxxxxxxxxx

Eingabe:
C 6000,01001100,00000000,01100000 ; Schreibt $4C, $00, $60 ab $6000 (= JMP $6000 in Maschinensprache)

P [E|T] — Printer (Druckerverwaltung)

Steuert den Druckerkanal (IOCB 6, Gerät P1:).

• P allein: Kanal schließen → zeigt AUS an

• P E: Echo-Modus öffnen → zeigt EIN an (alle Ausgaben werden auch gedruckt)

• P T: Datenübertragung zum Drucker (nicht getestet)

xxxxxxxxxx

Eingabe:
P
Ergebnis: P    AUS

Eingabe:
P E
Ergebnis: EIN
; Echo-Betrieb ist aktiviert (EIN = „ein" = „on" auf Deutsch)
; Alle ATAMON-Ausgaben werden auch gedruckt

Eingabe:
P ; (zum Deaktivieren des Echos)
Ergebnis: P    AUS

Hinweis: Dieser Befehl ist nützlich, wenn ein Drucker an Ihren Atari angeschlossen ist. Ohne Drucker verursacht P E einen I/O-Fehler.

R — Registers (Register anzeigen)

Zeigt den aktuellen Zustand aller gesicherten CPU-Register an. Der Befehl zeigt nur an, ohne Register zu ändern.

Zum Ändern der Register Befehl ; verwenden oder direkt in $4F3C–$4F42 schreiben.

xxxxxxxxxx

Eingabe:
R
Ergebnis:
*R
  PC  SP AC XR YR NV\BDIZC
; 4000 FD 00 00 00 00110000

X — eXit (Beenden)

Kehrt über JMP DOSVEC ($000A) zum Atari-DOS zurück.

xxxxxxxxxx

Eingabe:
X ; ATAMON beendet — der Atari-DOS-Bildschirm erscheint wieder

Z nn,cc[,aaaa,llll] — IOCB (CIO-Kanal-Operation)

Führt eine OS-E/A-Operation über das CIO-System (Central I/O) aus.

Das CIO-System kurz erklärt

xxxxxxxxxx
Ihr Programm
      | (über IOCB)
CIO -- Central I/O         <- einziger Einsprungpunkt
      | (über ZIOCB)
Gerätetreiber
      | (über DCB)
SIO -- Serial I/O

Das CIO bietet einen einzigen Einsprungpunkt ($E456) für alle Geräte: ob Sie auf den Bildschirm schreiben, die Tastatur lesen oder auf eine Diskette zugreifen — es ist immer dieselbe OS-Routine, die Sie aufrufen. Der Gerätetreiber (eine spezifische Routine in ROM oder RAM) erledigt die eigentliche Arbeit.

ROM-residiente Treiber (immer verfügbar, beim Booten automatisch geladen):

Nicht-residiente Treiber (beim Booten durch DOS oder Peripherie-ROM geladen):

Diese nicht-residenten Treiber werden beim Booten in die Handler-Tabelle ($031A) eingetragen, sobald das entsprechende Gerät angeschlossen und eingeschaltet ist. Fehlt das Gerät, wird der Treiber nicht geladen, und jeder Zugriffsversuch auf D:, R: oder T: via CIO gibt einen Fehler „unknown device" zurück.

IOCB-Kanäle

Um mit dem CIO zu kommunizieren, verwendet man einen IOCB (Input/Output Control Block): einen 16-Byte-Speicherbereich, der die gewünschte Operation beschreibt (welches Gerät, welcher Befehl, welcher Puffer…).

Das OS stellt 8 Kanäle bereit (IOCB #0 bis #7), die jedem Gerät zugewiesen werden können:

Die Kanäle 1 bis 5 haben keine feste Zuweisung — das ist so gewollt. Die nicht-residenten Treiber (D:, R:, T:) öffnen sich nicht auf einem festen Kanal: das Programm wählt frei, auf welchem Kanal es jedes Gerät öffnet. Wenn BASIC aktiv ist, sollte man Kanäle 6 und 7 nicht anfassen.

Ein Datensatz ist eine Bytefolge, die mit dem ATASCII-Zeilenende-Zeichen $9B abgeschlossen wird. GET RECORD liest bis zum nächsten $9B; PUT RECORD schreibt und fügt $9B am Ende hinzu.

Z-Syntax

nn = Kanal-Offset (2 Hex-Stellen), cc = CIO-Befehl (2 Hex-Stellen).

• aaaa = Adresse des Datenpuffers (optional, nur für GET/PUT BYTES und OPEN)

• llll = Länge der Daten in Bytes (optional, nur für GET/PUT BYTES)

Z allein oder Z nn allein → ? — cc ist erforderlich.

Z kopiert den aktuellen IOCB des Kanals, ersetzt die angegebenen Felder (Befehl, Adresse, Länge), ruft CIO auf und schreibt den geänderten IOCB zurück. Es wird kein Ergebnis angezeigt — die Wirkung ist die Ausgabe der CIO-Operation selbst.

Beispiel — Text auf dem Bildschirm ausgeben via PUT RECORD auf Kanal 0 (immer auf Bildschirmeditor E: geöffnet):

xxxxxxxxxx
; Schritt 1: "ATARI!!" + $9B (ATASCII-Zeilenende) nach $6000 schreiben

Eingabe:
: 6000 41 54 41 52 49 21 21 9B

; Schritt 2: 8 Bytes von $6000 via CIO auf den Bildschirm senden

Eingabe:
Z 00,09,6000,0008

Ergebnis:
ATARI!!
; → der Text wird direkt angezeigt, dann erscheint der Atari-Cursor wieder

Um den Rohinhalt eines IOCB zu inspizieren, M 0340 (Kanal 0) oder M 0350 (Kanal 1) verwenden.

I aaaa,DdatenD — Input String (Text in Speicher schreiben)

Schreibt Text oder gemischte Daten direkt in den Speicher ab Adresse aaaa.

D ist ein frei wählbares Trennzeichen (z. B. ", ', /…), das Anfang und Ende der Daten markiert. Alles zwischen den zwei Trennzeichen wird Byte für Byte in den Speicher geschrieben.

⚠ Wichtig: KEIN Leerzeichen zwischen Komma und Trennzeichen. Das Komma trennt die Adresse von den Daten — das Trennzeichen muss unmittelbar auf das Komma folgen, ohne Leerzeichen. Ein Leerzeichen zwischen , und dem Trennzeichen ergibt ?.

Innerhalb der Daten werden zwei Formate akzeptiert:

• Hexadezimale Bytes: 2-stellige Paare (z. B. 9B, 4F)

• Zeichenkette: ein Paar einfacher Anführungszeichen '...' umschließt eine vollständige Zeichenkette — 'HALLO' nicht 'H'A'L'L'O'

xxxxxxxxxx
; ⚠ Unbedingt $6000+ verwenden — ATAMON belegt $4000–$52B1

Eingabe:
I 6000,"'HALLO'9B" ; KEIN Leerzeichen zwischen , und " — Trennzeichen muss direkt nach dem Komma folgen
; 'HALLO' = vollständige ATASCII-Zeichenkette, 9B = Zeilenende-Byte

; Überprüfung:

Eingabe:
M 6000
Ergebnis:
:6000  48 41 4C 4C 4F 9B xx xx  [HALLO.xx]
; (BREAK zum Anhalten)

Eingabe:
I 6010,/FF 00 4C 00 40/ ; 5 Hex-Bytes, durch Leerzeichen getrennt

; Überprüfung:

Eingabe:
M 6010
Ergebnis:
:6010  FF 00 4C 00 40 xx xx xx  [..L.@...]
; (BREAK zum Anhalten)

Eingabe:
I 6020,"'ATARI'9B" ; ATASCII-Zeichenkette + Zeilenende-Byte

; Überprüfung:

Eingabe:
M 6020
Ergebnis:
:6020  41 54 41 52 49 9B xx xx  [ATARI.xx]
; (BREAK zum Anhalten)

Dieser Befehl ist besonders nützlich zum Schreiben von Fehlermeldungen, ATASCII-Zeichenketten oder Code-Patches direkt in den Speicher.

# — Dezimal → Hexadezimal-Umrechnung

Interpretiert das Argument als Dezimalwert und zeigt das Hexadezimaläquivalent an.

Nützlich, wenn man eine Adresse oder einen Wert in Dezimal kennt und wissen möchte, was er in Hexadezimal entspricht, bevor man ihn in einem anderen Befehl verwendet.

xxxxxxxxxx

Eingabe:
# 4000

Ergebnis:
# 4000 = 0FA0
; 4000 in Dezimal = $0FA0 in Hexadezimal

Eingabe:
# 255

Ergebnis:
# 255 = 00FF
; 255 in Dezimal = $FF in Hexadezimal

$ — Hexadezimal → Dezimal-Umrechnung

Interpretiert das Argument als Hexadezimalwert und zeigt das Dezimaläquivalent an (Komplement von #).

xxxxxxxxxx

Eingabe:
$ 1638

Ergebnis:
$ 1638 = 5688
; $1638 in Hexadezimal = 5688 in Dezimal

Eingabe:
$ 00FF

Ergebnis:
$ 00FF = 0255
; $FF = 255 in Dezimal — ATAMON erfordert genau 4 Hex-Stellen
; $ FF (nur 2 Stellen) → Fehler ?

Wichtig: $ erfordert genau 4 Hexadezimalstellen. $ 00FF verwenden, nicht $ FF.

% — Binäreingabe

Ermöglicht die Eingabe eines Werts als 8 Bits (0 und 1) und zeigt ihn hexadezimal an.

Nützlich für die direkte Arbeit mit Prozessor-Flags oder jedem Register, dessen Wert bitweise kontrolliert werden soll — lesbarer als ein Hex-Byte für diese Art der Manipulation.

xxxxxxxxxx

Eingabe:
% 11001000

Ergebnis:
C8
; $C8 = Hexadezimalwert von 11001000 binär (= 200 in Dezimal)

Eingabe:
% 00110000

Ergebnis:
30
; $30 = Flags I+B gesetzt (typischer Zustand beim Starten)

; aaaa BB BB BB BB XXXXXXXX — Set (Alle Register auf einmal laden)

Lädt alle CPU-Register in einer einzigen Befehlszeile. Syntax: ; PCHL SP AC XR YR XXXXXXXX

• PCHL : 4 Hex-Stellen = PC-Ausführungsadresse (z. B. 5000)

• SP : Stapelzeiger (z. B. FD)

• AC : Akkumulator

• XR : X-Register

• YR : Y-Register

• XXXXXXXX : 8 Binärbits = Flags P in der Reihenfolge N V \ B D I Z C

Nützlich, um einen genauen Ausführungskontext in einer einzigen Operation wiederherzustellen, zum Beispiel um das Debuggen eines Programms genau in dem Zustand fortzusetzen, in dem es angehalten wurde.

Bedeutung der 8 Flag-Bits (von links nach rechts):

Beispiel: 00110100 = Bits N=0, V=0, \=1, B=1, D=0, I=1, Z=0, C=0 — typischer Zustand beim Starten (I=1 : Interrupts deaktiviert).

xxxxxxxxxx

Eingabe:
; 5000 FD 00 00 00 00110100

Ergebnis: ATAMON überschreibt die eingegebene Zeile mit dem `;`-Format, ohne eine neue Zeile hinzuzufügen.
Der angezeigte Inhalt ist identisch mit der Eingabe — der Befehl erscheint lautlos.
; 5000 FD 00 00 00 00110100

Überprüfung:

Eingabe:
R
Ergebnis:
*R
  PC  SP AC XR YR NV\BDIZC
; 5000 FD 00 00 00 00110100

! aaaa — Binary (Hexadezimal → Binär-Umrechnung)

Wandelt den Hexadezimalwert aaaa in 16-Bit-Binär um und zeigt ihn an. Es wird kein Speicher gelesen — das Argument selbst wird konvertiert.

Format: ! aaaa = bbbbbbbb bbbbbbbb (höherwertiges Byte dann niederwertiges Byte).

Nützlich zur Visualisierung der einzelnen Bits eines Werts (zuvor gelesenes Hardware-Register, Ergebnis einer Operation, Flag-Wert…).

xxxxxxxxxx

Eingabe:
! 4000 ; Konvertiert $4000 in Binär: $40=01000000, $00=00000000

Ergebnis:
! 4000 = 01000000 00000000

Eingabe:
! 00FF ; Konvertiert $00FF: $00=00000000, $FF=11111111

Ergebnis:
! 00FF = 00000000 11111111

Eingabe:
! D01F ; Konvertiert den Wert $D01F (Adresse des CONSOL-Registers) — um die Bits eines Hardware-Registers zu sehen, zuerst seinen Wert mit M lesen, dann mit ! konvertieren

Ergebnis:
! D01F = 11010000 00011111

* OP aaaa,bbbb — Arithmetic (Rechenwerk)

Arithmetische oder logische Operation mit zwei 16-Bit-Werten. Ergebnis: RRRR C=b.

Operatoren: + - A (UND) O (ODER) E (XOR).

* + 4000 allein → ? — beide Operanden erforderlich.

xxxxxxxxxx

Eingabe:
* + 4000,0100

Ergebnis:
* + 4000,0100 = 4100  C= 0
; $4000 + $0100 = $4100, Übertrag = 0

Eingabe:
* - 5000,0200

Ergebnis:
* - 5000,0200 = 4E00  C= 1
; $5000 - $0200 = $4E00, C=1 = kein Borgeübertrag (positives Ergebnis)
Beim 6502 ist der Übertrag bei der Subtraktion im Vergleich zur Addition invertiert: C=1 = Ergebnis ≥ 0 (kein Borgeübertrag), C=0 = negatives Ergebnis (Überlauf). Das ist das Gegenteil von dem, was man intuitiv erwartet.

Eingabe:
* A FF00,0FF0

Ergebnis:
* A FF00,0FF0 = 0F00
; $FF00 AND $0FF0 = $0F00

Eingabe:
* O 4000,0001

Ergebnis:
* O 4000,0001 = 4001
; $4000 OR $0001 = $4001

Nützlich zur Berechnung von Adressen, Offsets oder zur Überprüfung von Speicherbereichen ohne den Monitor zu verlassen.

: aaaa bb bb bb bb bb bb bb bb — Enter (Bytes in Speicher eingeben)

Schreibt 8 Hex-Bytes ab aaaa, zeigt die Zeile an, schlägt nächste Adresse vor. BREAK zum Beenden.

: aaaa allein → keine Ausgabe.

xxxxxxxxxx

Eingabe:
: 6000 A9 FF 8D 00 D0 4C 00 40

Ergebnis:
:6000  A9 FF 8D 00 D0 4C 00 40  )  PL @
:6008
; ATAMON schlägt die nächste Adresse vor — man kann 8 neue Bytes eingeben
; oder BREAK drücken, um zum Prompt zurückzukehren

Um einen großen Bereich einzugeben, Zeile für Zeile fortfahren: jede EINGABE-Taste rückt um 8 Bytes vor. Um weniger als 8 Bytes einzugeben, den Befehl I verwenden.

Einschränkung: : prüft jeden geschriebenen Byte durch erneutes Lesen der Adresse. Diese Prüfung schlägt bei Hardwareregistern (POKEY $D200–$D20F, GTIA $D000–$D01F, ANTIC $D400–$D40F, PIA $D300–$D30F) fehl, da Lese- und Schreibadressen auf unterschiedliche physische Register zeigen. Um Hardware zu beschreiben, Maschinencode in den RAM schreiben und mit G ausführen.

, aaaa bb [bb ...] — Enter with Disassembly (Eingabe mit Disassemblierung)

Schreibt Hex-Bytes ab aaaa und zeigt die entsprechende 6502-Disassemblierung. Beliebige Byte-Anzahl pro Zeile. BREAK zum Beenden.

xxxxxxxxxx

Eingabe:
, 6000 A9 00

Ergebnis:
, 6000 A9 00           LDA #$00
, 6002
; ATAMON zeigt die Bytes + die Disassemblierung an, dann schlägt er die Fortsetzung mit `,` vor
; Weiter durch Eingabe der nächsten Bytes, BREAK zum Zurückkehren zum Prompt

Eingabe:
, 6002 4C 00 60

Ergebnis:
, 6002 4C 00 60        JMP $6000
, 6005
; 3 Bytes geschrieben — JMP $6000 (Sprung nach $6000)
; Fortfahren oder BREAK drücken

Ideal für die Eingabe von Assembler-Code und sofortige Überprüfung, dass die Opcodes korrekt sind.

7. Interne Variablen (Zeropage)

8. Wichtigste Unterprogramme

9. Nutzung des Atari-Betriebssystems

ATAMON verwendet folgende OS-Dienste:

Verwendete IOCBs:

• IOCB 0 ($0340): Hauptkanal zu E: (Editor/Bildschirm) für alle Benutzereingaben/-ausgaben.

• Das IOCB wird dynamisch durch SET_FNAME / SET_BUFADDR / DO_CIO konfiguriert.

DCB-Struktur für Diskettenzugriffe ($0300–$030B):

• $0300 DDEVIC = $31 ('1') — Diskettengerät D1:

• $0301 DUNIT = 1

• $0302 DCOMND = SIO-Befehl ('R'=$52 Lesen, 'W'=$57 Schreiben)

• $0303 DSTATS = Richtung ($40 = Lesen, $80 = Schreiben)

• $0304–$0305 DBUFLO/HI = Pufferadresse

• $030A–$030B DAUX1/2 = Sektornummer

10. Interne Datentabellen

Banner und Registerformat ($4F44)

Die im Speicher gespeicherte Zeichenkette lautet:

xxxxxxxxxx
*** ATAMON V1.3 - (c) 1983 by ATARI  ***E:P1:   PC  SP AC XR YR NV\BDIZC<$9B>

ATAMON zeigt auf den Beginn des Teils PC SP AC XR YR NV\BDIZC (bei $4F71), um die Spaltenüberschrift anzuzeigen — der Teil E:P1: ist in der Binärzeichenkette enthalten, wird aber nicht separat angezeigt. Die Bildschirmausgabe (40 Spalten) ergibt:

xxxxxxxxxx
*** ATAMON V1.3 - (c) 1983 by ATARI  ***
     PC  SP AC XR YR NV\BDIZC
; 4000 FD 00 00 00 00110000

Hex-Ziffern + Befehlstabelle ($4F8D)

xxxxxxxxxx
$4F8D  "0123456789ABCDEF"   <- Hex-Ziffern (Index 0–15)
$4F9D  "RX;GM:EWFVTH#$%!I*PCSD,LZ"  <- Befehlszeichen

Dispatch-Tabelle ($4FC8)

Bytepaare (Adresse - 1) (lo, hi) für jeden Befehls-Handler. Die Verteilung nutzt den RTS-Trick: Die Handler-Adresse minus 1 wird auf den Stapel gelegt (hi zuerst, dann lo), dann wird RTS ausgeführt. Der 6502 liest die Adresse, erhöht sie um 1 und springt zum Handler. Das vermeidet eine JMP-Tabelle und spart einige Bytes.

Beispiel: Befehl 'G' (5. Zeichen in $4F9D) → ATAMON liest die 2 Bytes bei $4FC8 + (Index × 2), legt sie in umgekehrter Reihenfolge auf den Stapel und macht RTS zum Handler.

Interne Disassembler-Tabellen ($4FF9+)

ATAMON besitzt einen eigenen Mini-Disassembler (Befehl D). Er verwendet zwei interne Tabellen:

1. 6502-Mnemoniken: 3-Buchstaben-kodierte Einträge (56 offizielle Mnemoniken)

2. Adressierungsmodi: Tabelle der Operandengrößen und -formate für jeden Opcode

Diese Tabellen decken nur die offiziellen 6502-Opcodes ab. Illegale Opcodes werden vom ATAMON-Disassembler nicht erkannt und würden fehlerhaft angezeigt.

→ Siehe Anhang B am Ende des Dokuments für die vollständige Liste der 56 erkannten Mnemoniken.

Hinweis: Im ATAMON-Binärcode enthalten die Adressen $4F43–$52B1 Daten (Textzeichenketten, Zeichentabellen, Vektoren). Ein linearer Disassembler interpretiert diese Bytes als Befehle — von denen viele in die Kategorie undokumentierter 6502-Opcodes fallen ($02 *KIL, $03 *SLO, $3A *NOP usw.). Dies sind Fehlalarme aufgrund der Datennatur, keine absichtliche Verwendung illegaler Opcodes im ATAMON-Code.

11. ATAMON benutzen

Start

Wählen Sie im Atari-DOS L. BINARY LOAD, dann D:ATAMON eingeben. ATAMON zeigt sein Banner (*C + Register) an, und der Atari-Cursor wartet auf den ersten Befehl.

Sondertasten

Hinweis: ATAMON stützt sich auf CIO (Bildschirmeditor E:) für das Einlesen von Befehlen. Die Standardbearbeitungsfunktionen des Atari-Editors (Cursorbewegung, Löschen) sind verfügbar, bevor mit RETURN bestätigt wird.

Typische Startanzeige

xxxxxxxxxx
*** ATAMON V1.3 - (c) 1983 by ATARI  ***
*C
  PC  SP AC XR YR NV\BDIZC
; 4000 FD 00 00 00 00110000

Beispielsitzung

xxxxxxxxxx
; Speicher ab $4000 anzeigen
M 4000

; 8 Bytes bei $6000 ändern (freier Bereich)
: 6000 A9 FF 8D 00 D0 4C 00 60

; Disassemblieren ab $4000
D 4000

; Programm bei $4000 starten
G 4000

; $4000-$40FF nach $6000 kopieren, dann prüfen
T 4000,40FF,6000
V 4000,40FF,6000

; $6000-$60FF mit NOPs ($EA) füllen — freier Bereich außerhalb ATAMON
F 6000,60FF,EA

; Diskettensektor 1 in Puffer ($0680) lesen
E 0001

; Puffer auf Sektor 1 zurückschreiben
W 0001

; $4000 + $0100 berechnen
* + 4000,0100

; Zu DOS beenden
X

12. Historische Anmerkungen

ATAMON (Abkürzung für ATAri MONitor) ist ein Maschinensprachemonitor, der 1983 von ATARI in Deutschland vermarktet wurde — im selben Jahr wie die Markteinführung des Atari 800XL.

Die DXG-5724-Diskette enthält außerdem:

• DOS.SYS: das Atari-DOS-2.x-Diskettenbetriebssystem (39 Sektoren)

• DUP.SYS: das Diskettenverwaltungsprogramm (42 Sektoren)

Diese drei Programme bilden eine vollständige Diskette: DOS + Dienstprogramme + Debugging-Monitor.

Die Analyse der Diskette ergab keinen besonderen Kopierschutz. Die Analyse aller 720 Sektoren bestätigte das Fehlen von Phantomsektoren (phantom_count = 0 für alle Sektoren), absichtlich fehlerhafter CRCs oder anderer Kopierschutzmechanismen. Die Original-ATAMON-Diskette war nicht kopiergeschützt.

13. Technische Hinweise zur Disassemblierung

Bekannte illegale 6502-Opcodes

JMP-Indirect-Fehler

Der 6502 hat einen Hardware-Fehler: JMP (addr) liest das höherwertige Byte falsch, wenn addr auf $FF endet. Beispiel: JMP ($10FF) liest $10FF (lo) und $1000 (hi) statt $1100. In ATAMON enden die beiden vorhandenen JMP (ind) ($47BF JMP (DOSVEC) und $47E4 JMP ($4F41)) nicht auf $FF — kein Fehler in diesem Programm. Hinweis: JMP ($4F41) ist der Ausführungssprung zur gesicherten Adresse (PCL bei $4F41, PCH bei $4F42).

Anhang A — Zeropage-Glossar ($00–$FF)

Die Zeropage ist der erste 256-Byte-Block des RAM ($00 bis $FF). Auf dem 6502 ist sie aus zwei Gründen besonders:

• Befehle, die auf sie zugreifen, verwenden nur ein Adressbyte statt zwei → sie sind kürzer und schneller.

• Der 6502 kann sie als Bereich „zusätzlicher Register" nutzen: 16-Bit-Zeiger, Zähler, temporäre Variablen.

Das Atari-Betriebssystem und ATAMON machen davon intensiv Gebrauch. Hier die wichtigsten Stellen:

Atari-OS-Variablen (vom System reserviert)

Von ATAMON verwendete Variablen

Diese Adressen sind von ATAMON während des Betriebs reserviert. Eine Änderung mit : oder , kann den Monitor stören.

Tipp: Verwenden Sie M 0000 00FF, um die gesamte Zeropage anzuzeigen und zu beobachten, wie sich diese Werte bei verschiedenen Operationen ändern.

Inoffizielle Dokumentation, rekonstruiert durch Binäranalyse der XEX-Datei und 6502-Disassemblierung. Referenzen: De Re Atari (APX 90009), Atari 8-bit FAQ, Altirra 4.40 Quellcode, AtariWiki — 6502 Assembly Code, Unused Opcodes, OS-ROM-Quellliste, Atari Custom Display Lists (Atarimania), Display Lists Simplified (Atari magazines), ANTIC registers (xmission.com/~trevin), Mapping the Atari.

Anhang B — Die 56 offiziellen 6502-Mnemoniken

Der eingebaute Disassembler von ATAMON (Befehl D) erkennt genau diese 56 Befehle.

Laden / Speichern

Registertransfers

Stapel

Arithmetik

Inkrementieren / Dekrementieren

Logische Operationen

Schieben und Rotieren

Vergleiche

Bedingte Sprünge

Alle Sprünge sind relativ (vorzeichenbehafteter Offset von −128 bis +127 Bytes ab dem nächsten Befehl).

Sprünge und Aufrufe

Software-Interrupt

Flag-Operationen

Sonstiges

Anhang C — Illegale / undokumentierte 6502-Opcodes

Diese Opcodes existieren nicht in der offiziellen MOS-Technology-6502-Spezifikation. Sie entstehen durch unbeabsichtigte Kombinationen der internen Prozessorlogik. Ihr Verhalten wird vom ATAMON-Disassembler (Befehl D) wiedergegeben, der sie mit einem vorangestellten * anzeigt.

Warnung: Die meisten sind je nach Prozessorrevision oder Versorgungsspannung instabil. Im Produktionscode vermeiden; nützlich zur Analyse alter Programme, die sie nutzen.

Fatale Befehle

Kombinierte Lese-Modifizier-Schreib-Befehle

Diese Opcodes führen zwei Operationen in einer aus: eine Änderung im Speicher dann eine logische/arithmetische Operation mit A.

Kombiniertes Laden / Speichern

Akkumulator-Befehle

Instabile Speicherbefehle (abhängig von addr_hi)

Illegale NOPs (mehrere Bytes, kein Effekt)

Diese Opcodes verhalten sich wie NOP (tun nichts Sichtbares), verbrauchen aber 2 oder 3 Bytes.

Anhang D — Bekannte Atari-Bezeichner

Symbolische Adressen, die der ATAMON-Disassembler (Befehl D) erkennt. Sie erscheinen im Disassemblat anstelle der reinen Hexadresse.

Zeropage — OS-Variablen ($00–$FF)

Seite 2 — Interrupt-Vektoren ($0200–$02FF)

Seite 3 — SIO-DCB ($0300–$035F)

Hardwareregister — GTIA ($D000)

Hardwareregister — POKEY ($D200)

Hardwareregister — PIA ($D300)

Hardwareregister — ANTIC ($D400)

OS-ROM-Einsprungpunkte ($E4xx)

Math-ROM ($D8xx)

Anhang E — Atari 800XL Hardwareregister — Kurzübersicht

Übersicht der Hardware-Register der vier Custom-Chips des Atari 800XL, mit ihrer typischen Verwendung in der Programmierung.

GTIA — Graphic Television Interface Adaptor ($D000–$D01F)

POKEY — Potentiometer and Keyboard ($D200–$D20F)