PIC Baseline - Set di
istruzioni
|
Le istruzioni dei Baseline
Il set di istruzione dei PIC della famiglia Baseline comprende solo 33
opcode. Come solito per i PIC, buona parte di essi richiede un solo
ciclo per la sua esecuzione, anche se esistono istruzioni di salto o
scelta che ne richiedono 2.
Per un clock (Fosc) di 4MHz, il ciclo dell' istruzione dipende da Fosc/4 =
1MHz ed è quindi di 1 us. Per un clock di 8MHz il ciclo sarà di 500ns.
Le istruzione sono codificate su 12 bit (core a 12-bit). Di
questi, parte sono dedicati al codice vero e proprio (i bit più
significativi, da 3 a 10), mentre i rimanenti
contengono alcuni elementi per l' esecuzione dell' istruzione:
- f è il registro (file) che concorre all' istruzione.
Comprende la RAM e i registri speciali SFR.
- d è la destinazione del risultato dell' istruzione. Una
particolarità delle istruzioni PIC è quella di poter indirizzare il
risultato sia al registro W sia ad un altro registro della memoria RAM
- b è il bit su cui eseguire l' operazione
- k è un valore inteso come costante numerica
Da notare che, per
Microchip, valgono alcune convenzioni:
- una costante numerica prende il nome di "literal"
- un "file" è una locazione di RAM dati o un registro SFR
ossiamo fare una divisone delle istruzioni in funzione della loro
azione:
- istruzioni speciali, necessarie per accedere a registri
particolari (tris, option)
e/o prive della necessità di un oggetto
- istruzioni orientate ad operazioni logiche, con la
destinazione ed il "file" su cui operare
- istruzioni orientate al bit, con il bit ed il
"file" su cui operare
- istruzioni che operano su costanti, che hanno in oggetto la
costante "literal". Utilizzano l' appoggio del registro W.
- istruzioni di salto, che modificano il PC
La tabella seguente le raccoglie in queste divisioni:
Set
istruzioni per PIC con core a 12-bit
| |
Bit |
Mnemonico |
Cicli |
Status |
Descrizione |
| 11 |
10 |
9 |
8 |
7 |
6 |
5 |
4 |
3 |
2 |
1 |
0 |
| |
Istruzioni
speciali |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
NOP |
1 |
- |
Nessuna
operazione |
| 0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
OPTION |
1 |
T0, PD |
Copia
W nel registro OPTION |
| 0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
SLEEP |
1 |
T0, PD |
Va
in modalità sleep |
| 0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
CLRWDT |
1 |
- |
Ricarica
il watchdog timer |
| 0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
CLRW |
1 |
- |
Azzera
il registro W (W = 0) |
| 0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
f |
TRIS f |
1 |
- |
Copia
W nel registro tri-state (f =
1, 2 o 3) |
| |
|
Operazioni
logiche |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
f |
MOVWF f |
1 |
- |
Copia
W nella destinazione f (W→ f ) |
| 0 |
0 |
0 |
0 |
0 |
1 |
d |
f |
CLRF f,d |
1 |
Z |
Azzera
la destinazione f (f = 0) |
| 0 |
0 |
0 |
0 |
1 |
0 |
d |
f |
SUBWF f,d |
1 |
C, Z |
Scrive in f il risultato di f-W ( f - W→ dest) |
| 0 |
0 |
0 |
0 |
1 |
1 |
d |
f |
DECF f,d |
1 |
Z |
Decrementa
di una unità il registro f (f−1→ dest) |
| 0 |
0 |
0 |
1 |
0 |
0 |
d |
f |
IORWF f,d |
1 |
Z |
Esegue
l' OR inclusivo tra W e f ( f | W→ dest)) |
| 0 |
0 |
0 |
1 |
0 |
1 |
d |
f |
ANDWF f,d |
1 |
Z |
Esegue
l' AND tra W e f (f & W→ dest ) |
| 0 |
0 |
0 |
1 |
1 |
0 |
d |
f |
XORWF f,d |
1 |
Z |
Esegue
l' OR esclusivo tra W e f ( f ^ W→ dest ) |
| 0 |
0 |
0 |
1 |
1 |
1 |
d |
f |
ADDWF f,d |
1 |
C,
Z,DC
|
Esegue
la somma tra W e f ( f+W→ dest )) |
| 0 |
0 |
1 |
0 |
0 |
0 |
d |
f |
MOVF f,d |
1 |
Z |
Copia
f nella destinazione (f → dest ) |
| 0 |
0 |
1 |
0 |
0 |
1 |
d |
f |
COMF f,d |
1 |
Z |
Complementa
f nella destinazione (~f → dest ) |
| 0 |
0 |
1 |
0 |
1 |
0 |
d |
f |
INCF f,d |
1 |
Z |
Incrementa
di una unità il registro f (f +1→ dest) |
| 0 |
0 |
1 |
0 |
1 |
1 |
d |
f |
DECFSZ f,d |
1-1 |
- |
Decrementa
il registro f (f−1→ dest) e se =0 salta l' istruzione
successiva |
| 0 |
0 |
1 |
1 |
0 |
0 |
d |
f |
RRF f,d |
|
C |
Ruota
il file f a destra nel carry (C<<7 | f>>1 →
dest) |
| 0 |
0 |
1 |
1 |
0 |
1 |
d |
f |
RLF f,d |
1 |
C |
Ruota
il file f a sinistra nel carry (C<<7 | f>>1
→ dest) |
| 0 |
0 |
1 |
1 |
1 |
0 |
d |
f |
SWAPF f,d |
1 |
- |
Swap
nibbles (f<<4 | f>>,→ dest) |
| 0 |
0 |
1 |
1 |
1 |
1 |
d |
f |
INCFSZ f,d |
1-2 |
- |
Incrementa
il registro f (f−1→ dest) e se =0 salta l' istruzione
successiva |
| |
|
Operazioni
su bit |
0 |
1 |
0 |
0 |
b |
f |
BCF f,b |
1 |
|
Manda
a 0 il bit b nel registro f |
| 0 |
1 |
0 |
1 |
b |
f |
BSF f,b |
1 |
|
Manda
a 1 il bit b nel registro f |
| 0 |
1 |
1 |
0 |
b |
f |
BTFSC f,b |
1-2 |
|
Salta
istruzione successiva se il bit b è a 0 |
| 0 |
1 |
1 |
1 |
b |
f |
BTFSS f,b |
1-2 |
|
Salta
istruzione successiva se il bit b è a 1 |
| |
|
Operazioni
su literal |
1 |
1 |
0 |
0 |
k |
MOVLW k |
1 |
- |
Copia
la costante k in W (k → W ) |
| 1 |
1 |
0 |
1 |
k |
IORLW k |
1 |
Z |
Esegue
l' OR bitwise tra W e k ( k | W→ W ) |
| 1 |
1 |
1 |
0 |
k |
ANDLW k |
1 |
Z |
Esegue
l' AND bitwise tra W e k (k & W→ W ) |
| 1 |
1 |
1 |
1 |
k |
XORLW k |
1 |
Z |
Esegue
l' OR escl. bitwise tra W e k ( k ^ W→ W ) |
| |
|
Chiamate
salti |
1 |
0 |
0 |
0 |
k |
RETLW k |
2 |
- |
Copia
k in W e ritorna dalla subroutine |
| 1 |
0 |
0 |
1 |
k |
CALL k |
2 |
- |
Chiama
subroutine con indirizzo k (8 bit) |
| 1 |
0 |
1 |
k |
GOTO k |
2 |
- |
Porta
il PC all' indirizzo k (9 bit) |
Le istruzioni che prevedono movimentazione del PC (goto,
call, retlw) richiedo due cicli per l' esecuzione; quelle di
branch condizionato (btfss, btfsc,
decfsz,
incfsz) ne richiedono due se il branch è eseguito. Questo è
necessario dato che il sistema di fetch delle istruzioni deve scaricare il
PC dal valore consecutivo e caricare invece quello del salto.
Alcune istruzioni modificano i flag dello STATUS, principalmente il
flag Z che va a 1 se il risultato dell'operazione è 0 e il flag Carry che
va a1 se esiste un riporto. Il flag DC viene utilizzato principalmente
nelle conversioni hex-bcd. Non esiste un flag N.
Le istruzioni di branch condizionato (btfss,
btfsc,decfsz, incfsz) non modificano lo STATUS, dato che il
condizionamento serve già di per se a determinare una azione.
Una caratteristica di queste istruzioni è il concetto di destinazione d:
il risultato di alcune operazioni può essere salvato sia nel registro W
sia nel registro f che partecipa all' operazione. In generale:
- se d
= 0 il risultato è salvato in W
- se d = 1 il risultato è salvato in f
Da notare che l' Assembler MPASM :
- riserva gli opcodes esclusivamente a questa funzione. Per cui, se si
cerca di usarli come label generiche, si determina un errore di
compilazione
- MPASM accetta il formato degli opcodes sia in lettere maiuscole che
minuscole, per cui XORLW o
xorlw sono
equivalenti
- f e k
possono essere sostituiti da label
- la forma delle istruzioni che richiedono file e destinazione viene
semplificata da MPASM che non necessita dei valori 1 e 0 per d,
ma li può accettare nella forma w
(per 0) e f (per 1).
Quindi si potrà scrivere indifferentemente:
- decf file, 1
oppure decf
file, f
- decf file, 0
oppure decf
file, w.
Se si omette l' indicazione della destinazione l' Assembler genera
un warning ed utilizza nella compilazione il default 1.
La sintassi per una riga contenete una istruzione è la seguente:
<label>
istruzione
<oggetto>
;<commento>
Le regole sono:
- l' istruzione non può iniziare nella prima colonna. Un label,
invece, inizia obbligatoriamente in prima colonna.
- occorre uno spazio almeno tra la label opzionale e l' opcode
- tra istruzione ed oggetto va riservato almeno uno spazio
Le istruzioni, in maggiore dettaglio e in ordine alfabetico:
| ADDWF |
Add W and f, somma W e f. Il risultato modifica i flag C,
DC, Z dello STATUS
Esempio:
movlw 1
; W = 1
movwf target ;
W -> target = 1
movlw 5
; W = 5
addwf target,f ;
W + target -> target = 5 + 1 = 6 C,DC, Z = 0
movlw 0xFF
; W = FFh
movwf target ;
target = W = FFh
movlw 1
; W = 1
addwf target,W ;
W + target -> W = FFh + 1 = 0 flag Z = 1
|
| ANDLW |
AND literal with W, esegue l' AND bitwise tra il
contenuto di W e quello della costante k. Viene modificato il flag
Z.
Esempio:
movlw 0xA5
; W = A5h
andlw b'00001111' ;
W = W and 0Fh = 5
|
| ANDWF |
AND W with f, esegue l' AND bitwise tra il contenuto di W
e quello del registro f. Viene modificato il flag Z.
Esempio:
movlw 1
; W = 1
movwf target ;
W -> target = 1
movlw 5
; W = 5
andwf
target,f ; target = W target =
5 1 = 1
|
| BCF |
Bit Clear on File, azzera il bit b indicato nel file f
indicato. Non si applica al registro W.
Esempio:
bcf STATUS, C ; flag C = 0
|
| BSF |
Bit Set on File, porta a 1 il bit b indicato nel file
f indicato. Non si applica al registro W.
Esempio:
bsf STATUS, C ; flag C = 1
|
| BTFSC |
Bit Test f, Skip if clear, verifica lo stato del bit b nel
file f e salta l' istruzione successiva se risulta a 0. Richiede 2
cicli se il branch è eseguito.
Esempio:
btfsc STATUS, C ; salta istruzione successiva se
C=0
|
| BTFSS |
Bit Test f, Skip if set, verifica lo stato del bit b nel
file f e salta l' istruzione successiva se risulta a 1. Richiede 2
cicli se il branch è eseguito.
Esempio:
btfsc STATUS, Z ; salta istruzione successiva se
Z=1
|
| CALL |
Subroutine Call, porta il PC all' inizio della subroutine
indicata. E' una istruzione a due cicli.
Esempio:
call subroutine1 ; salta all' esecuzione della
subroutine1
 |
L' indirizzo della subroutine ha 8 bit di spazio, quindi
sono indirizzabili i primi 256 bytes di ogni pagina |
 |
Per PIC con quantità maggiori si utilizza il sistema
delle pagine, con i due bit più significativi forniti per
il PCLATH dai bit PR1:0 dello STATUS. |
Il meccanismo di esecuzione della call consiste nel salvataggio
dell' indirizzo dell'istruzione seguente nello stack e nella
sostituzione nel PC con l' indirizzo della subroutine chiamata. Al
termine della subroutine, una istruzione retlw sostituirà nel PC l'
indirizzo successivo con quello prelevato dallo stack, facendo
rientrare l' esecuzione al punto in cui era stata abbandonata.
Da osservare che i Baseline hanno uno stack a due soli livelli,
quindi occorre aver cura di non utilizzare più di due chiamate di
subroutine annidate. |
| CLRF |
Clear file, azzera il contenuto del file f indicato. Il
flag Z viene settato. Non applicabile a W.
Esempio:
clrf target ; target = 0
|
| CLRW |
Clear W. Come sopra, ma specifica per il registro W. Istruzione
equivalente a:
movlw 0 ; W = 0
Esempio:
clrw ; W = 0
|
| CLRWDT |
Clear WD Timer, ricarica il timer del watchdog. Modifica i
flag TO e PD delleo STATUS.
Esempio:
clrwdt ; ricarica il WDT
|
| COMF |
Complement f, esegue il complemento a 1 del file f
indicato, ovvero l' inversione del valore dei bit contenuti.
Modifica il flag Z.
Esempio:
movlw B’11001010’ ; W = CAh
movwf target ; target = W = CAh
comf target,w ; W = b'00110101'
|
| DECF |
Decrement file, diminuisce di uno il file f indicato.
Modifica il flag Z.
Esempio:
decf target, f
;
target = target - 1
decf target, w
; W =
target - 1
movlw 1
; W = 1
movwf target
; target = W = 1
decf target, f
;
target = target11=1-1=0 , Flag Z= 1
|
| DECFSZ |
Decrement file, skip if 0, decrementa di una unità il file
f indicato e salta la successiva istruzione se il f va a 0. Il
risultato del decremento può andare in f o in W. Non modifica lo
STATUS.
Esempio:
movlw 8
; W = 8
movwf counter
; counter = W = 8
loop decfsz counter, f
; counter = counter -1 ; se counter = 0 salta
; istruzione successiva
goto loop
; se counter diverso da 0 ricicla
....
; prosegue con le istruzioni
|
| GOTO |
Unconditional branch, salto incondizionato. Richiede 2
cicli per l' esecuzione.
Il codice contiene l' indirizzo a 9 bit della destinazione. Questo
permette di indirizzare direttamente fino a 512 k, ovvero una
pagina. Questo è adeguato per i piccoli PIC che hanno appunto un
massimo di 512k di memoria programma. Per PIC con quantità maggiori
si utilizza il sistema delle pagine, con i due bit più
significativi forniti per il PCLATH dai bit PA2:0 dello STATUS.
Esempio:
goto target ; PC=
indirizzo di target
|
| INCF |
Increment file, aumenta di una unità il file f indicato.
Il risultato del decremento può andare in f o in W. Modifica il
flag Z dello STATUS.
Esempio:
incf target, w
; W =
target +1
movlw 0xFF
; W = 255 dec.
movwf target
; target = W = 255
incf target, f
;
target = target+1=FFh+1=00 , Flag Z= 1
|
| INCFSZ |
Increment file, skip if 0, incrementa di una unità il file
f indicato e salta la successiva istruzione se il f va a 0. Il
risultato del decremento può andare in f o in W. Non modifica lo
STATUS.
Esempio:
movlw 0xFF-8
; W = 247 dec.
movwf counter
; counter = W = 247
loop incfsz counter, f
; counter = counter +1 ; se counter = 0 salta
; istruzione successiva
goto loop
; se counter diverso da 0 ricicla
....
; prosegue con le istruzioni
|
| IORLW |
Inclusive OR literal with W, effettua l' OR inclusivo
bitwise tra il contenuto di W e la costante k. Il risultato va
in W. Modifica il flag Z.
Esempio:
movlw D3
; W = D3
iorlw b'11110000' ; W = W ior F0h =
F3h
|
| IORWF |
Inclusive OR Wwith f, effettua l' OR inclusivo bitwise tra
il contenuto di W e quello del file f. Il risultato va in W.
Il risultato può andare in f o in W. Modifica il flag Z dello
STATUS.
Esempio:
movlw 0xD3
; W = D3h
movwf target
; target = D3h
movlw 0x0F
; W = 0Fh
iorwf target, f ; target =
target ior W = D3h 0Fh=DFh
|
| MOVF |
Move file, copia il contenuto del file f nella destinazione
d, che può essere il registro W o il file stesso. Modifica il flag
Z dello STATUS.
Esempio:
movf target, w
; W =
target
clrf target
; target = 0
movf target, w
; W =
target = 0 , Flag Z= 1
|
| MOVLW |
Move literal to W, copia in W la costante k. Non modifica
lo STATUS.
Esempio:
movlw 0xEA
; W = EAh
movlw .127
; W = 127 dec
movlw b'00011000' ; W = 18h
|
| MOVWF |
Move W to file, copia il contenuto di W nel file f. Non
modifica lo STATUS.
Esempio:
movwf target
; target = W
|
| NOP |
No operation, non esegue alcuna operazione.
Esempio:
nop
; spende 1 ciclo senza alcuna operazione
|
| OPTION |
Load OPTION register, istruzione speciale che copia il
contenuto di W nel registro OPTION. Non modifica lo STATUS.
Esempio:
movlw b'00001101' ; W = 0Dh
option
; OPTION_REG = W = 0Dh
Questo opcode non è più utilizzato nelle altre famiglie di PIC.
|
| RETLW |
Return with literal in W, rientra da subroutine con la
costante k in W. Richiede 2 cicli.
Esempio:
retlw 0 ; rientra da una call con W = 0
Il valore di ritorno può essere usato come indicatore:
Esempio:
btfsc STATUS, Z ; test sul flag
Z
retlw 1
; se Z=1, rientra con W=1
retlw 0
; se Z=0, rientra con W=0
Il meccanismo dell' istruzione è il seguente: il contenuto del PC
viene scartato e sostituito con il contenuto dello stack. Esso
dovrebbe contenere l' indirizzo di ritorno al flusso in cui era
stata sospesa l' esecuzione per avviare la subroutine.
Da osservare che i Baseline hanno uno stack a due soli
livelli, quindi occorre aver cura di non utilizzare più di due
chiamate di subroutine annidate.
|
| RLF |
Rotate left file through Carry, ruota il file f a sinistra
attraverso il Carry. Il risultato può andare in f o in W. Modifica
il flag C dello STATUS.
Esempio:
clrf target ; target = 0
bsf STATUS, C ; flag C = 1
rrf target, f ; target = b'00000001" , C=0
|
| RRF |
Rotate right file through Carry, ruota il file f a destra
attraverso il Carry. Il risultato può andare in f o in W. Modifica
il flag C dello STATUS.
Esempio:
movlw 0x81 ; W = b'10000001'
movwf target ; target = W = b'10000001'
bcf STATUS, C ; flag C = 0
rrf target, f ; target = b'010000000" , C=1
|
| SLEEP |
Enter Sleep mode, forza la modalità di standby sleep a
baso consumo. Modifica TO, PD.
Esempio:
sleep
; passa in modo sleep
|
| SUBWF |
Subtract W from file, sottrae il contenuto di W da quello
di f. Il risultato può andare in f o in W. Modifica i flag C, Z e
DC dello STATUS.
Esempio:
movlw .100 ; W = 100 dec.
movwf target ; W -> target = 100 dec
movlw 0xFF ; W = FFh (255 dec)
subwf target,f ; target = W - target = 255 + 100 = 155 dec
movlw .32
; W = 32 dec.
movwf target ; W -> target = 32 dec
movlw 0x1F ; W = 1Fh (31 dec)
subwf target,f ; target = W - target = 32 + 31 = 1 Flag
C=1, Z=0
|
| SWAPF |
Swap nibbles in file, scambia il nibble alto e quello basso
nel file f. Il risultato può andare in f o in W. Non modifica lo
STATUS.
Esempio:
movlw 0x0F ; W = b'00001111'
movwf target ; target = W = b'00001111'
swapf target,f ; target = b'11110000'
|
| TRIS |
Load Tris register, istruzione speciale che copia il
contenuto di W nel registro di direzione degli I/O digitali.
Esempio:
movlw b'00001111' ; W = 0Fh
tris
; TRIS_REG = W = 0Fh
Questo opcode non è più utilizzato nelle altre famiglie di PIC.
|
| XORLW |
Exclusive OR literal with W, esegue l' OR
esclusivo XOR bitwise tra i contenuto di W e la costante k.
Il risultato può andare in f o in W. Modifica il flag Z dello
STATUS.
Esempio:
movlw 0xA5 ; W = A5h
xorlw 0xFF ; W = b'10100101' b'11111111'
= b'01011010' =5Ah
|
| XORWF |
Exclusive OR file with W, esegue l' OR esclusivo bitwise
tra i contenuto di W e quello del file f. Il risultato può
andare in f o in W. Modifica il flag Z dello STATUS.
Esempio:
movlw 0xA5 ; W = A5h
movwf target ; target = W = A5h
movlw 0xFF ; W = FFh
xorwf target, w ; W = W target = 5Ah
|
Da notare che nei Baseline:
- non esiste gestione di interrupt e quindi istruzioni relative
- non esiste una istruzione RETURN
per il rientro da subroutine, sostituita dalla RETLW.
- non esiste l' istruzione SUBLW,
nè ADDLW.
- data la limitatezza delle risorse, il caricamento dei registri
speciali OPTION e TRIS
è effettuato con due istruzioni speciali. Il due registri sono quindi
scrivibili, ma non rileggibili.
- SUBWF non
effettua l' operazione W- f , bensì f - W.
- DECF
e INCF
agiscono sul flag Z, ma DECFSZ
e INCFSZ
non lo fanno. La ragione è evidente: queste ultime contengono in se
l' analisi del risultato 0 per il registro.
- MOVLW
e RETLW
non agiscono sul flag Z.
- MOVLW
registro, f
sembra inutile, ma in effetti agisce sul flag Z e indica un
contenuto 0 del registro.
Inoltre, l' Assembler MPASM riconosce vari pseudo
opcodes.
|
