|
Initiation à l’assembleur 6809
Cours n°3
Le 6809 possède un grand nombre d'instructions, qui permettent la manipulation des registres. Les codes
utilisés en assembleur pour les instructions sont appelés "mnémoniques", du fait qu'ils sont orthographiés de telle façon qu'il
soit facile de se les rappeler. Il est possible, par leur biais, d'effectuer 59
opérations de base. Lors de l'assemblage, ces instructions sont transformées en
langage machine dont les codes sont affichés en jaune à gauche de d'écran.
Les instructions les plus fréquemment utilisées sont les deux instructions de chargement (LoaD) et de stockage
(STore) d'un registre. Ces deux instructions, comme tant d'autres, sont
orthographiées avec le registre qui les concerne. Tous les registres peuvent
être chargés avec une valeur déterminée, mais nous ne toucherons pas au
registre S (cours n°2), ainsi qu'aux registres CC et DP, qui ont des procédures
de chargement plus particulières. Quoi qu’il en soit, effacez le programme
précédent, puis tapez, assemblez et exécutez le programme suivant:
DEBUT LDA #$55 Charge A > A=&H55
LDB #$A0 Charge B > B=&HA0
LDX #$2000 Charge X > X=&H2000
LDY #$1000 Charge Y > Y=&H1000
LDU #$7777 Charge U > U=&H7777
SWI Arrêt du programme > END
END - Fin du programme -
* Le SWI d’arrêt du programme doit être remplacé par STOP sur les MO
Pour vérifier que les valeurs ont bien été chargées dans les registres, tapez "R"+RETURN dans le moniteur, juste
après l'exécution du programme. Sur la barre de haut d'écran du moniteur sont
affichés tous les registres du 6809. Lorsque vous tapez "R"+RETURN s'affichent
alors la valeur de tous les registres sous leur nom respectif. Vous noterez
donc que, sauf erreur, les registres incriminés sont chargés avec les valeurs
voulues.
Il est possible d'écrire aussi en mémoire par le biais de l'instruction Store. Il nous faudra alors définir une zone
mémoire par la directive RMB (Reserve Memory Bytes) pour stockez la valeur des
registres. En utilisant le programme précédent, tapez, assemblez et exécutez ce
programme (les adresses pour le stockage des registres en basic sont
arbitraires):
> REGA=&H9000
> REGB=&H9001
> REGX=&H9002
> REGY=&H9004
> REGU=&H9006
DEBUT LDA #$55 Charge A > A=&H55
LDB #$A0 Charge B > B=&HA0
LDX #$2000 Charge X > X=&H2000
LDY #$1000 Charge Y > Y=&H1000
LDU #$7777 Charge U > U=&H7777
STA REGA Ecrit A dans REGA > POKE REGA,A
STB REGB Ecrit B dans REGB > POKE REGB,B
STX REGX Ecrit X dans REGX > POKE REGX,X
STY REGY Ecrit Y dans REGY > POKE REGY,Y
STU REGU Ecrit U dans REGU > POKE REGU,U
SWI Arrêt du programme > END
* Le SWI d’arrêt du programme doit être remplacé par STOP sur les MO
REGA RMB 1 Place pour A
REGB RMB 1 Place pour B
REGX RMB 2 Place pour X
REGY RMB 2 Place pour Y
REGU RMB 2 Place pour U
END - Fin du programme -
Vous remarquerez que les registres X, Y et U nécessitent une déclaration mémoire de 2 octets puisqu'il s'agit de registres
16 bits.
Pour vérifier que les espaces mémoire déclarés sont bien remplis avec les valeurs des registres, effectuez dans le
moniteur un dump de la mémoire en tapant "DREGA" (qui signifie
"Dump REGA") +RETURN, soit la visualisation du contenu de la mémoire
à partir de REGA. Vous constaterez que les 8 premiers octets contiennent bien
les valeurs "55 A0 20 00 10 00 77 77". Vous pouvez aussi, par
exemple, vérifier seulement la valeur contenue dans REGU en tapant "DREGU"+RETURN.
L'air de rien, nous avons aussi étudié une partie des modes d'adressages du 6809. Pour le chargement des valeurs dans les
registres, nous avons recouru à l'adressage immédiat, qui est toujours précédé
du signe "#", qu'il s'agisse d'une adresse numérique ou d'une
étiquette. "LDX #$2000" chargerait la valeur $2000 dans X. Mais si on
omet le signe "#", on passe alors à une indirection supérieure: ce
n'est pas la valeur $2000 qui est récupérée dans X mais la valeur 16 bits contenue
dans la mémoire à l'adresse $2000. Cet adressage s'appelle l'adressage étendu.
Et si l'on écrit non pas "LDX $2000" mais "LDX [$2000]",
alors ce n'est plus la valeur contenue à l'adresse $2000 qui est récupérée par
X, mais la valeur qui se trouve à l'adresse contenue en $2000. C'est
l'adressage étendu indirect.
Nous avons aussi entrevu une des formes de l'adressage indexé comme le "STB ,X+" dans le programme ci-dessous,
qui signifie que la valeur contenue à l'adresse pointée par X est chargée dans
B, puis que le registre X pointera l'octet à l'adresse suivante, la valeur de
l'adresse contenue dans X étant automatiquement augmentée de 1 unité. Si l'on
avait voulu que cette adresse soit augmentée automatiquement de 2 unités, comme
peut l'exiger la lecture ou l'écriture d'une table d'adresses en mémoire, il
aurait fallu écrire ",X++".
Voici donc un programme qui va afficher les caractères de la barre des registres sur tout l'écran, c'est-à-dire
recopier ni plus ni moins par les instructions étudiées le graphisme des 8 premières
lignes du moniteur sur toutes les autres lignes:
Pour TO :
DEBUT LDB $E7C3 ! Passe en > 10 B=PEEK(&HE7C3)
ORB #$01 ! mémoire > 20 B=B OR &H01
STB $E7C3 ! de forme > 30 POKE&HE7C3,B
LDY #(40*8)*24 24 lignes caractères > 40 Y=(40*8)*24
LDX #$4000+(40*8) Pointeur de départ > 50 X=&H4000+(40*8)
SUITE LDB -(40*8),X Lit le segment > 60 B=PEEK(X-(40*8))
STB ,X+ Copie le segment > 70 POKE X,B:X=X+1
LEAY -1,Y ! Pour tous les > 80 Y=Y-1
BNE SUITE ! segments > 90 IF Y<>0 THEN 60
SWI Arrêt du programme > 100 END
END - Fin de programme -
...et pour MO :
DEBUT CALL $06 Passe en mémoire de forme > Pas d’équivalent
LDY #(40*8)*24 24 lignes caractères > 40 Y=(40*8)*24
LDX #$0000+(40*8) Pointeur de départ > 50 X=&H0000+(40*8)
SUITE LDB -(40*8),X Lit le segment > 60 B=PEEK(X-(40*8))
STB ,X+ Copie le segment > 70 POKE X,B:X=X+1
LEAY -1,Y ! Pour tous les > 80 Y=Y-1
BNE SUITE ! segments > 90 IF Y<>0 THEN 60
STOP Arrêt du programme > 100 END
END - Fin de programme -
|
