ATAMON V1.3

Table des matières

• ATAMON V1.3

  • Table des matières

  • Avant-propos

  • Qu'est-ce qu'ATAMON ?

• Documentation technique

  • Moniteur langage machine pour Atari 800XL

  • 1. Présentation générale

  • 2. Installation en mémoire

  • 3. Mécanisme de démarrage

    • Sauvegarde des registres ($401C)

  • 4. Boucle principale de commande

    • Invite de commande et affichage des registres

  • 5. Comment charger votre programme dans ATAMON

    • Voici le plan d'action de l'agent double

    • Placer des points d'arrêt dans ton programme

  • 6. Liste des commandes

    • Conventions de syntaxe

    • G [aaaa] — Go (Exécuter)

    • M aaaa — Memory (Afficher mémoire)

    • E ssss — E (Lire un secteur disque)

    • D aaaa[,bbbb] — Disassemble (Désassembler)

    • L aaaa,bbbb,xx — Locate Non-Matching (Localiser les octets différents)

    • W ssss — Write (Écrire un secteur disque)

    • V aaaa,bbbb,cccc — Verify (Comparer mémoire)

    • F aaaa,bbbb,bb — Fill (Remplir)

    • T aaaa,bbbb,cccc — Transfer (Transférer mémoire)

    • H aaaa,bbbb,DrecherchéD — Hunt (Rechercher en mémoire)

    • S aaaa — Scan (Moniteur binaire en temps réel)

    • C aaaa,bbbbbbbb — Code (Écrire des octets binaires en mémoire)

    • P [E|T] — Printer (Gestion imprimante)

    • R — Registers (Afficher les registres)

    • X — eXit (Quitter)

    • Z nn,cc[,aaaa,llll] — IOCB (Manipulation d'un canal CIO)

      • Le système CIO en bref

      • Les canaux IOCB

      • Syntaxe Z

    • I aaaa,DdonnéesD — Input string (Saisir du texte en mémoire)

    • # — Conversion décimal → hexadécimal

    • $ — Conversion hexadécimal → décimal

    • % — Entrée binaire

    • ; aaaa BB BB BB BB XXXXXXXX — Set (Charger tous les registres d'un coup)

    • ! aaaa — Binary (Conversion hexadécimal → binaire)

    • * OP aaaa,bbbb — Arithmetic (Calculateur)

    • : aaaa bb bb bb bb bb bb bb bb — Enter (Saisir des octets en mémoire)

    • , aaaa bb [bb ...] — Enter with Disassembly (Saisir avec désassemblage)

  • 7. Variables internes (page zéro)

  • 8. Sous-routines principales

  • 9. Utilisation du système Atari

  • 10. Tables de données internes

    • Bannière et format registres ($4F44)

    • Table des chiffres hex + commandes ($4F8D)

    • Table de dispatch ($4FC8)

    • Tables du désassembleur intégré ($4FF9+)

  • 11. Comment utiliser ATAMON

    • Lancement

    • Touches spéciales

    • Affichage typique au démarrage

    • Exemples de session

  • 12. Notes historiques

  • 13. Notes techniques sur le désassemblage

    • Opcodes illégaux connus du 6502

    • Bug JMP indirect

  • Annexe A — Glossaire de la page zéro ($00–$FF)

    • Variables OS Atari (réservées par le système)

    • Variables utilisées par ATAMON

  • Annexe B — Les 56 mnémoniques officiels du 6502

    • Chargement / stockage

    • Transferts entre registres

    • Pile

    • Arithmétique

    • Incrémentation / décrémentation

    • Opérations logiques

    • Décalages et rotations

    • Comparaisons

    • Branchements conditionnels

    • Sauts et appels

    • Interruption logicielle

    • Gestion des flags

    • Divers

  • Annexe C — Opcodes illégaux / non documentés du 6502

    • Instructions fatales

    • Instructions lecture-modification-écriture combinées

    • Chargement / stockage combinés

    • Instructions sur l'accumulateur

    • Instructions mémoire instables (dépendent de addr_hi)

    • NOP illégaux (multi-octets, sans effet)

  • Annexe D — Étiquettes Atari connues

    • Page zéro — Variables OS ($00–$FF)

    • Page 2 — Vecteurs d'interruption ($0200–$02FF)

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

    • Registres matériels — GTIA ($D000)

    • Registres matériels — POKEY ($D200)

    • Registres matériels — PIA ($D300)

    • Registres matériels — ANTIC ($D400)

    • Points d'entrée OS ROM ($E4xx)

    • Math ROM ($D8xx)

  • Annexe E — Registres hardware Atari 800XL — référence rapide

    • 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)

  • Correction du bug de la commande C (patch)

    • Le bug

    • La correction

    • Appliquer le patch

  • Sources documentaires

    • Processeur 6502

    • Documentation Atari 800XL

    • AtariWiki

    • Format de disque .PRO

    • Émulateur utilisé pour les tests

Avant-propos

La documentation d'ATAMON (ATAri MONitor) reste introuvable depuis plus de 40 ans.

Ce que vous lisez est une documentation non officielle, le fruit d'heures de travail, d'essais, de décompilation et de rédaction à partir du code désassemblé d'ATAMON.

J'espère que vous l'apprécierez ;-)

Atarinside — Mars 2026

Le programme se trouve ici : https://www.atarinside.com/blog/index.php/atarinside-items/atamon/

Qu'est-ce qu'ATAMON ?

Vous venez de charger ATAMON, le moniteur langage machine d'ATARI. Mais à quoi sert un moniteur, exactement ?

Votre Atari 800XL fonctionne grâce à un processeur, le 6502, qui exécute des milliers d'instructions par seconde. Ces instructions — appelées "langage machine" — sont stockées en mémoire sous forme de nombres. ATAMON est l'outil qui vous permet de voir, modifier et exécuter directement ces instructions, sans passer par un langage intermédiaire comme le BASIC.

Concrètement, ATAMON vous permet de :

• Regarder dans la mémoire : affichez n'importe quelle zone de la RAM de votre Atari, octet par octet, pour voir ce qu'elle contient.

• Modifier la mémoire : changez des valeurs directement, corrigez un bug dans un programme, ou personnalisez un jeu à votre guise.

• Désassembler un programme : ATAMON traduit le langage machine brut en mnémoniques lisibles (comme LDA, JMP, STA…), ce qui vous permet de comprendre comment un programme fonctionne.

• Exécuter et déboguer : lancez un programme et reprenez la main à chaque point d'arrêt BRK, en observant l'état du processeur — indispensable pour trouver un bug.

• Sauvegarder des secteurs : lisez et réécrivez directement des secteurs du disque (via les commandes E et W).

• Calculer : effectuez des additions, soustractions, ET logique, OU logique directement en hexadécimal ou en binaire.

Pour qui ? ATAMON s'adresse aux programmeurs, aux passionnés qui souhaitent comprendre le fonctionnement interne de leur Atari, ou à quiconque veut explorer et modifier des programmes en langage machine. Aucun matériel supplémentaire n'est nécessaire : ATAMON fonctionne entièrement depuis votre Atari, avec votre lecteur de disquette habituel.

Comment démarrer ? Depuis le menu du DOS Atari, sélectionnez L. BINARY LOAD puis tapez D:ATAMON et appuyez sur Entrée. Le programme s'installe en mémoire à partir de l'adresse $4000, affiche sa bannière, et le curseur Atari indique qu'il est prêt à recevoir une commande. Toutes les commandes sont à une seule lettre — rapide et efficace.

Documentation technique

Moniteur langage machine pour Atari 800XL

Fichier source : Atamon - D7 - DXG 5724.PRO → ATAMON Identification : *** ATAMON V1.3 - (c) 1983 by ATARI *** Type : Moniteur / débogueur en langage machine 6502 Taille : 4 404 octets Format : XEX Atari (segments multiples) Adresse de chargement : $4000 Adresse d'exécution (RUNAD) : $4000 Langage source : Assembleur 6502 Éditeur : Atari Deutschland GmbH (Atari Allemagne) — ATAMON est un produit Atari Allemagne, identifié par le numéro de catalogue DXG 5724 Auteur : Non identifié — le binaire ne contient aucun nom de programmeur, uniquement (c) 1983 by ATARI Outil d'assemblage probable : Atari Macro Assembler ou MAC/65 (OSS) — déduit de la structure des segments XEX de 256 octets (252 octets de code + 4 octets d'en-tête), format de sortie caractéristique des assembleurs Atari natifs de 1983

1. Présentation générale

ATAMON est un moniteur langage machine professionnel développé par ATARI en 1983. Il permet à un programmeur de :

• Examiner et modifier la mémoire vive (RAM)

• Afficher et modifier les registres du 6502 (adresse d'exécution, pointeur de pile, accumulateur, X, Y, flags)

• Désassembler le code 6502 directement en mémoire

• Exécuter du code et reprendre la main sur chaque point d'arrêt BRK

• Lire et réécrire des secteurs disque

• Vérifier et transférer des zones mémoire

• Effectuer des calculs hexadécimaux

Il appartient à la famille des moniteurs langage machine qui ont accompagné les ordinateurs 8 bits de l'époque sur de nombreuses plateformes.

2. Installation en mémoire

xxxxxxxxxx
Adresse    Contenu
---------  --------------------------------
$4000      Point d'entrée principal (RUNAD)
$4000-$52B1 Code et données ATAMON
$4F3C-$4F42 Zone de sauvegarde des registres CPU
$4E3C      Buffer d'entrée clavier (ligne de commande)
$4F44      Bannière ASCII + format affichage registres
$4F8D      Table des chiffres hex + caractères de commande
$4F9D      Table de dispatch des commandes
$4FC8      Table des adresses des handlers (vecteurs)
$4FF9+     Tables internes du désassembleur 6502

Occupation mémoire : environ 4,5 Ko de $4000 à $52B1. ATAMON déclare aussi MEMLO = $5300 pour protéger son code.

3. Mécanisme de démarrage

L'entrée à $4000 utilise une technique classique : le vecteur BRK ($0206-$0207).

xxxxxxxxxx
$4000  LDA #$40         ; Installe le handler BRK
$4002  STA $0207        ; VBREAK hi = $40
$4005  LDA #$0B
$4007  STA $0206        ; VBREAK lo = $0B  →  handler à $400B
$400A  BRK              ; Déclenche volontairement BRK
; === Le 6502 pousse (adresse courante + 2) et les flags sur la pile, saute via $0206 ===
$400B  LDA #$40         ; Reconfigure VBREAK pour usage futur
$400D  STA $0207
$4010  LDA #$1A
$4012  STA $0206        ; Nouveau VBREAK = $401A
$4015  LDA #$43         ; 'C' = indicateur "entrée par démarrage"
$4017  JMP $401C        ; → Sauvegarder l'état CPU

Pourquoi cette technique ? Le BRK pousse automatiquement l'adresse de la prochaine instruction (adresse courante + 2) et le registre d'état sur la pile. ATAMON récupère ensuite ces valeurs pour construire un tableau complet de l'état du processeur au moment de l'entrée dans le moniteur.

Sauvegarde des registres ($401C)

xxxxxxxxxx
$401C  STA $E4          ; Sauvegarde l'indicateur d'entrée (passé par l'appelant)
$401E  PLA              ; Récupère A (poussé par le handler OS avant BRK)
$401F  STA $4F3D        ; Sauvegarde A
$4022  STY $4F3F        ; Sauvegarde Y
$4025  STX $4F3E        ; Sauvegarde X
$4028  PLA              ; Récupère P (flags, depuis la pile BRK)
$4029  STA $4F40        ; Sauvegarde P
$402C  CLC
$402F  PLA              ; Récupère PCL (adresse basse, depuis la pile BRK)
$4030  ADC #$FF         ; Soustrait 1 (16 bits : BRK pousse addr+1, on revient à l'adresse réelle)
$4032  STA $4F41        ; Sauvegarde PCL ajusté
$4035  PLA              ; Récupère PCH (adresse haute, depuis la pile BRK)
$4036  ADC #$FF         ; Continue la soustraction 16 bits avec la retenue
$4038  STA $4F42        ; Sauvegarde PCH ajusté
$403B  TSX
$403C  STX $4F3C        ; Sauvegarde SP
$403F  LDX #$FD
$4041  TXS              ; Réinitialise la pile à $FD

Note sur le mécanisme d'entrée : Le handler OS Atari (ROM IRQ) pousse le registre A via PHA avant d'appeler le vecteur VBREAK. C'est pourquoi SAVE_CPU effectue 4 PLA successifs (A, P, PCL, PCH) alors que l'instruction BRK n'en pousse que 3 (P, PCL, PCH).

Zone de sauvegarde des registres ($4F3C-$4F42) :

xxxxxxxxxx
$4F3C  SP  Pointeur de pile
$4F3D  A   Accumulateur
$4F3E  X   Registre X
$4F3F  Y   Registre Y
$4F40  P   Registre d'état (flags NV\BDIZC)
$4F41  PCL Adresse basse de la prochaine instruction (ajustée -1)
$4F42  PCH Adresse haute de la prochaine instruction

Ce layout est confirmé par le handler G (Go) : LDA $4F3D restaure A, LDA $4F40; PHA; PLP restaure P, JMP ($4F41) saute à l'adresse $4F42:$4F41.

4. Boucle principale de commande

Après initialisation, ATAMON affiche sa bannière et entre dans la boucle de commande ($4064) :

xxxxxxxxxx
1. Réinitialise la pile à $FD
2. Efface le buffer d'entrée ($4E3C ← $9B)
3. Ouvre le canal E: (éditeur écran) via CIO
4. Lit une ligne via CIO (IOCB 0)
5. Cherche le premier caractère non-espace
6. Recherche ce caractère dans la table $4F9D
7. Si trouvé → charge l'adresse du handler depuis $4FC8/$4FC9
8. Exécute le handler via un RTS indirect (push hi-1 / lo-1, RTS)
9. Retourne à l'étape 1

Invite de commande et affichage des registres

ATAMON n'affiche pas de prompt explicite : l'invite de saisie est le curseur de l'éditeur écran Atari (bloc clignotant en vidéo inverse), géré automatiquement par l'OS. Quand ce curseur est visible, ATAMON attend une commande.

Les en-têtes *R, *B, *C sont des préfixes d'affichage ATAMON, pas le prompt. L'astérisque * (code $2A) est émis par ATAMON avant d'afficher les registres, suivi d'une lettre indiquant le contexte d'entrée :

• *C — entrée par démarrage ou G

• *R — commande R

• *B — retour sur BREAK (interruption d'un programme)

Exemple d'affichage des registres (commande R ou après un BRK) :

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

La ligne de valeurs commence toujours par ;. Signification de chaque champ :

Cette ligne se met à jour automatiquement après chaque retour de programme (suite à un BRK ou G), pour refléter l'état réel du processeur à cet instant.

5. Comment charger votre programme dans ATAMON

L'Atari stocke l'adresse de lancement automatique du dernier programme chargé dans une case mémoire bien précise, à l'adresse $02E0 (le vecteur système appelé RUNAD).

Si tu charges ton jeu, son adresse de démarrage va se loger en $02E0. Mais si tu charges ATAMON juste derrière, l'adresse de démarrage d'ATAMON ($4000) va écraser celle de ton jeu !

Pour contourner ça et utiliser ATAMON en tant que détective, on va inverser l'ordre de chargement en s'aidant d'une autre option du menu DOS (l'option M).

Voici le plan d'action de l'agent double

Étape 1 : Installer le moniteur en "sous-marin"

1. Depuis le menu DOS, utilise L pour charger ATAMON.

2. ATAMON s'affiche à l'écran. Tape la commande X (eXit).

3. Tu reviens au menu DOS, mais ATAMON reste caché bien au chaud dans la mémoire (à partir de $4000).

Étape 2 : Charger ton jeu silencieusement

1. De retour dans le DOS, utilise à nouveau L pour charger ton programme en ajoutant /N (sans espace après le nom de fichier) — exemple : MYPROG.BIN/N.

2. Le jeu se charge en mémoire et l'OS inscrit son adresse de départ en $02E0. Comme on a mis /N, le DOS ne saute pas à cette adresse, n'exécute pas le programme chargé et te garde dans le menu.

Étape 3 : Réveiller ATAMON

1. Dans le menu DOS, choisis l'option M (Run at address).

2. Tape 4000 (l'adresse où dort ATAMON) et appuie sur Entrée.

3. La bannière d'ATAMON s'affiche — te revoilà dans le moniteur !

Étape 4 : Lire l'adresse magique

1. Dans l'invite d'ATAMON, affiche la mémoire à l'adresse $02E0 en tapant :

xxxxxxxxxx
Entrée :
M 02E0

2. Appuie tout de suite sur BREAK pour arrêter le défilement.

3. Regarde les deux premiers octets de la ligne affichée.

Attention — Little Endian : l'Atari stocke les adresses « à l'envers » (octet de poids faible en premier, puis poids fort).

• Si ATAMON affiche :02E0 00 50 ..., l'adresse de ton programme est $5000.

• S'il affiche :02E0 00 2A ..., l'adresse est $2A00.

Et voilà ! Tu n'as plus qu'à utiliser la commande G suivie de l'adresse découverte (ex : G 5000) pour lancer ton programme, sachant qu'ATAMON est prêt à intercepter n'importe quel plantage ou point d'arrêt (BRK).

Placer des points d'arrêt dans ton programme

Attention : ATAMON ne possède pas de fonction d'interruption asynchrone garantie.

La seule méthode infaillible pour rendre la main à ATAMON au milieu d'un programme, c'est d'y insérer volontairement un point d'arrêt logiciel :

1. Remplace temporairement un octet de ton programme par l'instruction BRK (code hexadécimal $00).

2. Lorsque le processeur exécutera ce $00, il déclenchera une interruption logicielle.

3. ATAMON a détourné le vecteur d'interruption du système (VBREAK en $0206–$0207) lors de son chargement.

4. Le processeur sautera directement dans les bras d'ATAMON, qui sauvegardera tous tes registres (A, X, Y, PC…) et affichera son invite avec *B pour signaler qu'il a intercepté un BRK.

En résumé : si ton programme est une boucle infinie sans instruction BRK, la touche BREAK ne te sauvera pas (sauf si ton code fait appel aux routines clavier de l'OS). Tu seras bon pour un Reset ! Pense toujours à placer tes $00 stratégiquement avant de lancer ton code avec G.

6. Liste des commandes

La table des commandes est stockée à partir de $4F9D. Les commandes s'entrent en majuscules. Quand une commande prend plusieurs arguments, ils sont séparés par des virgules (pas d'espace entre les arguments). Un espace est accepté avant le premier argument.

Conventions de syntaxe

• aaaa = adresse 16 bits en hexadécimal (ex : 4000)

• bb = octet 8 bits en hexadécimal (ex : FF)

• [...] = argument optionnel

G [aaaa] — Go (Exécuter)

Lance l'exécution du programme à l'adresse aaaa. Sans argument : repart depuis l'adresse d'exécution sauvegardée (registre PC). Restaure tous les registres CPU sauvegardés avant de faire JMP aaaa.

Attention : G aaaa saute directement à l'adresse indiquée. Si cette adresse ne contient pas un programme valide (par exemple de la RAM non initialisée avec des zéros), le 6502 exécutera n'importe quoi et le système se bloquera ou redémarrera. G seul (sans adresse) est sûr : il repart depuis le PC sauvegardé au moment du dernier BRK.

Première utilisation après le démarrage : au démarrage, le PC sauvegardé est $400B (point d'entrée de l'initialisation ATAMON). Taper G seul réexécute donc le démarrage d'ATAMON : la bannière s'affiche à nouveau, suivie de *C et de l'état des registres.

Exemples :

xxxxxxxxxx

Entrée :
G ; Au premier lancement, réexécute l'init ATAMON :

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

; Après un BRK dans votre propre programme, reprend l'exécution depuis le PC sauvegardé

Entrée :
G 4000 ; Lance l'exécution à $4000 — ATAMON disparaît le temps que votre programme tourne.
; Il ne reprend la main que si le programme exécute un BRK (point d'arrêt).

M aaaa — Memory (Afficher mémoire)

Affiche le contenu de la mémoire à partir de l'adresse aaaa, 8 octets par ligne en hexadécimal. ATAMON défile indéfiniment — appuyer sur BREAK pour arrêter.

Le format d'affichage commence chaque ligne par : suivi de l'adresse, des 8 octets en hexadécimal, puis une colonne ATASCII à droite (chaque octet affiché comme son caractère ATASCII correspondant).

Exemple :

xxxxxxxxxx

Entrée :
M 4000

Résultat (défile sans fin — appuyer BREAK pour arrêter) :
: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¨¹@
; ... (continue automatiquement)

E ssss[,aaaa[,nn]] — E (Lire un secteur disque)

Lit le secteur disque numéro ssss (en hexadécimal) depuis le lecteur D1: et le charge dans le buffer mémoire à l'adresse aaaa (défaut : $0680).

Arguments optionnels :

• aaaa : adresse du buffer de destination (défaut : $0680)

• nn : nombre de secteurs consécutifs à lire (défaut : 01) — le buffer avance de $80 (128 octets) par secteur

Attention : ssss est un numéro de secteur, pas une adresse mémoire. Une disquette Atari simple densité (720 secteurs) a des numéros de $0001 à $02D0. Dépasser ce nombre provoque une erreur I/O.

Pour voir le contenu du secteur chargé : taper M 0680 — ATAMON affiche les octets à partir de $0680 en défilant (appuyer BREAK pour arrêter après avoir vu les 128 premiers octets du secteur).

Exemple :

xxxxxxxxxx

Entrée :
E 0168 ; Lit le secteur 360 ($0168) = secteur VTOC du DOS 2.x

Résultat :
OK
; ATAMON affiche "OK" — le secteur est maintenant en $0680

Entrée :
E 0001,0700 ; Lit le secteur 1 dans $0700 (buffer custom)

Résultat :
OK

Entrée :
E 0001,0700,02 ; Lit les secteurs 1 et 2 → $0700 (sect. 1) et $0780 (sect. 2)

Résultat :
OK

Entrée :
E 0001 ; Lit le secteur de boot (secteur 1)

Résultat en cas d'erreur (secteur inexistant) :
I/O ERROR #138

D aaaa[,bbbb] — Disassemble (Désassembler)

Désassemble le code 6502 à partir de l'adresse aaaa et affiche les mnémoniques. Utilise les tables internes à $4FF9 qui contiennent les 56 mnémoniques 6502 et les informations de décodage des modes d'adressage.

Important : l'adresse de fin bbbb est syntaxiquement acceptée mais ignorée — ATAMON désassemble indéfiniment sans s'arrêter, continue après $FFFF et repart à $0000. Appuyer sur BREAK pour arrêter.

Exemple :

xxxxxxxxxx

Entrée :
D 4000,400C

Résultat (défile sans fin — appuyer BREAK pour arrêter) :
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
; ... (continue automatiquement)

Chaque ligne indique : l'adresse, les octets bruts en mémoire, puis l'instruction désassemblée.

L aaaa,bbbb,xx — Locate Non-Matching (Localiser les octets différents)

Parcourt la zone mémoire de aaaa à bbbb et affiche les adresses où l'octet trouvé est différent de xx.

En pratique : L identifie les octets qui "ne correspondent pas" à une valeur de référence. Utile pour repérer rapidement les différences entre deux zones après une copie, ou trouver des octets modifiés dans un programme.

L seul (sans argument) → erreur ? — les trois arguments sont obligatoires.

Note : ATAMON ne possède pas de commande de chargement de fichier. Les programmes doivent être chargés depuis le DOS Atari (option L. BINARY LOAD) avant de lancer ATAMON.

Exemple :

xxxxxxxxxx

Entrée :
F 6000,60FF,EA ; (remplit $6000–$60FF de $EA)

Entrée :
: 6000 A9 FF 8D 00 D0 4C 00 40 ; (modifie quelques octets en $6000)

Entrée :
L 6000,60FF,EA ; Parcourt $6000–$60FF et affiche les adresses où l'octet ≠ $EA

Résultat (7 adresses par ligne — appuyer BREAK pour arrêter, affiche *B) :
6000  6001  6002  6003  6004  6005  6006
6007
*B
; → les adresses $6000–$6007 contiennent des octets ≠ $EA
; Les adresses où l'octet vaut exactement $EA ne sont PAS affichées

W ssss[,aaaa[,nn]] — Write (Écrire un secteur disque)

Écrit le contenu du buffer mémoire à l'adresse aaaa (défaut : $0680) sur le secteur disque numéro ssss (en hexadécimal).

Arguments optionnels : mêmes que E — buffer source et nombre de secteurs consécutifs.

Attention : écrase directement le secteur sur la disquette — opération irréversible. ssss est un numéro de secteur en hexadécimal (1 à $02D0 = 720 pour une disquette simple densité).

E et W fonctionnent en tandem : E pour lire un secteur, modifier avec M ou :, puis W pour réécrire.

Exemple :

xxxxxxxxxx

Entrée :
E 0001 ; 1. Lit le secteur 1 dans le buffer ($0680)

; (modifier éventuellement le buffer avec : 0680 A9 FF ...)

Entrée :
W 0001 ; 2. Réécrit le buffer sur le secteur 1

Résultat : OK
; En cas d'erreur : I/O ERROR #xxx

V aaaa,bbbb,cccc — Verify (Comparer mémoire)

Compare la zone mémoire aaaa→bbbb avec la zone commençant à cccc (comparaison mémoire à mémoire). Signale les adresses où les octets diffèrent. Aucune modification n'est effectuée.

Utile pour vérifier qu'une copie (effectuée avec T) est conforme à l'original, ou comparer deux versions d'un programme.

Exemple :

xxxxxxxxxx

Entrée :
T 6000,600F,6100 ; (copie $6000-$600F vers $6100)

Entrée :
V 6000,600F,6100 ; Compare $6000-$600F avec $6100-$610F

Résultat si tout correspond :
OK

; Pour voir des différences, modifier un octet avant la comparaison :

Entrée :
: 6100 FF FF 00 00 00 00 00 00

Entrée :
V 6000,600F,6100 ; $6100 et $6101 ont été modifiés → ATAMON signale $6000 et $6001

Résultat (7 adresses par ligne) :
6000  6001
; Seules les adresses SOURCE où les octets diffèrent sont affichées — pas les valeurs.

Note : si la zone de destination n'est pas initialisée (RAM quelconque), presque toutes les adresses de la plage apparaîtront dans le résultat.

F aaaa,bbbb,bb — Fill (Remplir)

Remplit la zone mémoire aaaa→bbbb avec l'octet bb.

Zone sûre : ATAMON occupe $4000–$52B1. Utiliser des adresses au-delà de $5300 (ex : $6000+).

Exemple :

xxxxxxxxxx

Entrée :
F 6000,60FF,EA

Résultat :
OK
; ATAMON affiche "OK" puis revient au prompt
; $6000 à $60FF (256 octets) contient maintenant $EA (opcode NOP)
; Utile pour "nettoyer" une zone ou y écrire des NOP avant de patcher du code

; Pour vérifier que les NOP ont bien été écrits :

Entrée :
M 6000

Résultat :
:6000  EA EA EA EA EA EA EA EA  nnnnnnn
:6008  EA EA EA EA EA EA EA EA  nnnnnnn
; ... (appuyer BREAK pour arrêter)
; La colonne droite = ATASCII de $EA (caractère 'n' en ATASCII inverse)

T aaaa,bbbb,cccc — Transfer (Transférer mémoire)

Copie le bloc mémoire de aaaa à bbbb vers la destination cccc (mémoire vers mémoire). Effectue ensuite une vérification octet par octet et signale les différences.

Zones qui se chevauchent : si la source et la destination se recoupent en mémoire, une copie naïve du début vers la fin écraserait des octets source non encore lus. ATAMON évite ce problème : si la destination est avant la source, il copie de gauche à droite (premier octet en premier) ; si la destination est après la source (chevauchement par la droite), il copie de droite à gauche (dernier octet en premier). Le résultat est toujours correct quelle que soit la configuration.

Zone sûre : ATAMON occupe $4000–$52B1. Pour les tests, utiliser une zone au-delà de $5300 (par exemple $6000–$7FFF, RAM libre).

Exemples :

xxxxxxxxxx

Entrée :
T 6000,60FF,6100 ; Copie $6000-$60FF vers $6100

Résultat : OK

Entrée :
T 6000,6008,6004 ; Cas de chevauchement : ATAMON copie à rebours pour éviter d'écraser la source
; Résultat : (idem — silencieux si succès)

H aaaa,bbbb,DrecherchéD — Hunt (Rechercher en mémoire)

Parcourt la zone mémoire de aaaa à bbbb et cherche la séquence d'octets DrecherchéD. Affiche les adresses où la séquence est trouvée, puis OK.

D est un caractère délimiteur choisi librement (ex : ", /, #…) qui encadre la séquence. Les données à l'intérieur s'expriment comme pour la commande I : octets hex deux par deux (sans espaces), ou chaîne entre guillemets simples '...'.

H est une commande de recherche uniquement. La syntaxe de remplacement DsearchD,DreplaceD ne fonctionne pas : après la recherche, ATAMON retourne au prompt et interprète tout ce qui suit comme une nouvelle commande.

H seul, H aaaa ou H aaaa,bbbb (sans troisième argument) → erreur ? — les trois arguments minimum sont obligatoires.

Les données à l'intérieur du délimiteur suivent les mêmes règles que la commande I : octets hex deux par deux, ou chaîne entre '...'. Sans les guillemets simples internes, les lettres sont interprétées comme des chiffres hex — AT = A (hex valide) + T (hex invalide) → résultat corrompu.

Exemple :

xxxxxxxxxx

Entrée :
H 4000,52B0,"'ATARI'" ; Cherche la chaîne "ATARI" dans le code ATAMON
; Note : 'ATARI' (guillemets simples internes) = mode chaîne ATASCII

Résultat :
4D99  4E4A  4F62
OK
; La chaîne ATARI apparaît 3 fois dans ATAMON (dans les tables et la bannière)
; ATAMON affiche les adresses trouvées, puis "OK" à la fin

Entrée :
H 4000,52B0,"4154415249" ; Même recherche en hex : A=$41 T=$54 A=$41 R=$52 I=$49
; (les espaces entre paires hex sont ignorés — "4154415249" et "41 54 41 52 49" sont équivalents)

Résultat :
4D99  4F62
OK
; Seulement 2 résultats — car la commande elle-même ne contient pas le motif dans le buffer.

; Pourquoi 'ATARI' trouve 3 résultats mais "4154415249" seulement 2 ?
; Le buffer d'entrée ATAMON est à $4E3C. Quand on tape H 4000,52B0,"'ATARI'",
; le mot "ATARI" est présent dans le buffer vers $4E4A → H se trouve lui-même !
; La version hex n'a pas ce problème (la commande ne contient pas les octets ATARI en clair).
; Les 2 occurrences réelles dans le binaire ATAMON : $4D99 et $4F62.

S aaaa — Scan (Moniteur binaire en temps réel)

Affiche en temps réel les 4 octets à partir de l'adresse aaaa sous forme de 8 bits binaires. La même ligne se rafraîchit continuellement (pas de défilement) : ATAMON relit et réaffiche les mêmes 4 octets en boucle, permettant de surveiller en direct l'évolution de registres matériels.

S seul (sans argument) → erreur ? — l'adresse est obligatoire.

La commande ne rend pas la main — appuyer sur BREAK (ou SYSTEM RESET) pour arrêter.

Note : ATAMON ne possède pas de commande de pas-à-pas (single-step). Pour déboguer un programme pas à pas, il faut insérer manuellement des instructions BRK aux points souhaités dans le code.

Exemple avec une adresse fixe :

xxxxxxxxxx

Entrée :
S 4000

Résultat (une seule ligne se rafraîchit en boucle) :
10101001 01000000 10001101 00000111
; Les 4 octets à $4000-$4003 s'affichent et se mettent à jour en continu
; Appuyer BREAK pour revenir au prompt

Exemple avec un registre matériel en temps réel :

xxxxxxxxxx

Entrée :
S 0014 ; Surveille RTCLOK ($0014-$0017) — horloge Atari incrémentée 60× par seconde

Résultat (la ligne change visible à l'œil nu) :
00000000 00000001 01001100 00000000
00000000 00000001 01001101 00000000
; L'octet en $0016 s'incrémente continuellement — preuve que l'Atari tourne
; Appuyer BREAK pour arrêter

Particulièrement utile pour surveiller des registres matériels (POKEY, GTIA, ANTIC, horloge RTCLOK) qui changent en temps réel, ou observer l'évolution d'une variable durant l'exécution d'un programme.

C aaaa,bbbbbbbb — Code (Écrire des octets binaires en mémoire)

Écrit un ou plusieurs octets en mémoire à partir de l'adresse aaaa. Chaque octet est saisi en binaire (8 chiffres 0 ou 1), séparés par des virgules.

C seul (sans argument) → erreur ?

Note : Cette commande est buggée dans la version originale V1.3 — elle interprète la virgule comme $2C au lieu d'analyser les arguments binaires, et retourne ?. Les exemples ci-dessous décrivent le comportement de la version patchée uniquement (Atamon - D7 - DXG 5724-Patched Atarinside.atr). Voir la section Correction du bug de la commande C en fin de document.

Exemple :

xxxxxxxxxx

Entrée :
C 6000,10110001 ; Écrit $B1 (10110001 en binaire) à l'adresse $6000

Résultat :
; (aucun affichage — le curseur Atari réapparaît)

; Vérification :

Entrée :
M 6000
Résultat :
:6000  B1 xx xx xx xx xx xx xx  [...]
; → $B1 bien écrit en $6000 (BREAK pour arrêter le défilement)

Exemple avec plusieurs octets :

xxxxxxxxxx

Entrée :
C 6000,01001100,00000000,01100000 ; Écrit $4C, $00, $60 à partir de $6000 (= JMP $6000 en langage machine)

P [E|T] — Printer (Gestion imprimante)

Contrôle le canal imprimante (IOCB 6, device P1:).

• P seul : ferme le canal imprimante et affiche son état (AUS = désactivé en allemand)

• P E : ouvre le canal imprimante P1: en mode écho (tout l'affichage est dupliqué sur l'imprimante) → affiche EIN (= activé en allemand)

• P T : transfert de données vers l'imprimante (non testé)

Exemple :

xxxxxxxxxx

Entrée :
P

Résultat :
P    AUS
; Le canal imprimante est actuellement fermé (AUS = "aus" = "off" en allemand)

Entrée :
P E

Résultat :
EIN
; L'écho imprimante est activé (EIN = "ein" = "on" en allemand)
; Tout l'affichage ATAMON sera aussi imprimé

Entrée :
P ; (pour désactiver l'écho)
P    AUS

Note : cette commande est utile si vous disposez d'une imprimante connectée à votre Atari. Sans imprimante, P E provoquera une erreur I/O.

R — Registers (Afficher les registres)

Affiche l'état actuel de tous les registres CPU sauvegardés. La commande affiche uniquement, sans modifier aucun registre.

Pour modifier les registres, utiliser la commande ; (chargement complet) ou modifier directement en mémoire aux adresses $4F3C–$4F42.

Exemple :

xxxxxxxxxx

Entrée :
R

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

X — eXit (Quitter)

Retourne au DOS Atari via JMP DOSVEC ($000A).

Exemple :

xxxxxxxxxx

Entrée :
X ; ATAMON quitte — l'écran du DOS Atari réapparaît

Z nn,cc[,aaaa,llll] — IOCB (Manipulation d'un canal CIO)

Exécute une opération d'entrée/sortie de l'OS Atari sur un canal donné, en passant directement par le système CIO (Central I/O).

Le système CIO en bref

L'OS Atari organise toutes les entrées/sorties en trois niveaux :

xxxxxxxxxx
Votre programme
      ↓ (via IOCB)
CIO — Central I/O         ← point d'entrée unique pour tous les périphériques
      ↓ (via ZIOCB)
Handlers de périphériques  ← routines spécifiques à chaque appareil
      ↓ (via DCB)
SIO — Serial I/O          ← bus série (disquette, imprimante SIO…)

Le CIO offre un point d'entrée unique ($E456) pour tous les appareils : que vous écriviez sur l'écran, lisiez le clavier ou accédiez à une disquette, c'est toujours la même routine OS que vous appelez. C'est le handler de périphérique (une routine spécifique en ROM ou en RAM) qui s'occupe du vrai travail.

Handlers résidents en ROM (toujours disponibles, chargés automatiquement au démarrage) :

Handlers non-résidents (chargés en RAM au démarrage par DOS ou la ROM d'un périphérique SIO) :

Ces handlers non-résidents s'ajoutent à la table des handlers ($031A) au démarrage dès que le périphérique correspondant est connecté et allumé. Si le périphérique est absent, le handler n'est pas chargé et toute tentative d'accès à D:, R: ou T: via CIO retourne une erreur "unknown device".

Les canaux IOCB

Pour communiquer avec le CIO, on utilise un IOCB (Input/Output Control Block) : une zone mémoire de 16 octets qui décrit l'opération souhaitée (quel périphérique, quelle commande, quel buffer…).

L'OS dispose de 8 canaux (IOCB #0 à #7), chacun pouvant être affecté à n'importe quel périphérique :

Les canaux 1 à 5 n'ont pas d'affectation fixe — c'est voulu. Les handlers non-résidents (D:, R:, T:) ne s'ouvrent pas sur un canal dédié : c'est le programme qui choisit librement sur quel canal il ouvre chaque périphérique. K: n'a jamais besoin d'un canal IOCB car il est utilisé en interne par E:. Par exemple, un programme peut ouvrir D:FICHIER.DAT sur le canal 1, et R1: (port série) sur le canal 2, simultanément. Si BASIC est actif, éviter de toucher aux canaux 6 et 7.

Un record est une suite d'octets terminée par le caractère de fin de ligne ATASCII $9B. GET RECORD lit jusqu'au prochain $9B ; PUT RECORD écrit et ajoute $9B en fin.

Syntaxe Z

• nn — offset du canal en hex sur 2 chiffres : 00=canal 0, 10=canal 1… 70=canal 7

• cc — commande CIO en hex sur 2 chiffres

• aaaa — adresse du buffer en mémoire (4 chiffres, optionnel selon la commande)

• llll — longueur du buffer en octets (4 chiffres, optionnel)

Z seul, Z 00 seul → erreur ? — la commande cc est obligatoire.

Z copie l'IOCB actuel du canal, remplace les champs fournis (commande, adresse, longueur), appelle CIO, puis réécrit l'IOCB modifié. Aucun résultat n'est affiché — l'effet est la sortie de l'opération CIO elle-même.

Exemple — afficher du texte à l'écran via PUT RECORD sur le canal 0 (toujours ouvert sur l'éditeur écran E:) :

xxxxxxxxxx
; Étape 1 : écrire "ATARI!!" + $9B (fin de ligne ATASCII) en $6000

Entrée :
: 6000 41 54 41 52 49 21 21 9B

; Étape 2 : envoyer 8 octets de $6000 vers l'écran via CIO

Entrée :
Z 00,09,6000,0008

Résultat :
ATARI!!
; → le texte s'affiche directement, puis le curseur Atari réapparaît

Pour inspecter le contenu brut d'un IOCB, utiliser M 0340 (canal 0) ou M 0350 (canal 1).

I aaaa,DdonnéesD — Input string (Saisir du texte en mémoire)

Saisit du texte ou des données mixtes directement en mémoire à partir de l'adresse aaaa.

D est un caractère délimiteur choisi librement (ex : ", ', /…) qui marque le début et la fin des données. Tout ce qui se trouve entre les deux délimiteurs est écrit octet par octet en mémoire.

⚠ Important : PAS d'espace entre la virgule et le délimiteur. La virgule sépare l'adresse des données — le délimiteur doit immédiatement suivre la virgule, sans espace. Un espace entre , et le délimiteur produit ?.

À l'intérieur des données, deux formats sont acceptés :

• Octets hexadécimaux : deux chiffres hex (ex : 9B, 4F)

• Chaîne littérale : une paire de guillemets simples '...' encadre une chaîne entière — tous les caractères entre les deux ' sont convertis en ATASCII (ex : 'BONJOUR' = 7 octets $42 $4F $4E $4A $4F $55 $52)

Attention : 'B'O'N'J'O'U'R' est incorrect — après le premier 'B', la lettre O est interprétée comme début d'un octet hex à deux chiffres, ce qui échoue immédiatement avec ?. Il faut impérativement mettre toute la chaîne entre une seule paire de guillemets simples : 'BONJOUR'.

Exemples :

xxxxxxxxxx
; ⚠ Utiliser impérativement $6000+ — ATAMON occupe $4000–$52B1

Entrée :
I 6000,"'BONJOUR'9B" ; PAS d'espace entre , et " — le délimiteur doit être collé à la virgule
; 'BONJOUR' = chaîne ATASCII complète, 9B = octet fin de ligne

; Vérification :

Entrée :
M 6000
Résultat :
:6000  42 4F 4E 4A 4F 55 52 9B  [BONJOUR.]
; (BREAK pour arrêter)

Entrée :
I 6010,/FF 00 4C 00 40/ ; 5 octets hex séparés par des espaces

; Vérification :

Entrée :
M 6010
Résultat :
:6010  FF 00 4C 00 40 xx xx xx  [..L.@...]
; (BREAK pour arrêter)

Entrée :
I 6020,"'ATARI'9B" ; Chaîne ATASCII + octet fin de ligne

; Vérification :

Entrée :
M 6020
Résultat :
:6020  41 54 41 52 49 9B xx xx  [ATARI.xx]
; (BREAK pour arrêter)

Cette commande est particulièrement utile pour écrire des messages d'erreur, des chaînes ATASCII ou des patches de code directement dans la mémoire.

# — Conversion décimal → hexadécimal

Interprète l'argument comme une valeur décimale et affiche son équivalent en hexadécimal.

Utile quand on connaît une adresse ou une valeur en décimal et qu'on veut savoir ce qu'elle vaut en hexadécimal avant de l'utiliser dans une autre commande.

Exemples :

xxxxxxxxxx

Entrée :
# 4000

Résultat :
# 4000 = 0FA0
; 4000 en décimal = $0FA0 en hexadécimal

Entrée :
# 255

Résultat :
# 255 = 00FF
; 255 en décimal = $FF en hexadécimal

$ — Conversion hexadécimal → décimal

Interprète l'argument comme une valeur hexadécimale et affiche son équivalent en décimal (complément de #).

Exemples :

xxxxxxxxxx

Entrée :
$ 1638

Résultat :
$ 1638 = 5688
; $1638 en hexadécimal = 5688 en décimal

Entrée :
$ 00FF

Résultat :
$ 00FF = 0255
; $FF = 255 en décimal — ATAMON exige exactement 4 chiffres hex
; $ FF (seulement 2 chiffres) → erreur ?

Important : $ exige exactement 4 chiffres hexadécimaux. Utiliser $ 00FF et non $ FF.

% — Entrée binaire

Permet de saisir une valeur sous forme de 8 bits (0 et 1) et l'affiche en hexadécimal.

Utile pour travailler directement avec les flags du processeur ou tout registre dont on veut contrôler bit à bit la valeur — plus lisible qu'un octet hex pour ce type de manipulation.

Exemples :

xxxxxxxxxx

Entrée :
% 11001000

Résultat :
C8
; $C8 = valeur hexadécimale de 11001000 binaire (= 200 en décimal)

Entrée :
% 00110000

Résultat :
30
; $30 = flags I+B actifs (état typique au démarrage)

; aaaa BB BB BB BB XXXXXXXX — Set (Charger tous les registres d'un coup)

Charge l'intégralité des registres CPU en une seule ligne de commande. Syntaxe : ; PCHL SP AC XR YR XXXXXXXX

• PCHL : 4 chiffres hex = adresse d'exécution PC (ex : 5000)

• SP : pointeur de pile (ex : FD)

• AC : accumulateur

• XR : registre X

• YR : registre Y

• XXXXXXXX : 8 bits binaires = flags P dans l'ordre N V \ B D I Z C

  Signification de chaque bit (de gauche à droite) :

  Bit	Lettre	Nom	Vaut 1 quand…
  7	N	Negative	Le dernier résultat avait le bit 7 à 1 (valeur "négative" en signé)
  6	V	oVerflow	Débordement en arithmétique signée (ex : 127 + 1 → −128)
  5	\	(non utilisé)	Toujours à 1 — ce bit n'est pas un flag réel du 6502
  4	B	Break	L'entrée dans le moniteur s'est faite via une instruction BRK
  3	D	Decimal	Mode BCD activé — non fonctionnel sur le 6502 de l'Atari
  2	I	Interrupt disable	Les interruptions IRQ sont masquées (ignorées)
  1	Z	Zero	Le dernier résultat était exactement zéro
  0	C	Carry	Retenue d'une addition, ou emprunt inverse d'une soustraction

  Exemple : 00110100 = bits N=0, V=0, \=1, B=1, D=0, I=1, Z=0, C=0 — état typique au démarrage (I=1 : interruptions désactivées).

Utile pour restaurer un contexte d'exécution précis en une seule opération, par exemple pour reprendre le débogage d'un programme exactement dans l'état où il s'est arrêté.

Exemple :

xxxxxxxxxx

Entrée :
; 5000 FD 00 00 00 00110100

Résultat : ATAMON réécrit la ligne saisie en place au format `;`, sans ajouter de nouvelle ligne.
Le contenu affiché est identique à la saisie — la commande paraît silencieuse.
; 5000 FD 00 00 00 00110100

; Vérification :

Entrée :
R
Résultat :
*R
  PC  SP AC XR YR NV\BDIZC
; 5000 FD 00 00 00 00110100
; → PC bien à $5000, flags identiques à ceux saisis

! aaaa — Binary (Conversion hexadécimal → binaire)

Convertit la valeur hexadécimale aaaa en binaire sur 16 bits et l'affiche. Il ne lit pas la mémoire — il convertit l'argument lui-même.

Format : ! aaaa = bbbbbbbb bbbbbbbb (octet de poids fort puis octet de poids faible).

Utile pour visualiser les bits individuels d'une valeur (registre matériel lu au préalable, résultat d'une opération, valeur de flag…).

Exemples :

xxxxxxxxxx

Entrée :
! 4000 ; Convertit $4000 en binaire : $40=01000000, $00=00000000

Résultat :
! 4000 = 01000000 00000000

Entrée :
! 00FF ; Convertit $00FF : $00=00000000, $FF=11111111

Résultat :
! 00FF = 00000000 11111111

Entrée :
! D01F ; Convertit la valeur $D01F (adresse du registre CONSOL) — pour voir les bits
; d'un registre matériel, lire d'abord sa valeur avec M, puis convertir avec !

Résultat :
! D01F = 11010000 00011111

* OP aaaa,bbbb — Arithmetic (Calculateur)

Effectue une opération arithmétique ou logique entre deux valeurs 16 bits sur la même ligne de commande. L'opérateur est un symbole : + (addition), - (soustraction), A (AND logique), O (OR logique), E (EOR/XOR).

Les deux opérandes doivent être fournis ensemble, séparés par une virgule. Le résultat s'affiche au format RRRR C=b (résultat 16 bits + bit de retenue).

* + 4000 seul (un seul opérande) → erreur ? — le second opérande après la virgule est obligatoire.

Exemples :

xxxxxxxxxx

Entrée :
* + 4000,0100

Résultat :
* + 4000,0100 = 4100  C= 0
; $4000 + $0100 = $4100, retenue = 0

Entrée :
* - 5000,0200

Résultat :
* - 5000,0200 = 4E00  C= 1
; $5000 - $0200 = $4E00, C=1 = pas d'emprunt (résultat positif)
En 6502, pour la soustraction le carry est inversé par rapport à l'addition : C=1 = résultat ≥ 0 (pas d'emprunt), C=0 = résultat négatif (dépassement). C'est l'opposé de ce qu'on attend intuitivement.

Entrée :
* A FF00,0FF0

Résultat :
* A FF00,0FF0 = 0F00
; $FF00 AND $0FF0 = $0F00

Entrée :
* O 4000,0001

Résultat :
* O 4000,0001 = 4001
; $4000 OR $0001 = $4001

Utile pour calculer des adresses, des offsets ou vérifier des plages mémoire sans sortir du moniteur.

: aaaa bb bb bb bb bb bb bb bb — Enter (Saisir des octets en mémoire)

Écrit 8 octets hexadécimaux en mémoire à partir de l'adresse aaaa, affiche la ligne écrite, puis propose l'adresse suivante pour continuer la saisie. BREAK pour revenir au prompt.

: aaaa seul (sans octets) → ne produit rien.

Exemple :

​x

Entrée :
: 6000 A9 FF 8D 00 D0 4C 00 40

Résultat :
:6000  A9 FF 8D 00 D0 4C 00 40  )  PL @
:6008
; ATAMON propose l'adresse suivante — on peut saisir 8 nouveaux octets
; ou appuyer sur BREAK pour revenir au prompt

Pour saisir une grande zone, continuer ligne par ligne : chaque ENTRÉE avance de 8 octets. Pour saisir moins de 8 octets, utiliser la commande I.

Limitation : : vérifie chaque octet après écriture en relisant l’adresse. Cette vérification échoue sur les registres hardware (POKEY $D200–$D20F, GTIA $D000–$D01F, ANTIC $D400–$D40F, PIA $D300–$D30F) car lecture et écriture correspondent à des registres physiques différents. Pour écrire dans le hardware, placer le code machine en RAM puis l’exécuter avec G.

, aaaa bb [bb ...] — Enter with Disassembly (Saisir avec désassemblage)

Écrit des octets hexadécimaux en mémoire à partir de aaaa et affiche le désassemblage 6502 correspondant. Contrairement à :, le nombre d'octets par ligne est libre (pas limité à 8). Mode interactif continu : après chaque ligne, ATAMON affiche le désassemblage et propose l'adresse suivante. BREAK pour revenir au prompt.

Exemples :

xxxxxxxxxx

Entrée :
, 6000 A9 00

Résultat :
, 6000 A9 00           LDA #$00
, 6002
; ATAMON affiche les octets + le désassemblage, puis propose la suite avec `,`
; Continuer en saisissant les octets suivants, BREAK pour revenir au prompt

Entrée :
, 6002 4C 00 60

Résultat :
, 6002 4C 00 60        JMP $6000
, 6005
; 3 octets écrits — JMP $6000 (saut vers $6000)
; On peut continuer ou appuyer sur BREAK

Idéal pour entrer du code assembleur et vérifier immédiatement que les opcodes sont corrects.

7. Variables internes (page zéro)

8. Sous-routines principales

9. Utilisation du système Atari

ATAMON utilise les services OS suivants :

Structure des IOCBs utilisés :

• IOCB 0 ($0340) : Canal principal vers E: (éditeur/écran) pour toutes les entrées/sorties utilisateur.

• L'IOCB est configuré dynamiquement par les fonctions SET_FNAME / SET_BUFADDR / DO_CIO.

Structure DCB pour les accès disque ($0300-$030B) :

• $0300 DDEVIC = $31 ('1') — périphérique disque D1:

• $0301 DUNIT = 1

• $0302 DCOMND = commande SIO ('R'=$52 lecture, 'W'=$57 écriture)

• $0303 DSTATS = direction ($40 = lecture, $80 = écriture)

• $0304-$0305 DBUFLO/HI = adresse du buffer

• $030A-$030B DAUX1/2 = numéro de secteur

10. Tables de données internes

Bannière et format registres ($4F44)

La chaîne stockée en mémoire est :

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

ATAMON pointe sur le début de la partie PC SP AC XR YR NV\BDIZC (à $4F71) pour afficher l'en-tête de colonnes — la partie E:P1: est dans la chaîne binaire mais n'est pas affichée séparément. L'affichage à l'écran (40 colonnes) donne :

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

Table des chiffres hex + commandes ($4F8D)

xxxxxxxxxx
$4F8D  "0123456789ABCDEF"   ← chiffres hexa (index 0-15)
$4F9D  "RX;GM:EWFVTH#$%!I*PCSD,LZ"  ← caractères de commande

Table de dispatch ($4FC8)

Paires d'octets (adresse - 1) (lo, hi) pour chaque handler de commande. Le dispatch utilise le trick RTS : l'adresse du handler moins 1 est poussée sur la pile (hi d'abord, puis lo), puis RTS est exécuté. Le 6502 récupère l'adresse, l'incrémente de 1 et saute au handler. Cela évite un tableau de JMP et économise quelques octets.

Exemple : commande 'G' (5e caractère dans $4F9D) → ATAMON lit les 2 octets à $4FC8 + (index × 2), les pousse en ordre inversé, et fait RTS vers le handler.

Tables du désassembleur intégré ($4FF9+)

ATAMON possède son propre mini-désassembleur (commande D). Il utilise deux tables internes :

1. Mnémoniques 6502 : entrées de 3 lettres codées (56 mnémoniques officiels)

2. Modes d'adressage : table des tailles et formats d'opérandes pour chaque opcode

Ces tables couvrent uniquement les opcodes officiels du 6502. Les opcodes illégaux ne sont pas reconnus par le désassembleur d'ATAMON et seraient affichés de manière incorrecte.

→ Voir Annexe B en fin de document pour la liste complète des 56 mnémoniques reconnus.

Note : dans le binaire ATAMON, les adresses $4F43–$52B1 contiennent des données (chaînes texte, tables de caractères, vecteurs). Un désassembleur linéaire interprète ces octets comme des instructions — dont beaucoup tombent dans la catégorie des opcodes non documentés du 6502 ($02 *KIL, $03 *SLO, $3A *NOP, etc.). Il s'agit de faux positifs dus à la nature des données, pas d'utilisation intentionnelle d'opcodes illégaux dans le code d'ATAMON.

11. Comment utiliser ATAMON

Lancement

Depuis le DOS Atari, sélectionner L. BINARY LOAD puis taper D:ATAMON. ATAMON affiche sa bannière (*C + registres) et le curseur Atari attend votre première commande.

Touches spéciales

Note : ATAMON repose sur CIO (éditeur écran E:) pour la lecture des commandes. Les fonctions d'édition standard de l'éditeur Atari (déplacement curseur, effacement) sont disponibles avant de valider avec RETURN.

Affichage typique au démarrage

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

Exemples de session

xxxxxxxxxx
; Afficher la mémoire depuis $4000
M 4000

; Modifier 8 octets à $6000 (zone libre)
: 6000 A9 FF 8D 00 D0 4C 00 60

; Désassembler depuis $4000
D 4000

; Lancer le programme à $4000
G 4000

; Copier $4000-$40FF vers $6000, puis vérifier
T 4000,40FF,6000
V 4000,40FF,6000

; Remplir $6000-$60FF avec des NOP ($EA) — zone libre, hors ATAMON
F 6000,60FF,EA

; Lire le secteur 1 du disque dans le buffer ($0680)
E 0001

; Réécrire le buffer sur le secteur 1
W 0001

; Calculer $4000 + $0100
* + 4000,0100

; Quitter vers DOS
X

12. Notes historiques

ATAMON (abréviation de ATAri MONitor) est un moniteur langage machine commercialisé par ATARI en 1983 en Allemagne, la même année que le lancement de l'Atari 800XL.

La disquette DXG 5724 contient également :

• DOS.SYS : le système d'exploitation disque Atari DOS 2.x (39 secteurs)

• DUP.SYS : l'utilitaire de gestion de disquette (42 secteurs)

Ces trois programmes constituent une disquette complète : DOS + utilitaires + moniteur de débogage.

L'analyse de la disquette n'a révélé aucune protection particulière. L'analyse des 720 secteurs confirme l'absence de secteurs fantômes (phantom_count = 0 pour tous les secteurs), de mauvais CRC intentionnels ou de tout autre mécanisme de protection par copie. La disquette originale d'ATAMON n'était pas protégée contre la copie.

13. Notes techniques sur le désassemblage

Opcodes illégaux connus du 6502

Bug JMP indirect

Le 6502 a un bug matériel : JMP (addr) lit incorrectement le byte de poids fort si addr se termine par $FF. Exemple : JMP ($10FF) lit $10FF (lo) et $1000 (hi) au lieu de $1100. Dans ATAMON, les deux JMP (ind) présents ($47BF JMP (DOSVEC) et $47E4 JMP ($4F41)) n'ont pas d'adresses se terminant par $FF — pas de bug dans ce programme. Note : JMP ($4F41) est le saut d'exécution vers l'adresse sauvegardée (PCL à $4F41, PCH à $4F42).

Annexe A — Glossaire de la page zéro ($00–$FF)

La page zéro est la première tranche de 256 octets de la RAM ($00 à $FF). Sur le 6502, elle est spéciale à deux titres :

• Les instructions qui y accèdent n'utilisent qu'un seul octet d'adresse au lieu de deux → elles sont plus courtes et plus rapides.

• Le 6502 peut l'utiliser comme zone de "registres supplémentaires" : pointeurs 16 bits, compteurs, variables temporaires.

L'OS Atari et ATAMON s'en servent intensivement. Voici les emplacements les plus importants, expliqués pour un débutant :

Variables OS Atari (réservées par le système)

Variables utilisées par ATAMON

Ces adresses sont réservées par ATAMON pendant qu'il est chargé. Les modifier avec : ou , peut perturber le fonctionnement du moniteur.

Conseil : utilisez M 0000 00FF pour visualiser l'intégralité de la page zéro et observer comment ces valeurs changent selon les opérations en cours.

Documentation reconstituée par analyse du binaire XEX et désassemblage 6502. Références : De Re Atari (APX 90009), Atari 8-bit FAQ, Altirra 4.40 source, AtariWiki — 6502 Assembly Code, Unused Opcodes, OS ROM listing, Atari Custom Display Lists (Atarimania), Display Lists Simplified (Atari magazines), ANTIC registers (xmission.com/~trevin).

Annexe B — Les 56 mnémoniques officiels du 6502

Le désassembleur intégré d'ATAMON (commande D) reconnaît exactement ces 56 instructions.

Chargement / stockage

Transferts entre registres

Pile

Arithmétique

Incrémentation / décrémentation

Opérations logiques

Décalages et rotations

Comparaisons

Branchements conditionnels

Tous les branchements sont relatifs (déplacement signé de −128 à +127 octets depuis l'instruction suivante).

Sauts et appels

Interruption logicielle

Gestion des flags

Divers

Annexe C — Opcodes illégaux / non documentés du 6502

Ces opcodes n'existent pas dans la spécification officielle MOS Technology du 6502. Ils sont le résultat de combinaisons non prévues de la logique interne du processeur. Leur comportement est reproduit par le désassembleur ATAMON (commande D), qui les affiche précédés d'un *.

Attention : la plupart sont instables selon la révision du processeur ou la tension d'alimentation. À éviter en code de production ; utiles pour analyser des programmes anciens qui les exploitent.

Instructions fatales

Instructions lecture-modification-écriture combinées

Ces opcodes effectuent deux opérations en une : une modification en mémoire (ou sur l'accumulateur) puis une opération logique/arithmétique avec A.

Chargement / stockage combinés

Instructions sur l'accumulateur

Instructions mémoire instables (dépendent de addr_hi)

NOP illégaux (multi-octets, sans effet)

Ces opcodes se comportent comme un NOP (ne font rien de visible) mais consomment 2 ou 3 octets — le CPU les lit et les ignore.

Annexe D — Étiquettes Atari connues

Adresses symboliques reconnues par le désassembleur ATAMON (commande D). Elles apparaissent dans le désassemblage à la place de l'adresse hexadécimale brute.

Page zéro — Variables OS ($00–$FF)

Page 2 — Vecteurs d'interruption ($0200–$02FF)

Page 3 — DCB SIO ($0300–$035F)

Registres matériels — GTIA ($D000)

Registres matériels — POKEY ($D200)

Registres matériels — PIA ($D300)

Registres matériels — ANTIC ($D400)

Points d'entrée OS ROM ($E4xx)

Math ROM ($D8xx)

Annexe E — Registres hardware Atari 800XL — référence rapide

Récapitulatif des registres matériels des quatre puces customs de l'Atari 800XL, avec leur usage typique en programmation.

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

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