|
Apêndice A
Conjunto
de Instruções
A.1 MOVLW Escrever constante no registo W
|
Sintaxe: |
[rótulo]
MOVLW k |
|
Descrição: |
A constante de 8-bits k vai para o registo
W. |
|
Operação: |
k
Þ
(
W ) |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
MOVLW
0x5A |
|
Depois da instrução: W= 0x5A |
|
Exemplo
2: |
MOVLW
REGISTAR |
|
Antes da
instrução: W = 0x10 e REGISTAR = 0x40 |
|
Depois da instrução: W = 0x40 |
A.2 MOVWF Copiar W para f
|
Sintaxe: |
[rótulo]
MOVWF f |
|
Descrição: |
O
conteúdo do registo W é copiado para o registo
f |
|
Operação: |
W
Þ
(
f ) |
|
Operando: |
0
£
f
£
127 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
MOVWF
OPTION_REG |
|
Antes da
instrução: OPTION_REG = 0x20 |
|
W = 0x40 |
|
Depois
da instrução:
OPTION_REG = 0x40 |
|
W = 0x40 |
|
Exemplo
2: |
MOVWF
INDF |
|
Antes da instrução: W = 0x17 |
|
FSR =
0xC2 |
|
Conteúdo
do endereço 0xC2 = 0x00 |
|
Depois da instrução: W = 0x17 |
|
FSR =
0xC2 |
|
Conteúdo
do endereço 0xC2 = 0x17 |
A.3 MOVF Copiar f para d
|
Sintaxe: |
[rótulo]
MOVF f, d |
|
Descrição: |
O
conteúdo do registo f é guardado no local determinado pelo
operando d |
|
Se d
= 0, o destino é o registo W |
|
Se d
= 1, o destino é o próprio registo f |
|
A opção
d = 1, é usada para testar o conteúdo do registo f,
porque a execução desta instrução afecta a flag Z do registo STATUS. |
|
Operação: |
f
Þ
(
d ) |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
MOVF FSR, 0 |
|
Antes da instrução: FSR = 0xC2 |
|
W = 0x00 |
|
Depois da instrução: W = 0xC2 |
|
Z = 0 |
|
Exemplo
2: |
MOVF
INDF, 0 |
|
Antes da
instrução: W = 0x17 |
|
FSR = 0xC2 |
|
conteúdo do endereço 0xC2 = 0x00 |
|
Depois da instrução: W = 0x00 |
|
FSR = 0xC2 |
|
conteúdo do endereço 0xC2 = 0x00 |
|
Z
= 1 |
A.4 CLRW
Escrever 0 em W
|
Sintaxe: |
[rótulo]
CLRW |
|
Descrição: |
O conteúdo do registo W passa para 0 e a flag
Z do registo STATUS toma o valor 1. |
|
Operação: |
0
Þ
( W ) |
|
Operando: |
- |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo: |
CLRW |
|
Antes da
instrução: W = 0x55 |
|
Depois
da instrução: W = 0x00 |
|
Z
= 1 |
A.5 CLRF Escrever 0 em f
|
Sintaxe: |
[rótulo]
CLRF f |
|
Descrição: |
O conteúdo do registo ‘f’ passa para 0 e a
flag Z do registo STATUS toma o valor 1. |
|
Operação: |
0
Þ
f |
|
Operando: |
0
£
f
£
127 |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
CLRF
STATUS |
|
Antes da
instrução: STATUS = 0xC2 |
|
Depois
da instrução: STATUS = 0x00 |
|
Z = 1 |
|
Exemplo
2: |
CLRF
INDF |
|
Antes da
instrução: FSR = 0xC2 |
|
conteúdo
do endereço 0xC2 = 0x33 |
|
Depois
da instrução: FSR
= 0xC2 |
|
conteúdo
do endereço 0xC2 = 0x00 |
|
Z
= 1 |
A.6 SWAPF
Copiar o conteúdo de f para d, trocando a posição dos 4 primeiros bits
com a dos 4 últimos
|
Sintaxe: |
[rótulo]
SWAPF f, d |
|
Descrição: |
Os 4
bits + significativos e os 4 bits – significativos de f, trocam de
posições. |
|
Se d
= 0, o resultado é guardado no registo
W |
|
Se d = 1, o resultado é guardado no registo
f |
|
Operação: |
f <0:3>Þ
d <4:7>, f <4:7>Þ
d <0:3>, |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
SWAPF
REG, 0 |
|
Antes da instrução: REG = 0xF3 |
|
Depois
da instrução: REG = 0xF3 |
|
W = 0x3F |
|
Exemplo
2: |
SWAPF
REG, 1 |
|
Antes da
instrução: REG = 0xF3 |
|
Depois da instrução: REG = 0x3F |
A.7 ADDLW
Adicionar W a uma constante
|
Sintaxe: |
[rótulo]
ADDLW k |
|
Descrição: |
O conteúdo do registo W, é adicionado à
constante de 8-bits k e o resultado é guardado no registo
W. |
|
Operação: |
( W ) + k
Þ
W |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
C,
DC, Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
ADDLW
0x15 |
|
Antes da
instrução: W= 0x10 |
|
Depois da instrução: W= 0x25 |
|
Exemplo
2: |
ADDLW REG |
|
Antes da instrução: W = 0x10 |
|
REG = 0x37 |
|
Depois da instrução: W = 0x47 |
A.8 ADDWF
Adicionar W a f
|
Sintaxe: |
[rótulo]
ADDWF f, d |
|
Descrição: |
Adicionar os conteúdos dos registos W e
f |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
(W)
+ ( f )
Þ
d,
d
Î
[0, 1] |
|
Operando: |
0
£
f
£
127 |
|
Flag: |
C,
DC, Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
ADDWF
FSR, 0 |
|
Antes da
instrução:
W = 0x17 |
|
FSR =
0xC2 |
|
Depois
da instrução: W = 0xD9 |
|
FSR = 0xC2 |
|
Exemplo
2: |
ADDWF
INDF,0 |
|
Antes da
instrução:
W = 0x17 |
|
FSR =
0xC2 |
|
conteúdo
do endereço 0xC2 = 0x20 |
|
Depois
da instrução: W = 0x37 |
|
FSR =
0xC2 |
|
Conteúdo do endereço 0xC2 = 0x20 |
A.9 SUBLW
Subtrair W a uma constante
|
Sintaxe: |
[rótulo]
SUBLW k |
|
Descrição: |
O conteúdo do registo W, é subtraído à
constante k e, o resultado, é guardado no registo W. |
|
Operação: |
k
- ( W )
Þ
W |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
C,
DC, Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
SUBLW
0x03 |
|
Antes da instrução: W= 0x01, C = x, Z = x |
|
Depois da instrução: W= 0x02, C = 1, Z =
0 Resultado > 0 |
|
Antes da
instrução: W= 0x03, C = x, Z = x |
|
Depois da instrução: W= 0x00, C = 1, Z = 1 Resultado =
0 |
|
Antes da
instrução: W= 0x04, C = x, Z = x |
|
Depois da instrução: W= 0xFF, C = 0, Z =
0 Resultado < 0 |
|
Exemplo
2: |
SUBLW
REG |
|
Antes da
instrução: W = 0x10 |
|
REG =
0x37 |
|
Depois
da instrução: W = 0x27 |
|
C = 1 Resultado > 0 |
A.10 SUBWF
Subtrair W a f
|
Sintaxe: |
[rótulo]
SUBWF f, d |
|
Descrição: |
O
conteúdo do registo W é subtraído ao conteúdo do registo
f |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
( f ) - (W)
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
C,
DC, Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo: |
SUBWF
REG, 1 |
|
Antes da
instrução: REG= 3, W= 2, C = x, Z = x |
|
Depois da instrução: REG= 1, W= 2, C = 1, Z =
0 Resultado > 0 |
|
Antes da
instrução: REG= 2, W= 2, C = x, Z = x |
|
Depois da instrução: REG=0, W= 2, C = 1, Z = 1
Resultado = 0 |
|
Antes da
instrução: REG=1, W= 2, C = x, Z = x |
|
Depois da instrução: REG= 0xFF, W=2, C = 0, Z =
0 Resultado < 0 |
A.11 ANDLW
Fazer o “E” lógico de W com uma constante
|
Sintaxe: |
[rótulo]
ANDLW k |
|
Descrição: |
É executado o
“E” lógico do conteúdo do registo W, com a constante
k |
|
O resultado é guardado no registo
W. |
|
Operação: |
( W ) .AND. k
Þ
W |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
ANDLW
0x5F |
|
Antes da
instrução: W= 0xA3 ;
0101 1111
(0x5F) |
|
;
1010
0011 (0xA3) |
|
Depois da instrução: W=
0x03; 0000 0011 (0x03) |
|
Exemplo
2: |
ANDLW
REG |
|
Antes da
instrução: W = 0xA3 ; 1010 0011 (0xA3) |
|
REG = 0x37 ;
0011 0111 (0x37) |
|
Depois da instrução: W =
0x23 ; 0010 0011 (0x23) |
A.12 ANDWF
Fazer o “E” lógico de W com f
|
Sintaxe: |
[rótulo]
ANDWF f, d |
|
Descrição: |
Faz o “E” lógico dos conteúdos dos registos W
e f |
|
Se d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
(W) .AND. ( f )
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
ANDWF
FSR, 1 |
|
Antes da
instrução: W= 0x17, FSR= 0xC2; 0001 1111 (0x17) |
|
;
1100
0010 (0xC2) |
|
Depois da instrução: W= 0x17, FSR= 0x02
;
0000
0010 (0x02) |
|
Exemplo
2: |
ANDWF
FSR, 0 |
|
Antes da
instrução: W= 0x17, FSR= 0xC2; 0001 1111 (0x17) |
|
; 1100
0010 (0xC2) |
|
Depois da instrução: W= 0x02, FSR=
0xC2; 0000 0010 (0x02) |
A.13 IORLW
Fazer o “OU” lógico de W com uma constante
|
Sintaxe: |
[rótulo]
IORLW k |
|
Descrição: |
É executado o “OU” lógico do conteúdo do registo W,
com a constante de 8 bits k, o resultado é guardado no
registo W. |
|
Operação: |
( W ) .OR. k
Þ
W |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
IORLW
0x35 |
|
Antes da
instrução: W= 0x9A |
|
Depois
da instrução: W= 0xBF |
|
Z= 0 |
|
Exemplo
2: |
IORLW
REG |
|
Antes da
instrução: W = 0x9A |
|
conteúdo
de REG = 0x37 |
|
Depois da instrução: W = 0x9F |
|
Z = 0 |
A.14 IORWF
Fazer o “OU” lógico de W com f
|
Sintaxe: |
[rótulo]
IORWF f, d |
|
Descrição: |
Faz o
“OU” lógico dos conteúdos dos registos W e
f |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
(W)
.OR. ( f )
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
IORWF
REG, 0 |
|
Antes da
instrução: REG= 0x13, W= 0x91 |
|
Depois
da instrução: REG= 0x13, W= 0x93 |
|
Z= 0 |
|
Exemplo
2: |
IORWF
REG, 1 |
|
Antes da
instrução: REG= 0x13, W= 0x91 |
|
Depois
da instrução: REG= 0x93, W= 0x91 |
|
Z= 0 |
A.15 XORLW
“OU- EXCLUSIVO” de W com uma constante
|
Sintaxe: |
[rótulo]
XORLW k |
|
Descrição: |
É executada a operação “OU-Exclusivo” do conteúdo do
registo W, com a constante k.
O resultado é guardado no registo
W. |
|
Operação: |
( W ) .XOR. k
Þ
W |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
XORLW
0xAF |
|
Antes da
instrução: W= 0xB5 ; 1010 1111 (0xAF) |
|
;
1011 0101 (0xB5) |
|
Depois da instrução: W= 0x1A;
0001 1010 (0x1A) |
|
Exemplo
2: |
XORLW
REG |
|
Antes da
instrução: W = 0xAF ; 1010 1111 (0xAF) |
|
REG = 0x37 ; 0011
0111 (0x37) |
|
Depois
da instrução: W = 0x98 ; 1001 1000 (0x98) |
|
Z = 0 |
A.16 XORWF
“OU-EXCLUSIVO” de W com f
|
Sintaxe: |
[rótulo]
XORWF f, d |
|
Descrição: |
Faz o
“OU-EXCLUSIVO” dos conteúdos dos registos W e
f |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
(W) .XOR. ( f )
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
XORWF
REG, 1 |
|
Antes da instrução: REG= 0xAF, W= 0xB5
; 1010 1111 (0xAF) |
|
; 1011
0101 (0xB5) |
|
Depois da instrução: REG= 0x1A, W=
0xB5 001 1010 (0x1A) |
|
Exemplo
2: |
XORWF
REG, 0 |
|
Antes da
instrução: REG= 0xAF, W= 0xB5; 1010 1111 (0xAF) |
|
; 1011
0101 (0xB5) |
|
Depois da instrução: REG= 0xAF, W= 0x1A
;
0001
1010 (0x1A) |
A.17 INCF
Incrementar f
|
Sintaxe: |
[rótulo]
INCF f, d |
|
Descrição: |
Incrementar de uma unidade, o conteúdo do registo f. |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
( f ) + 1
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
INCF
REG, 1 |
|
Antes da
instrução: REG = 0xFF |
|
Z = 0 |
|
Depois
da instrução: REG = 0x00 |
|
Z =
1 |
|
Exemplo
2: |
INCF
REG, 0 |
|
Antes da
instrução: REG = 0x10 |
|
W = x |
|
Z
= 0 |
|
Depois
da instrução: REG = 0x10 |
|
W = 0x11 |
|
Z = 0 |
A.18 DECF
Decrementar f
|
Sintaxe: |
[rótulo]
DECF f, d |
|
Descrição: |
Decrementar de uma unidade, o conteúdo do registo f. |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se
d=1, o resultado é guardado no registo
f |
|
Operação: |
( f ) - 1
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
DECF
REG, 1 |
|
Antes da
instrução: REG = 0x01 |
|
Z = 0 |
|
Depois
da instrução: REG = 0x00 |
|
Z = 1 |
|
Exemplo
2: |
DECF
REG, 0 |
|
Antes da
instrução: REG = 0x13 |
|
W = x |
|
Z = 0 |
|
Depois
da instrução: REG = 0x13 |
|
W = 0x12 |
|
Z = 0 |
A.19 RLF
Rodar f para a esquerda através do Carry
|
Sintaxe: |
[rótulo]
RLF f, d |
|
Descrição: |
O
conteúdo do registo f é rodado um espaço para a esquerda,
através de C (flag do Carry). |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
( f <n>) Þ
d<n+1>, f<7>
Þ
C, C
Þ
d<0>; |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
C |
 |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
RLF
REG, 0 |
|
Antes da
instrução: REG = 1110 0110 |
|
C = 0 |
|
Depois
da instrução: REG = 1110 0110 |
|
W = 1100
1100 |
|
C = 1 |
|
Exemplo
2: |
RLF
REG, 1 |
|
Antes da
instrução: REG = 1110 0110 |
|
C = 0 |
|
Depois
da instrução: REG = 1100 1100 |
|
C = 1 |
A.20 RRF
Rodar f para a direita através do Carry
|
Sintaxe: |
[rótulo]
RRF f, d |
|
Descrição: |
O
conteúdo do registo f é rodado um espaço para a direita,
através de C (flag do Carry). |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
( f <n>) Þ
d<n-1>, f<0>
Þ
C, C
Þ
d<7>; |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
C |
 |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
RRF
REG, 0 |
|
Antes da
instrução: REG = 1110 0110 |
|
W = x |
|
C = 0 |
|
Depois
da instrução: REG = 1110 0110 |
|
W = 0111
0011 |
|
C = 0 |
|
Exemplo
2: |
RRF
REG, 1 |
|
Antes da
instrução: REG = 1110 0110 |
|
C = 0 |
|
Depois
da instrução: REG = 0111 0011 |
|
C = 0 |
A.21 COMF Complementar f
|
Sintaxe: |
[rótulo]
COMF f, d |
|
Descrição: |
O
conteúdo do registo f é complementado. |
|
Se
d=0, o resultado é guardado no registo
W |
|
Se d=1, o resultado é guardado no registo
f |
|
Operação: |
(
f)
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
Z |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
COMF
REG, 0 |
|
Antes da
instrução: REG= 0x13
; 0001
0011 (0x13) |
|
Depois
da instrução: REG= 0x13 ; complementar |
|
W = 0xEC ; 1110
1100 (0xEC) |
|
Exemplo
2: |
COMF
INDF, 1 |
|
Antes da
instrução: FSR= 0xC2 |
|
conteúdo
de FSR = (FSR) = 0xAA |
|
Depois
da instrução: FSR=
0xC2 |
|
conteúdo de FSR = (FSR) = 0x55 |
A.22 BCF
Pôr a “0” o bit b de f
|
Sintaxe: |
[rótulo]
BCF f, b |
|
Descrição: |
Limpar (pôr a ‘0’), o bit b do registo
f |
|
Operação: |
0
Þ
f<b> |
|
Operando: |
0
£
f
£
127,
0
£
b
£
7 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
BCF
REG, 7 |
|
Antes da
instrução: REG = 0xC7 ; 1100 0111 (0xC7) |
|
Depois da instrução: REG = 0x47 ; 0100
0111 (0x47) |
|
Exemplo
2: |
BCF
INDF, 3 |
|
Antes da
instrução: W = 0x17 |
|
FSR =
0xC2 |
|
conteúdo
do endereço em FSR (FSR) = 0x2F |
|
Depois
da instrução: W
= 0x17 |
|
FSR = 0xC2 |
|
conteúdo do endereço em FSR (FSR) = 0x27 |
A.23 BSF
Pôr a “1” o bit b de f
|
Sintaxe: |
[rótulo]
BSF f, b |
|
Descrição: |
Pôr a ‘1’, o bit b do registo
f |
|
Operação: |
1
Þ
f<b> |
|
Operando: |
0
£
f
£
127,
0
£
b
£
7 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
BSF
REG, 7 |
|
Antes da
instrução: REG = 0x07 ; 0000 0111 (0x07) |
|
Depois da instrução: REG = 0x17 ; 1000
0111 (0x87) |
|
Exemplo
2: |
BSF
INDF, 3 |
|
Antes da
instrução: W = 0x17 |
|
FSR =
0xC2 |
|
conteúdo
do endereço em FSR (FSR) = 0x2F |
|
Depois
da instrução: W = 0x17 |
|
FSR =
0xC2 |
|
conteúdo do endereço em FSR (FSR) = 0x28 |
A.24 BTFSC
Testar o bit b de f, saltar por cima se for = 0
|
Sintaxe: |
[rótulo]
BTFSC f, b |
|
Descrição: |
Se o bit b do registo f for igual a zero, ignorar
instrução seguinte.
Se este bit b for zero, então, durante a
execução da instrução actual, a execução da instrução seguinte não
se concretiza e é executada, em vez desta, uma instrução NOP,
fazendo com que a instrução actual, demore dois ciclos de instrução
a ser executada. |
|
Operação: |
Ignorar a instrução seguinte se (f<b>)
= 0 |
|
Operando: |
0
£
f
£
127,
0
£
b
£
7 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 ou 2 dependendo do valor lógico do bit
b |
|
Exemplo: |
LAB_01 BTFSC REG, 1; Testar o bit 1 do registo REG |
|
LAB_02 ........... ; Ignorar esta linha se for 0 |
|
LAB_03 ........... ; Executar esta linha depois da
anterior, se for 1 |
|
Antes da instrução, o contador de programa contém o endereço LAB_01.
Depois desta instrução, se o bit 1 do registo REG for zero, o
contador de programa contém o endereço LAB_03.
Se o bit 1 do registo REG for ‘um’, o contador de
programa contém o endereço LAB_02. |
A.25 BTFSS
Testar o bit b de f, saltar por cima se for = 1
|
Sintaxe: |
[rótulo]
BTFSS f, b |
|
Descrição: |
Se o bit b do registo f for igual a um, ignorar
instrução seguinte.
Se durante a execução desta instrução este bit b
for um, então, a execução da instrução seguinte não se concretiza e
é executada, em vez desta, uma instrução NOP, assim, a instrução
actual demora dois ciclos de instrução a ser executada. |
|
Operação: |
Ignorar a instrução seguinte se (f<b>)
= 1 |
|
Operando: |
0
£
f
£
127,
0
£
b
£
7 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 ou 2 dependendo do valor lógico do bit
b |
|
Exemplo: |
LAB_01 BTFSS REG, 1; Testar o bit 1 do registo REG |
|
LAB_02 ...........
; Ignorar esta
linha se for 1 |
|
LAB_03 ...........
; Executar esta
linha depois da anterior, se for 0 |
|
Antes da instrução, o contador de programa contém o endereço LAB_01.
Depois desta instrução, se o bit 1 do registo REG for ‘um’, o
contador de programa contém o endereço LAB_03.
Se o bit 1 do registo REG for zero, o contador de
programa contém o endereço LAB_02. |
A.26 INCFSZ
Incrementar f, saltar por cima se der = 0
|
Sintaxe: |
[rótulo]
INCFSZ f, d |
|
Descrição: |
Descrição:
O
conteúdo do registo f é incrementado de uma unidade. |
|
Se d
= 0, o resultado é guardado no registo W. |
|
Se d
= 1, o resultado é guardado no registo f. |
|
Se o resultado do incremento for = 0, a instrução
seguinte é substituída por uma instrução NOP, fazendo com que a
instrução actual, demore dois ciclos de instrução a ser executada. |
|
Operação: |
(f) + 1
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 ou 2 dependendo do resultado |
|
Exemplo: |
LAB_01 INCFSZ REG, 1; Incrementar o conteúdo de REG de uma
unidade |
|
LAB_02 ........... ; Ignorar esta linha se
resultado = 0 |
|
LAB_03 ........... ; Executar esta linha depois da
anterior, se der 0 |
|
Conteúdo do contador de programa antes da instrução,
PC = endereço LAB_01.
Se o conteúdo do registo REG depois
de a operação REG = REG + 1 ter sido executada, for REG = 0, o
contador de programa aponta para o rótulo de endereço LAB_03.
Caso contrário, o contador de programa contém o
endereço da instrução seguinte, ou seja, LAB_02. |
A.27 DECFSZ
Decrementar f, saltar por cima se der = 0
|
Sintaxe: |
[rótulo]
DECFSZ f, d |
|
Descrição: |
O conteúdo do registo f é decrementado uma
unidade. |
|
Se d = 0, o resultado é guardado no registo
W. |
|
Se d = 1, o resultado é guardado no registo
f. |
|
Se o resultado do decremento for = 0, a instrução
seguinte é substituída por uma instrução NOP, fazendo assim com que
a instrução actual, demore dois ciclos de instrução a ser executada. |
|
Operação: |
(f) - 1
Þ
d |
|
Operando: |
0
£
f
£
127,
d
Î
[0, 1] |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 ou 2 dependendo do resultado |
|
Exemplo: |
LAB_01
DECFSZ REG, 1; Decrementar o conteúdo de REG de uma unidade |
|
LAB_02 ........... ; Ignorar esta linha se
resultado = 0 |
|
LAB_03 ........... ; Executar esta linha depois da
anterior, se der 0 |
|
Conteúdo do contador de programa antes da instrução,
PC = endereço LAB_01.
Se o conteúdo do registo REG depois de a operação REG = REG – 1 ter
sido executada, for REG = 0, o contador de programa aponta para o
rótulo de endereço LAB_03.
Caso contrário, o contador de programa contém o
endereço da instrução seguinte, ou seja, LAB_02. |
A.28 GOTO Saltar
para o endereço
|
Sintaxe: |
[rótulo]
GOTO k |
|
Descrição: |
Salto incondicional para o endereço k. |
|
Operação: |
k
Þ
PC<10:0>, (PCLATH<4:3>)
Þ
PC<12:11> |
|
Operando: |
0
£
k
£
2048 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
2 |
|
Exemplo: |
LAB_00 GOTO LAB_01; Saltar para LAB_01 |
|
: |
|
LAB_01 ............ |
|
Antes da
instrução: PC = endereço LAB_00 |
|
Depois da instrução: PC = endereço LAB_01 |
A.29 CALL
Chamar um programa
|
Sintaxe: |
[rótulo]
CALL k |
|
Descrição: |
Esta instrução, chama um subprograma. Primeiro, o
endereço de retorno (PC+1) é guardado na pilha, a seguir, o operando
k de 11 bits, correspondente ao endereço de início do
subprograma, vai para o contador de programa (PC). |
|
Operação: |
PC+1
Þ
Topo da pilha (TOS – Top Of Stack) |
|
Operando: |
0
£
k
£
2048 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
2 |
|
Exemplo: |
LAB_00 CALL LAB_02 ; Chamar a subrotina LAB_02 |
|
LAB_01 : |
|
: |
|
LAB_02 ............ |
|
Antes da
instrução: PC = endereço LAB_00 |
|
TOS = x |
|
Depois da
instrução: PC = endereço LAB_02 |
|
TOS =
LAB_01 |
A.30 RETURN
Retorno de um subprograma
|
Sintaxe: |
[rótulo]
RETURN |
|
Descrição: |
O conteúdo do topo da pilha é guardado no contador de
programa. |
|
Operação: |
TOS
Þ
Contador de programa PC |
|
Operando: |
- |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
2 |
|
Exemplo: |
RETURN |
|
Antes da
instrução: PC = x |
|
TOS = x |
|
Depois
da instrução: PC = TOS |
|
TOS = TOS - 1 |
A.31 RETLW
Retorno de um subprograma com uma constante em W
|
Sintaxe: |
[rótulo]
RETLW k |
|
Descrição: |
A constante k de 8 bits, é guardada no registo
W. |
|
Operação: |
(k)
Þ
W;
TOS
Þ
PC |
|
Operando: |
0
£
k
£
255 |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
2 |
|
Exemplo: |
RETLW
0x43 |
|
Antes da
instrução: W = x |
|
PC = x |
|
TOS = x |
|
Depois
da instrução:
W = 0x43 |
|
PC = TOS |
|
TOS = TOS – 1 |
A.32 RETFIE
Retorno de uma rotina de interrupção
|
Sintaxe: |
[rótulo]
RETLW k |
|
Descrição: |
Retorno de uma subrotina de atendimento de
interrupção. O conteúdo do topo de pilha (TOS), é transferido para o
contador de programa (PC). Ao mesmo tempo, as interrupções são
habilitadas, pois o bit GIE de habilitação global das interrupções,
é posto a ‘1’. |
|
Operação: |
TOS
Þ
PC ; 1Þ
GIE |
|
Operando: |
- |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
2 |
|
Exemplo: |
RETFIE |
|
Antes da instrução: PC = x |
|
GIE = 0 |
|
Depois da instrução: PC = TOS |
|
GIE = 1 |
A.33 NOP
Nenhuma operação
|
Sintaxe: |
[rótulo]
NOP |
|
Descrição: |
Nenhuma operação é executada, nem qualquer flag é
afectada. |
|
Operação: |
- |
|
Operando: |
- |
|
Flag: |
- |
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo: |
NOP |
A.34 CLRWDT Iniciar
o temporizador do watchdog
|
Sintaxe: |
[rótulo]
CLRWDT |
|
Descrição: |
O temporizador do watchdog é reposto a zero. O
prescaler do temporizador de Watchdog é também reposto a 0 e,
também, os bits do registo de estado
e são postos a ‘um’. |
|
Operação: |
0
Þ
WDT |
|
0
Þ
prescaler de WDT |
|
1Þ |
|
1Þ |
|
Operando: |
- |
|
Flag: |
|
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo: |
CLRWDT |
|
Antes da
instrução: Contador de WDT = x |
|
Prescaler de WDT = 1:128 |
|
Depois
da instrução: Contador
do WDT = 0x00 |
|
Prescale
do WDT = 0 |
|
|
A.35 SLEEP
Modo de repouso
|
Sintaxe: |
[rótulo]
SLEEP |
|
Descrição: |
O processador entra no modo de baixo consumo. O
oscilador pára. O bit (Power
Down) do registo Status é reposto a ‘0’. O bit (Timer
Out) é posto a ‘1’. O temporizador de WDT (Watchdog) e o respectivo
prescaler são repostos a ‘0’. |
|
Operação: |
0
Þ
WDT |
|
0
Þ
prescaler do WDT |
|
1
Þ
TO |
|
0
Þ
PD |
|
Operando: |
- |
|
Flag: |
|
|
Número
de palavras: |
1 |
|
Número de ciclos: |
1 |
|
Exemplo
1: |
SLEEP |
|
Antes da
instrução: Contador do WDT = x |
|
Prescaler do WDT = x |
|
Depois
da instrução: Contador do WDT = 0x00 |
|
Prescaler do WDT = 0 |
|
|
|
