|
Initiation à l’assembleur 6809
Cours n°2
Les registres du 6809 sont au nombre de 10. Ils n'ont pas d'existence aussi palpable qu'une zone de mémoire mais plutôt
une existence... suspendue. Ils sont les messagers de l'ordinateur: toute
information passe nécessairement par eux. Ils ne sont pas le trait sur la
feuille mais le crayon qui le trace.
- A et B sont deux accumulateurs (ou registres de données) 8 bits.
L'avantage de leur utilisation est que la plupart des instructions les plus
courtes et les plus rapides existent spécialement pour eux. Les accumulateurs A
et B peuvent être traités simultanément: on obtient le registre de donnée 16
bits D.
- X et Y sont deux registres d'adresse 16 bits. Ils n'ont pas été
appelés ainsi par hasard: ils servent bien souvent à passer des coordonnées
graphiques aux programmes du moniteur.
- U (UserStack) est un registre d'adresse 16 bits. Il peut se
comporter aussi comme une pile. Nous reviendrons sur ce fait.
- S (Stack) est un registre d'adresse 16 bits. Il est le pointeur
de pile officiel de l'ordinateur et ne peut donc être utilisé que dans des
conditions bien précises sous peine de faire boguer l'ordinateur.
- PC (ProgramCounter) est un registre d'adresse 16 bits. Il est le
compteur de programme de l'ordinateur. Il pointe systématiquement sur
l'instruction en cours d'exécution, comme un doigt pointe le mot à lire pendant
une lecture. Il doit donc, lui aussi, être utilisé sous des conditions très
contrôlées.
- CC (ConditionCode) est un registre 8 bits. Il est le registre qui
mémorise le résultat de chaque test. Il n'est pas un registre manipulable à
proprement parler.
- DP (DirectPage) est un registre d'adresse 8 bits. Nous
reviendrons plus tard sur son utilité.
Les accumulateurs A, B et D servent à la manipulation des données. Il est alors possible d'effectuer toute une série
d'opérations par ces registres, opérations arithmétiques et logiques, entre
autres la multiplication. Ils permettent le "pétrissage" de la
donnée.
Les registres d'adresse, eux, peuvent être
aussi utilisés comme registres de données, mais ils sont moins agiles à
l'entreprise. Leur fonction officielle est de pointer un endroit de la mémoire
afin d'y inscrire ou lire la donnée qui s'y trouve.
Pour plus de clarté, vous pouvez noter que
l'instruction POKE sous Basic nécessite 2 paramètres: une adresse pour stocker
la donnée et la donnée elle-même. Ainsi, les manipulations par les registres se
limitent à prendre, transformer et donner.
Mais qu'est-ce donc qu'un bit?
Lorsque l'on compte en base décimale (base
dix), on part de 0, puis on passe à 1, puis 2, puis 3, etc... et ainsi jusqu'à
9. A partir de 9, il se passe une chose étrange: l'unité est mise à 0 et l'on
ajoute le chiffre 1 devant ce 0, ce qui nous donne 10. En base binaire (base
deux), la valeur maximum que puisse prendre un chiffre est 1. Lorsque l'on
compte en base binaire, on part de 0, puis on passe à 1 puis l'unité est mise à
0 et on ajoute le chiffre 1 devant ce 0, ce qui nous donne 10. Et la base
binaire est justement celle utilisée par l'ordinateur. Chacun de ces chiffres
représente un bit et lorsqu'il est dit qu'un registre est composé de 8 bits,
c'est que la valeur maximum qu'il puisse prendre est 11111111 en base 2, soit
255 en base 10. On appelle cela généralement un octet. Pour un registre 16
bits, la valeur maximum est 1111111111111111 en base 2 soit 65535 en base 10.
On appelle cela généralement un mot. Le préfixe utilisé pour marquer une valeur
binaire est le caractère "%", mais ASSEMBLER n'assemble pas ce genre
de valeur (dommage!).
Pour la base hexadécimale (base 16), très
utilisée en assembleur, chaque chiffre peut prendre 16 valeurs: 0, 1, 2, 3, 4,
5, 6, 7, 8, 9, A, B, C, D, E et F (il fallait bien trouver de quoi aller
jusqu'à la seizième!). De la même façon, au-delà de F, l'unité est mise à 0 et
l'on ajoute le chiffre 1 devant le 0,
ce qui nous donne 10. La valeur maximum qu'un registre 8 bits puisse prendre
est FF en base 16 soit 255 en base 10, et pour un registre 16 bits, la valeur
maximum est FFFF en base 16 soit 65535 en base 10. Le préfixe utilisé pour
marquer une valeur hexadécimale est le caractère "$".
Pour matérialiser un octet, quoi de plus démonstratif que de l'afficher dans la zone mémoire réservée à l'écran? On
comprendra de fait que le binaire soit si familier à un ordinateur puisqu’un
point à l'écran ne peut avoir que deux états: allumé (1) ou éteint (0). Un bit
sur l'écran prend alors le nom de pixel et un octet aura celui de segment. Nous
savons que l'écran se trouve sur TO de l'adresse $4000 à l'adresse $5F3F et sur
MO de l’adresse $0000 à l’adresse $1F3F. Affichons donc un octet de valeur $55
(01010101 en base 2), ce qui est censé nous donner 8 points consécutifs dont un
point sur deux serait allumé, soit 4 points espacés. Effacez le programme assembleur
résident en tapant « N »+RETURN puis sur « Y » (après avoir
sauvegardé votre programme) puis tapez, assemblez et exécutez ce programme
comme cela a été expliqué dans le cours n°1 (sans vous sentir obligés d'écrire
les commentaires de lignes):
Pour TO :
DEBUT LDB $E7C3 ! Passe > 10 B=PEEK(&HE7C3)
ORB #$01 ! en mémoire > 20 B=B OR &H01
STB $E7C3 ! de forme > 30 POKE &HE7C3,B
LDB #$55 ! Affiche l'octet > 40 B=&H55
STB $5000 ! de valeur $55 > 50 POKE &H5000,B
SWI Arrêt du programme > 60 END
END - Fin du programme -
...et pour MO :
DEBUT CALL $06 Passe en mémoire de forme < Pas d’équivalent
LDB #$55 ! Affiche l'octet < 40 B=&H55
STB $1000 ! de valeur $55 < 50 POKE &H1000,B
STOP Arrêt du programme < 60 END
END - Fin du programme -
Nous pouvons observer que nous avons bien à l'écran le segment à l’endroit attendu.
Allez, sans plus attendre, la friandise du cours!
Si vous doutiez encore de la rapidité du langage assembleur, voici
un programme qui va vous fixer définitivement sur la question. Nous allons
remplir l'écran avec le fameux segment $55. Effacez la ligne du « STB
$5000 » sur TO et « STB $1000 » sur MO à partir de la barre
d'édition en plaçant le curseur sur la ligne à effacer puis en tapant
« D »+RETURN, puis, dans l'éditeur, en faisant de la place entre les
lignes avec RETURN, tapez, assemblez et exécutez ce programme, pour TO:
DEBUT LDB $E7C3 ! Passe l'écran > 10 B=PEEK(&HE7C3)
ORB #$01 ! en mémoire > 20 B=B OR &H01
STB $E7C3 ! de forme > 30 POKE &HE7C3,B
LDX #$4000 Départ de l'écran > 40 X=&H4000
LDB #$55 Charge le segment > 50 B=&H55
SUITE STB ,X+ Ecrit le segment > 60 POKE X,B:X=X+1
CMPX #$5F40 ! Si pas fin > 70 IF X<&H5F40
BLO SUITE ! d'écran, boucle > THEN 60
SWI Arrêt du programme > 80 END
END - Fin du programme -
...et pour MO:
DEBUT CALL $06 Passe en mémoire forme > ---
LDX #$0000 Départ de l'écran > 40 X=&H0000
LDB #$55 Charge le segment > 50 B=&H55
SUITE STB ,X+ Ecrit le segment > 60 POKE X,B:X=X+1
CMPX #$1F40 ! Si pas fin > 70 IF X<&H1F40
BLO SUITE ! d'écran, boucle > THEN 60
STOP Arrêt du programme > 80 END
END - Fin du programme -
Ho, comme c'est joli! A part que la couleur
reste inchangée, votre écran est strié de lignes verticales. Il va sans dire
que l'équivalent du programme en Basic irait beaucoup, beaucoup moins vite...
|
