MPASM Instructions :

Dans la mémoire programme, les instructions sont codées en suites de 0 et de 1, nous, nous préférons écrire des choses comme goto ou clrw, l'assembleur se charge de cette traduction.

Chaque ligne peut contenir jusqu’à 4 types d’informations :

Une étiquette
L’instruction en mnémonique
Le ou les opérandes
Des commentaires

Une ligne contient 255 caractères maximum

Etiquettes :

L’étiquette permet de donner un nom à un nombre (adresse, variable), ou à une ligne du programme

Elle commence par un caractère alphanumérique (ou un sous ligné)

Dans ce cas, le sous ligné ne doit pas être suivi par un chiffre

Les caractères utilisables sont lettres, chiffres, sous ligné et point d’interrogation

Leur longueur maximale est de 32 caractères

Par défaut il y a une différence entre majuscules et minuscules, sauf option différente dans MPLAB.

L’étiquette en début de ligne de programme commence en colonne 1; elle est suivie par un espace, une tabulation ou par deux points ( : ) ou par un retour chariot si elle est seule sur la ligne.

Derrière un call ou un goto elle est en colone 3.

L’étiquette représentant un nombre est placée conformémént à la directive ou à l'instruction qui l'utilise.

Mnémoniques :

C’est l'instruction elle même

L’ instruction doit commencer en colonne 2

S’il y a une étiquette en colonne 1, il doit y avoir séparation par un ou plusieurs espace, ou par deux points ( : ) ou par une tabulation.

Opérande(s) :

L’opérande vient après l’instruction, il la complête

Il doit être séparé de l'instruction par un ou plusieurs espace, ou par deux points ( : ) ou par une tabulation.

S’il y a plusieurs opérandes, ils sont séparés par des virgules

Commentaires :

Tout texte commençant par un point virgule n’est pas pris en compte par la compilation jusqu’à la fin de la ligne ; c’est un commentaire.

Sauf si le point virgule fait partie d’une chaîne de caractères

Conventions utilisées dans la description des instructions :

b Bit concerné par l’opération (0 à 7)

f(b) est le bit b du registre f

d = 0 Résultat dans le registre de travail (W)

d = 1 Résultat dans le registre f (cas par défaut)

f Adresse d’un registre ou d’une case mémoire (h’00’ à h’FF’)

(f) Valeur contenue dans f

k Valeur numérique, ou étiquette

(k) Valeur de k

W Registre de travail (accumulateur)

(W) valeur contenue dans W

ADDLW k

(Add literal to W)

k + (W) ->(W)

k: (0 à 255)

Ajoute la valeur k au contenu du registre de travail W et met le résultat dans W

Exemple: Avant l'instruction W contient d'05'

addlw d'07' ; après l'instruction W contient h'12'

Nombre de cycles d'horloge:1

Registre affecté: STATUS C, DC, Z

ADDWF f,d

(Add W and f)

(W) + (f) -> (d)

f: (00 à 4F); d: (0 ou 1)

Ajoute le contenu du registre de travail W à celui du registre f, et met le résultat

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction W contient d'05' et Casemem contient d'06'

addwf Casemem,0 ; après l'instruction W contient d'12' , f contient toujours d'06'

Exemple 2: Avant l'instruction W contient d'05' et Casemem contient d'06'

addwf Casemem,1 ; après l'instruction W contient toujours d'05' , f contient d'12'

Nombre de cycles d'horloge:1

Registres affectés: STATUS C, DC, Z

ANDLW k

(AND literal and W)

k AND (W)->(W)

k: (0 à 255)

Fait bit à bit l'opération AND entre le contenu de W et la valeur k, et met le résultat dans W

Exemple1: Avant l'instruction W contient b'01101101'

andlw b'01001110' ; après l'instruction W contient b'01001100'

Cette instruction permet de forcer certains bits à 0 dans W; k devient un masque: les bits à 1 dans le masque ne changeront pas les bits correspondants dans W, les bits à 0 dans le masque forceront à 0 les bits correspondants de W

Nombre de cycles d'horloge:1

Registre affecté: STATUS, Z

ANDWF f,d

(AND W and f)

(W) AND (f) -> (d)

f: (00 à 4F); d: (0 ou 1)

Fait bit à bit l'opération AND entre les contenus de W et de f, et met le résultat

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction W contient b'01101101' et Casemem contient b'01001110'

andwf Casemem,0 ; après l'instruction W contient b'01001100' , Casemem contient toujours b'01001110'

Exemple 2: Avant l'instruction W contient b'01101101' et Casemem contient b'01001110'

andwf Casemem,1 ; après l'instruction W contient toujours b'01101101' , Casemem contient b'01001100'

Nombre de cycles d'horloge:1

Registre affecté: STATUS, Z

BCF f,b

(Bit clear f)

0->f(b)

f: (00 à 4F); d: (0 à 7)

Met à zéro le bit b du registre f

Exemple:

bcf STATUS,RP0 ; met à 0 le bit 5 RP0 du registre STATUS, donc passe en page mémoire 0

Nombre de cycles d'horloge:1

Registres affectés: aucun

BSF f,b

(Bit set f )

1->f(b)

f: (00 à 4F); d: (0 à 7)

Met à un le bit b du registre f

Exemple:

bsf STATUS,RP0 ; met à 1 le bit 5 RP0 du registre STATUS, donc passe en page mémoire 1

Nombre de cycles d'horloge:1

Registres affectés: aucun

BTFSC f,b

(Bit test, skip if clear)

skip if f(b) = 0

f: (00 à 4F); d: (0 à 7)

Teste le bit b du registre f:

Si f(b)=0, on saute l'instruction qui suit pour exécuter celle qui vient après
Si f(b)=1, on exécute l'instruction qui suit

Exemple:

btfsc Casemem,b
goto Bita1 ; exécuté si b=1
xxxxx ; exécuté si b=0

Nombre de cycles d'horloge:1 si b=1 ou 2 si b=0

Registres affectés: aucun

BTFSS f,b

(Bit test, skip if set)

skip if f(b) = 1

f: (00 à 4F); d: (0 à 7)

Teste le bit b du registre f:

Si f(b)=1, on saute l'instruction qui suit pour exécuter celle qui vient après
Si f(b)=0, on exécute l'instruction qui suit

Exemple:

btfsc Casemem,b
goto Bita0 ; exécuté si b=0
xxxxx ; exécuté si b=1

Nombre de cycles d'horloge:1 si b=0 ou 2 si b=1

Registres affectés: aucun

CALL k

Call subroutine

PC + 1->pile, (k) ->PC

k: (étiquette)

Le programme saute à l'adresse k; il exécute les instructions qu'il y trouve jusqu'à une instruction RETURN ou RETLW qui le fera revenir à l'instruction qui suivait l'instruction CALL

La pile ne contenant que 8 mots, on ne peut imbriquer que 8 souroutines au maximum

Exemple:

call SousRoutine

Nombre de cycles d'horloge: 2

Registres affectés: aucun

CLRF f

(Clear f)

h'00' -> (f) ; 1 -> Z

f: (00 à 4F)

Met le contenu du registre f à zéro

Exemple:

clrf INTCON ; interdit toutes les interruptions

Nombre de cycles d'horloge: 1

Registres affectés: STATUS , Z

CLRW

(Clear W)

h'00' ->(W) ; 1 -> Z

Met le contenu du registre de travail W à zéro

Exemple : Avant l'instruction W contient h'3c'

clrw ; aprés l'instruction, W contient h'00'

Nombre de cycles d'horloge: 1

Registres affectés: STATUS Z

CLRWDT

(Clear watchdog timer)

0->WDT
0 -> prescaler (s'il est affecté au Watchdog)
1 -> STATUS, NOT_TO
1 -> STATUS, NOT_TO

Met à zéro le compteur du Watchdog; en fait autant pour le compteur du prescaler s'il est assigné au Watchdog

On insére clrwdt dans le programme en un endroit exploré régulièrement, si par suite d'un plantage cette instruction n'est plus sollicitée, le watchdog va à son terme et produit un Reset

Ne pas utiliser dans une routine d'interruption

Nombre de cycles d'horloge: 1

Registre affecté: STATUS, NOT_TO, NOT_PD

COMF f,d

(Complement f)

NOT( f) -> (d)

f: (00 à 4F); d: (0 ou 1)

met le résultat

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction, peu importe le contenu de W et Casemem contient b'00110011'

comf Casemem,0 ; après l'instruction W contient b'11001100' , Casemem contient toujours b'00110011'

Exemple 2: Avant l'instruction peu importe le contenu de W et Casemem contient b'00110011'

comf Casemem,1 ; après l'instruction le contenu de W n'a pas changé et Casemem contient b'11001100'

Nombre de cycles d'horloge: 1

Registres affectés: STATUS , Z

DECF f,d

(Decrement f)

(f) - 1 -> (d)

f: (00 à 4F); d: (0 ou 1)

Décrémente d'une unité le contenu de f et met le résultat

dans W si d=0
dans f si d=1

Si l'on décrémente d'000' on obtient d'255'

Exemple 1: Avant l'instruction, peu importe le contenu de W et Casemem contient d'123'

decf Casemem,0 ; après l'instruction W contient d'122' , Casemem contient toujours d'123'

Exemple 2: Avant l'instruction peu importe le contenu de W et Casemem contient d'123'

decf Casemem,1 ; après l'instruction le contenu de W n'a pas changé et Casemem contient d'122'

Nombre de cycles d'horloge: 1

Registre affecté: STATUS , Z

DECFSZ f,d

(Decrement f, skip if zero)

(f) - 1 -> (d), skip if 0

f: (00 à 4F); d: (0 ou 1)

Décrémente d'une unité le contenu de f et met le résultat

dans W si d=0
dans f si d=1

Si l'on décrémente d'000' on obtient d'255'

Si le résultat=0, on saute l'instruction qui suit pour exécuter celle qui vient après
Si le résultat est différent de 0, on exécute l'instruction qui suit

Exemple:

decfsz Casemem,1
goto Zero ; exécuté si le résultat=0
xxxxx ; exécuté si le résultat<>0

Nombre de cycles d'horloge:1 si b=1 ou 2 si b=0

Registre affecté: aucun

GOTO k

Goto address k (k sur 10 bits)

(k) ->PC (9 bits)

k: (étiquette)

Branchement inconditionnel, le programme saute à l'adresse donnée par la valeur de k (ou par une étiquette)

Nombre de cycles d'horloge: 2

Registre affecté: aucun

INCF f,d

(Increment f)

(f) + 1 -> (d)

f: (00 à 4F); d: (0 ou 1)

Incrémente d'une unité le contenu de f et met le résultat

dans W si d=0
dans f si d=1

Si l'on incrémente d'255' on obtient d'000'

Exemple 1: Avant l'instruction, peu importe le contenu de W et Casemem contient d'123'

incf Casemem,0 ; après l'instruction W contient d'124' , Casemem contient toujours d'123'

Exemple 2: Avant l'instruction peu importe le contenu de W et Casemem contient d'123'

incf Casemem,1 ; après l'instruction le contenu de W n'a pas changé et Casemem contient d'124'

Nombre de cycles d'horloge: 1

Registre affecté: STATUS , Z

INCFSZ f,d

(Increment f, skip if zero)

(f) + 1 -> (d) ; skip if 0

f: (00 à 4F); d: (0 ou 1)

Incrémente d'une unité le contenu de f et met le résultat

dans W si d=0
dans f si d=1

Si l'on incrémente d'255' on obtient d'000'

Si le résultat=0, on saute l'instruction qui suit pour exécuter celle qui vient après
Si le résultat est différent de 0, on exécute l'instruction qui suit

Exemple:

incfsz Casemem,1
goto Zero; exécuté si le résultat=0
xxxxx ; exécuté si le résultat<>0

Nombre de cycles d'horloge:1 si b=1 ou 2 si b=0

Registre affecté: aucun

IORLW k

(Incl. OR literal and W)

k OR (W) -> (W)

k: (0 à 255)

Fait bit à bit l'opération OR entre le contenu de W et la valeur k, et met le résultat dans W

Exemple: Avant l'instruction W contient b'01101101'

iorlw b'01001110' ; après l'instruction W contient b'01101111'

Cette instruction permet de forcer certains bits à 1 dans W; (k) devient un masque: les bits à 0 dans le masque ne changeront pas les bits correspondants dans W, les bits à 1 dans le masque forceront à 1 les bits correspondants de W

Nombre de cycles d'horloge:1

Registre affecté: STATUS , Z

IORWF f,d

(Inclusive OR W and f)

(W) OR (f) -> (d)

f: (00 à 4F); d: (0 ou 1)

Fait bit à bit l'opération OR entre les contenus de W et de f, et met le résultat

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction W contient b'01101101' et Casememcontient b'01001110'

iorwf Casemem,0 ; après l'instruction W contient b'01101111' , f contient toujours b'01001110'

Exemple 2: Avant l'instruction W contient b'01101101' et Casemem contient b'01001110'

iorwf Casemem,1 ; après l'instruction W contient toujours b'01101101' , f contient b'01101111'

Nombre de cycles d'horloge:1

Registre affecté: STATUS , Z mais Z passe à 1 si le résultat est différent de 0

MOVF f,d

(Move f)

(f) -> (d)

f: (00 à 4F); d: (0 ou 1)

Prend le contenu de f et le met

dans W si d=0
dans f si d=1 (permet de tester si (f)=0, dans ce cas Z passe à 1)

Exemple 1: Avant l'instruction, W contient d'50' et f contient d'100'

movf Casemem,0 ; après l'instruction W contient d'100' , Casemem contient toujours d'100'

Exemple 2: Avant l'instruction, W contient d'50' et f contient d'100'

movf Casemem,1 ; après l'instruction W contient toujours d'50' et Casemem contient toujours d'100' , mais le bit Z a été eventuellement modifié

Nombre de cycles d'horloge:1

Registre affecté: STATUS , Z

MOVLW k

(Move Literal to W)

k -> (W)

k: (0 à 255)

Met la valeur k dans le registre de travail W

Exemple : Avant l'instruction, W contient d'50'

movlw,d'100' ; après l'instruction W contient d'100'

Nombre de cycles d'horloge:1

Registre affecté: STATUS , Z

MOVWF f

(Move W to f)

(W) -> (f)

f: (00 à 4F)

Met le contenu du registre f dans le registre de travail W

Exemple 1: Avant l'instruction, W contient d'50' et peu importe le contenu de f

movwf,Casemem ; après l'instruction W contient toujours d'50' , Casemem contient d'50'

Nombre de cycles d'horloge:1

Registre affecté: aucun

NOP

(No operation)

Cette instruction ne fait aucune opération, elle utilise cependant un cycle d'horloge.

RETFIE

(Return from Interrupt)

Pile -> PC
1->INTCON,GIE

Provoque le retour au programme d'origine à la fin d'une sous routine lancée par une 'interruption

Nombre de cycles d'horloge: 2

Registre affecté: INTCON, GIE

RETLW k

(Return with literal in W)

k -> (W)
Pile -> PC

k: (0 à 255)

Provoque le retour au programme principal à la fin d'une sous routine lancée par une instruction CALL et met la valeur de k dans le registre de travail W

Nombre de cycles d'horloge: 2

Exemple:

btfss Casemem,3 ; teste le bit 3 de Casemem
retlw h'00' ; en sortie de sous routine (W) vaut h'00' si le bit est à 1
retlw h'ff' ; en sortie de sous routine (W) vaut h'ff' si le bit est à 0

Registre affecté: aucun

Cette instruction est utilisée pour lire des tableaux de grandes dimensions stockés en mémoire programme.

RETURN

(Return from subroutine)

Pile -> PC

Provoque le retour au programme principal à la fin d'une sous routine lancée par une instruction CALL

Nombre de cycles d'horloge: 2

Registre affecté: aucun

RLF f,d

(Rotate left f)

f(n)->dest(n+1), f(7)->C, C->dest(0)

f: (00 à 4F); d: (0 ou 1)

Tous les bits de f sont décalés d'un cran à gauche (vers les bits de poids fort)
Le bit STATUS, C passe dans le bit 0
le bit 7 passe dans STATUS, C

Le résultat est mis

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction, peu importe le contenu de W , f contient b'00110011', et C contient 1

rlf Casemem,0; après l'instruction W contient b'01100111', Casemem est inchangé, C contient 0

Exemple 2: Avant l'instruction, peu importe le contenu de W , f contient b'00110011', et C contient 1

rlf Casemem,f ; après l'instruction W est inchangé, Casemem contient b'01100111' , C contient 0

On peut imposet la valeur de C par bcf ou STATUS,C

Avec C=0 au départ, un rlf revient à multiplier par deux

Nombre de cycles d'horloge: 1

Registre affecté: STATUS, C

RRF f,d

(Rotate right)

f f(n)->dest(n-1), f(0)->C, C->dest(7)

f: (00 à 4F); d: (0 ou 1)

Tous les bits de f sont décalés d'un cran à droite (vers les bits de poids faible)
Le bit STATUS, C passe dans le bit 7
le bit 0 passe dans STATUS, C

Le résultat est mis

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction, peu importe le contenu de W , Casemem contient b'00110011', et C contient 1

rrf Casemem,0 ; après l'instruction W contient b'10011001', Casemem est inchangé, C contient 1

Exemple 2: Avant l'instruction, peu importe le contenu de W , f contient b'00110011', et C contient 1

rlf Casemem,1 ; après l'instruction W est inchangé, Casemem contient b'10011001' , C contient 1

Nombre de cycles d'horloge: 1

Registre affecté: STATUS, C

Avec C=0 au départ, un rrf revient à diviser par deux

SLEEP

(Go into Standby Mode)

0->WDT
stop oscillator
0-> prescaler
1 -> STATUS, NOT_TO
0 -> STATUS, NOT_PD

Met le microcontrôleur en mode d'économie d'énergie

Une boucle contenant SLEEP tournera au rythme imposé par le Watchdog:

Debut

sleep
comf PORTB,F ; produit des signaux carrés sur le port B
goto Debut

Nombre de cycles d'horloge: 1

Registre affecté: STATUS, NO_TO, NOT_PD

SUBLW k

(Subtract W from literal)

k - (W) -> (W)

k: (0 à 255)

Retranche le contenu de W à la valeur k, et met le résultat dans W (méthode du complément à deux)

Exemple 1: Avant l'instruction W contient d'01'

sublw d'02' ; Aprè l'instruction, (W)= d'01', C=1 , Z=0

Exemple 2: Avant l'instruction W contient d'02'

sublw d'02' ; Aprè l'instruction, (W)= d'00', C=1 , Z=1 (résultat nul)

Exemple 3: Avant l'instruction W contient d'03'

sublw d'02' ; Aprè l'instruction, (W)= d'255', C=0 (résultat négatif), Z=0

Nombre de cycles d'horloge: 1

Registre affecté: STATUS, C, DC, Z

SUBWF f,d

(Subtract W from f)

(f) - (W) -> (d)

f: (00 à 4F); d: (0 ou 1)

Retranche le contenu de W au contenu du registre f, (méthode du complément à deux), et met le résultat

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction W contient d'02' , Casemem contient d'03'

subwf Casemem,1 ; Aprè l'instruction, W est inchangé, Casemem contient d'01' , C=1 , Z=0

Exemple 2: Avant l'instruction W contient d'02' , Casemem contient d'02'

subwf Casemem,1 ; Aprè l'instruction, W est inchangé, Casemem contient d'00' , C=1 , Z=1 (résultat =0)

Exemple 3: Avant l'instruction W contient d'02' , Casemem contient d'01'

subwf Casemem,1 ; Aprè l'instruction, W est inchangé, Casemem contient d'01' , C=0 (résultat négatif), Z=0

Nombre de cycles d'horloge: 1

Registre affecté: STATUS, C, DC, Z

SWAPF f,d

(Swap halves f)

f(0:3)<->f(4:7)->d

f: (00 à 4F); d: (0 ou 1)

Prend les 4 bits de poids fort et les met à la place des 4 bits de poids faible

Prend les 4 bits de poids faible et les met à la place des 4 bits de poids fort

et met le résultat

dans W si d=0
dans f si d=1

Exemple 1: Avant l'instruction, peu importe le contenu de W et Casemem contient d'A5'

swapf Casemem,0 ; après l'instruction W contient d'5A' , Casemem contient toujours d'A5'

Exemple 2: Avant l'instruction peu importe le contenu de W et Casemem contient d'123'

swapf Casemem,1 ; après l'instruction le contenu de W n'a pas changé et Casemem contient d'5A'

Nombre de cycles d'horloge: 1

Registre affecté: aucun

XORLW k

(Exclusive OR literal and W)

k XOR (W) -> (W)

k: (0 à 255)

Fait bit à bit l'opération XOR entre le contenu de W et la valeur k, et met le résultat dans W

Exemple: Avant l'instruction W contient b'01101101'

xorlw b'01001110' ; après l'instruction W contient b'00100011'

Cette instruction permet d'inverser certains bits dans W; k devient un masque: les bits à 0 dans le masque ne changeront pas les bits correspondants dans W, les bits à 1 dans le masque iverseront les bits correspondants de W

Nombre de cycles d'horloge:1

Registre affecté: STATUS, Z

XORWF f,d

(Exclusive OR W and f)

(W) XOR (f) -> (d)

f: (00 à 4F); d: (0 ou 1)

Fait bit à bit l'opération XOR entre les contenus de W et de f, et met le résultat

dans W si d=0
dans f si d=1

Exemple1: Avant l'instruction W contient b'01001110' , Casemem contient b'01101101'

xorwf Casemem,0; après l'instruction W contient b'00100011' , Casemem est inchangé

Exemple2: Avant l'instruction W contient b'01001110' , Casemem contient b'01101101'

xorwf Casemem,1; après l'instruction W est inchangé, Casemem contient b'00100011'

Cette instruction permet d'inverser certains bits dans f; (W) devient un masque: les bits à 0 dans le masque ne changeront pas les bits correspondants dans f, les bits à 1 dans le masque iverseront les bits correspondants de f

Nombre de cycles d'horloge:1

Registre affecté: STATUS, Z

Retour au sommaire