PIC Midrange - Set di
istruzioni
|
Le istruzioni dei Midrange
Il set di istruzione dei PIC della famiglia Baseline comprende solo 35
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 una sola word a 14 bit (core a 14-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 14-bit
| |
Bit |
Mnemonico |
Cicli |
Status |
Descrizione |
| 13 |
12 |
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 |
0 |
0 |
NOP |
1 |
- |
Nessuna
operazione |
| 0 |
0 |
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 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
CLRWDT |
1 |
- |
Ricarica
il watchdog timer |
| 0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
CLRW |
1 |
- |
Azzera
il registro W (W = 0) |
| |
|
Operazioni
logiche |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
f |
MOVWF f |
1 |
- |
Copia
W nella destinazione f (W→ f ) |
|
0 |
0 |
1 |
0 |
0 |
1 |
d |
f |
COMF f,d |
1 |
Z |
Complementa il file (d < !f) |
|
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 |
1 |
0 |
1 |
1 |
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 |
0 |
0 |
0 |
1 |
1 |
|
CLRF f |
1 |
- |
Azzera il file (f =
0) |
|
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 |
1 |
d |
f |
RRF f,d |
|
C |
Ruota
il file f a destra nel carry (C<<7 | f>>1 →
dest) |
|
0 |
0 |
1 |
1 |
0 |
0 |
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 |
0 |
0 |
k |
MOVLW k |
1 |
- |
Copia
la costante k in W (k → W ) |
|
1 |
1 |
1 |
0 |
0 |
0 |
k |
IORLW k |
1 |
Z |
Esegue
l' OR bitwise tra W e k ( k | W→ W ) |
|
0 |
0 |
1 |
1 |
1 |
1 |
k |
ANDLW k |
1 |
Z |
Esegue
l' AND bitwise tra W e k (k & W→ W ) |
|
1 |
1 |
1 |
0 |
1 |
0 |
k |
XORLW k |
1 |
Z |
Esegue
l' XOR bitwise tra W e k ( k ^ W→ W ) |
|
1 |
1 |
1 |
1 |
1 |
0 |
k |
ADDLW k |
1 |
C, Z, D |
Somma il literal al contenuto di W |
|
1 |
1 |
1 |
1 |
0 |
0 |
k |
SUBLW k |
1 |
C, Z, D |
Sottrae dal literal al contenuto di W |
| |
|
Chiamate
salti |
1 |
1 |
0 |
1 |
0 |
0 |
k |
RETLW k |
2 |
- |
Copia
k in W e ritorna dalla subroutine |
|
1 |
0 |
0 |
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) |
|
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
RETURN |
2 |
- |
Return from subroutine |
|
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
RETFIE |
2 |
- |
Return from interrupt |
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 il default 1, ma esegue comunque la
compilazione.
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
:
| ADDLW |
Add W and Literal, somma W e la costante
literal. Il risultato modifica i flag C, DC, Z dello STATUS
Esempio:
movlw 1
; W = 1
addlw 5
;
W = 1 + 5 flag C,DC, Z = 0
movlw 0xFF
; W = FFh
addlw 1
; W = FFh + 1 = 00 flag Z = 1
|
| ADDWF |
Add W and f, somma W e f. Il risultato può
essere diretto a f o a W. 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. Il risultato può essere diretto a f o a
W. 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 modifica lo STATUS.
Esempio:
bcf STATUS, C ; flag C = 0
|
| BSF |
Bit Set on File, porta a 1 il bit b indicato nel file
f indicato. Non modifica lo STATUS.
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. Non modifica lo STATUS.
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. Non modifica lo STATUS.
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. Non modifica lo STATUS.
Esempio:
call subroutine1 ; salta all' esecuzione della
subroutine1
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. L' indirizzo della subroutine ha
11
bit di spazio, quindi
sono indirizzabili 2K. Per quantità maggiori si
utilizzano i bit PCLATH<4:3>.
|
| CLRF |
Clear file, azzera il contenuto del file f indicato. Il
flag Z viene settato.
Esempio:
clrf target ; target = 0
|
| CLRW |
Clear W. Come sopra, ma specifica per il registro W.
Modifica il flag Z.
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. Non modifica lo
STATUS.
Il codice contiene l' indirizzo a 11 bit della destinazione. Questo
permette di indirizzare direttamente fino a 2 k. Per quantità maggiori
si utilizza il sistema delle pagine, con i due bit più
significativi forniti dal PCLATH < 4:3.>
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. 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. Non
modifica lo STATUS.
Esempio:
nop
; spende 1 ciclo senza alcuna operazione
|
| OPTION |
Load OPTION register with W, carica il
registro OPTION con il contenuto di W. Non modifica flag dello
STATUS.
Esempio:
OPTION
Opcode obsoleto e da non utilizzare.
|
| RESET |
Software Reset, effettua un reset da software.
Viene settato il flag RI in PCON.
|
| RETFIE |
Return from Interrupt, effettua il rientro al
termine della gestione dell' interruzione. Richiede due cicli. Non modifica
lo STATUS.
|
| RETLW |
Return with literal in W, rientra da subroutine con la
costante k in W. Richiede 2 cicli. Non modifica lo STATUS. 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 che deve contenere l' indirizzo di ritorno al flusso in cui era
stata sospesa l' esecuzione per avviare la subroutine.
|
| RETURN |
Return from subroutine, rientra da subroutine. Richiede 2 cicli.
Non modifica lo STATUS.
|
| 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 C, Z, DC.
|
| SUBLW |
Subtract W from Literal, sottrae il valore di W
dal Literal indicato. Il risultato va in W. Modifica TO, PD.
|
| 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 with W, carica W nel
registro TRIS. Non modifica lo
STATUS.
Opcode obsoleto e da non utilizzare.
|
| 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, rispetto ai Baseline:
- poichè esiste gestione di interrupt è prevista l' istruzione RETFIE
- esiste sia una istruzione RETURN
che la RETLW.
- esiste l' istruzione SUBLW
e ADDLW.
- OPTION e
TRIS
sono da considerare obsoleti e non vanno utilizzati.
Inoltre:
- lo stack è a 8 livelli
- 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.
- Pagine
e banchi nei Midrange
|
