Familiarisation avec ASSEMBLER 2.0 Registres 6809 et bases algébriques Adressages des instructions Fonctionnement de la pile Les registres DP et CC Additions et soustractions Instructions de décalage Les opérateurs logiques Les branchements Test, translation, effacement et complémentation Etude d'une entrée du Moniteur Quelques astuces de programmation Agrandissement d'un caractère - Charger un secteur Programme de dessin - Un peu de musique Chronomètre

Initiation à l’assembleur 6809

Cours n°8

Opérateurs logiques

Les instructions logiques sont de trois types: ET (AND), OU (OR) et OU exclusif (XOR). Les instructions ET permettent de mettre à 0 les bits choisis d'un registre, les instructions OU de les mettre à 1 et les instructions OU exclusif d'en permuter l'état.

  Les instructions ET
  ANDA       Effectue un ET avec le registre 8 bits A
  ANDB       Effectue un ET avec le registre 8 bits B
  ANDCC      Effectue un ET avec le registre 8 bits CC

LDA    #$E0          < A=&HE1
ANDA   #$55          < A=&H41

Si un bit de A et un bit de l'opérande est à 1, le bit de résultat est à 1. Si l'un des deux bits, ou de A ou de l'opérande, est à 0, le bit de résultat est à 0:

Tramons l'écran:

DEBUT  LDB    $E7C3   |                      < 10 B=PEEK(&HE7C3)
       ORB    #$01    | Passe en RAMA        < 20 B=B OR 1
       STB    $E7C3   |                      < 30 POKE &HE7C3,B
       LDX    #$4000  Ptr écran              < 40 X=&H4000
       LDY    #200/2  Hauteur écran / 2      < 50 Y=200/2
* AND avec ligne paire                       < 55 'AND avec ligne paire
AND0   LDA    #40     Largeur ligne          < 60 A=40
AND1   LDB    ,X      Lit un segment         < 70 B=PEEK(X)
       ANDB   #$AA    ET avec $AA            < 80 B=B AND &HAA
       STB    ,X+     Ecrit le segment       < 90 POKE X,B:X=X+1
       DECA           | Segment              < 100 A=A-1
       BNE    AND1    | suivant              < 110 IF A<>0 THEN 70
* AND avec ligne impaire                     < 115 'AND avec ligne impaire
       LDA    #40     Largeur ligne          < 120 A=40
AND2   LDB    ,X      Lit le segment         < 130 B=PEEK(X)
       ANDB   #$55    ET avec $55            < 140 B=B AND &H55
       STB    ,X+     Ecrit le segment       < 150 POKE X,B:X=X+1
       DECA           | Segment              < 160 A=A+1
       BNE    AND2    | suivant              < 170 IF A<>0 THEN 130
* Lignes suivantes                           < 175 'Lignes suivantes
       LEAY   -1,Y    | Autant que           < 180 Y=Y-1
       BNE    AND0    | de lignes            < 190 IF Y<>0 THEN 60
       SWI            Arrêt du programme     < 200 END
       END            * Fin du programme

  Les instructions OU
  ORA       Effectue un OU avec le registre 8 bits A
  ORB       Effectue un OU avec le registre 8 bits B
  ORCC      Effectue un OU avec le registre 8 bits CC

LDA    #$18          < A=&H18
ORA    #$81          < A=&H99

Si l'un et/ou l'autre des bits de A de l'opérande sont à 1, le bit de résultat est à 1. Si les deux bits sont à 0, le bit de résultat est à 0:

Encadrons chaque colonne à l'écran par une ligne:

DEBUT  LDB   $E7C3    |                     < 10 B=PEEK(&HE7C3)
       ORB    #$01    | Passe en RAMA       < 20 B=B OR 1
       STB    $E7C3   |                     < 30 POKE &HE7C3,B
       LDX    #$4000  Ptr écran             < 40 X=&H4000
       LDY    #8000   Taille écran          < 50 Y=8000
OR     LDB    ,X      Lit un segment        < 60 B=PEEK(X)
       ORB    #$81    OR avec $81           < 70 B=B OR 1
       STB    ,X+     Ecrit le segment      < 80 POKE X,B:X=X+1
       LEAY   -1,Y    | Autant que          < 90 Y=Y-1
       BNE    OR      | de lignes           < 100 IF Y<>0 THEN 60
       SWI            Arrêt du programme    < 110 END
       END            * Fin du programme

  Les instructions OU exclusif
  EORA      Effectue un OU exclusif avec le registre 8 bits A
  EORB      Effectue un OU exclusif avec le registre 8 bits B

LDA    #$18          < A=&H18
EORA   #$0F          < A=&H99

Si le bit de A et celui de l'opérande sont de même valeur, le bit de résultat est à 0. Si les deux bits sont de valeurs différentes, le bit de résultat est à 1:

Commutons les couleurs de chaque demi-colonne à l'écran:

DEBUT  LDB   $E7C3    |                      < 10 B=PEEK(&HE7C3)
       ORB    #$01    | Passe en RAMA        < 20 B=B OR 1
       STB    $E7C3   |                      < 30 POKE &HE7C3,B
       LDX    #$4000  Ptr écran              < 40 X=&H4000
       LDY    #8000   Taille écran           < 50 Y=8000
XOR    LDB    ,X      Lit un segment         < 60 B=PEEK(X)
       EORB   #$0F    XOR avec $0F           < 70 B=B XOR &H0F
       STB    ,X+     Ecrit le segment       < 80 POKE X,B:X=X+1
       LEAY   -1,Y    | Autant que           < 90 Y=Y-1
       BNE    XOR     | de lignes            < 100 IF Y<>0 THEN 60
       SWI            Arrêt du programme     < END
       END            * Fin du programme

Pour adapter ces programmes au MO, remplacer les 4 premières lignes par:>P>

DEBUT  CALL   $06    Passe en RAMA          < - Pas d'équivalent basic -
       LDX    #$0000 Ptr écran              < X=&H0000

...et le SWI d'arrêt du programme par STOP.

Les instructions ANDCC et ORCC servent à positionner les flags du code condition à 0 ou 1. Les programmeurs connaissent bien le fameux "ORCC #$50" qui gèle les IRQ et FIRQ et permet toutes les fantaisies indépendamment d’un système désormais en dormition.