Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Microprocessadores e
Microcontroladores
Conjunto de Instruções do
PIC16F877A
Prof. Rodrigo Ramos
godoga@gmail.com
Instruções de processamento de dados
addlw k
− Adiciona constante k a WREG e guarda em WREG.
− Operação: w ← w + k
− Ex.: addlw 55
addwf f,d
−Adiciona conteúdo do registrador f a WREG e guarda
ou em WREG ou no próprio f.
− Operação: d ← w + f
− Ex.: addwf 0x20,f
Instruções de processamento de dados (cont.)
Copie o seguinte trecho do programa e verifique os flags C e
DC sendo modificados.
movlw 10
movwf 0x20 ; adiciona 0x0A a 0x0A
addwf 0x20, w ; e guarda em WREG/ Flag DC = 1
movlw 160
movwf 0x20 ; adiciona 0xA0 a 0xA0
addwf 0x20, w ; e guarda em WREG/ Flag C = 1
goto $
Instruções de processamento de dados (cont.)
subwf f, d
− Subtrai do conteúdo do registrador f o conteúdo de WREG
e guarda ou em WREG ou no próprio f.
− Operação: d ← f + (-w) XOR
− Na verdade: d ← f + [ (w ^ 0xFF) + 1 ]
− Ex.: Se quiséssemos realizar a operação 1 – 2 no PIC,
faríamos:
movlw 1
sublw 2
− O que faz a operação abaixo?
sublw 0
− O que fazer para subtrair um valor de WREG?
addlw -45
Instruções de processamento de dados (cont.)
decf f, d
incf f, d
− Operações de incremento e decremento de f.
− Resultado é salvo em d (WREG ou f).
comf f, d
− Complementa (inverte logicamente) o conteúdo do um
registrador f, com resultado salvo em d.
− Complemento de 1.
− Para complemento de 2, deve-se fazer:
comf f, d
incf f, d
Instruções de processamento de dados (cont.)
Verifique o programa abaixo e tente prever o resultado final
dos registradores 0x20 e WREG.
movlw 47
movwf 0x20
incf 0x20, f
incf 0x20, f
incf 0x20, f
decf 0x20, w
decf 0x20, w
decf 0x20, w
comf 0x20, f
incf 0x20, f
goto $
Instruções de processamento de dados (cont.)
andlw k
− AND entre k e o conteúdo de WREG.
andwf f, d
− AND entre o conteúdo de f e o conteúdo de WREG.
iorlw k
− (Inclusive) OR entre k e o conteúdo de WREG.
iorwf f, d
− (Inclusive) OR entre o conteúdo de f e o conteúdo de
WREG.
xorlw k
− XOR (ou exclusivo) entre k e o conteúdo de WREG.
xorwf f, d
− XOR entre o conteúdo de f e o conteúdo de WREG.
Instruções de processamento de dados (cont.)
rlf f, d
− Deslocamento à esquerda do conteúdo de f, salvando
resultado em d (rotate left - rl).
− Deslocamento com carry STATUS<C>
rrf f, d
− Deslocamento à esquerda do conteúdo de f, salvando
resultado em d (rotate right - rr).
− Deslocamento com carry STATUS<C>
Instruções de processamento de dados (cont.)
Para que não se perca nenhum bit no processo de
rotação, pode-se usar o seguinte trecho de código
(chamado snippet - fragmento)
rrf Reg, w
rrf Reg, f
Na primeira instrução, o carry é carregado com o LSB de
Reg (Reg<0>) e o resultado é salvo em WREG.
Na segunda instrução, o carry é colocado no MSB de Reg
(Reg<7>).
Instruções de processamento de dados (cont.)
O código a seguir mostra o uso do snippet anterior para
deslocar um bit do registrador 0x20 de 4 posições.
movlw b'00100000'
movwf 0x20
rrf 0x20, w
rrf 0x20, f
rrf 0x20, w
rrf 0x20, f
rrf 0x20, w
rrf 0x20, f
goto $
Exercício 1
HIGH LOW
Instruções de desvio (cont.)
Como exemplo do uso do goto, considere o código abaixo.
Habilite a opção View → Program Memory do MPLAB.
goto FirstLabel
movf STATUS, w ; Instrução não executada
FirstLabel:
movlw HIGH SecondLabel ; HIGH retorna o byte mais signif.
movwf PCLATH
goto SecondLabel
org 0x376
movlw 40
goto $
Instruções de desvio (cont.)
call k
− Chamada de subrotina especificada por k.
−Operação idêntica à goto, com exceção de que PC é salvo
na pilha.
− Dois ciclos de instrução.
− Ao fim da sub-rotina, uma instrução return (ou equivalente)
faz com que o fluxo retorne ao ponto seguinte à chamada.
Pilha (13-bits x 8)
Topo da
pilha
ULA
Instruções de desvio (cont.)
return
− Retorno de sub-rotina.
retlw k
− Retorno de sub-rotina, com valor k copiado em WREG, útil para
criação de tabelas.
movlw k
− Equivalente a
return
retfie
− Retorno de interrupção. INTCON<GIE> = 1 (habilita interrupções)
ULA
Exercício
Desvios condicionais
incfsz f, d
− Incrementa o registrador f, salva resultado em d e salta próxima
instrução se o resultado do incremento for zero.
decfsz f, d
− Decrementa o registrador f, salva resultado em d e salta próxima
instrução se o resultado do decremento for zero.
Tempo de execução:
− 1 ciclo se resultado não for zero (não salta próxima instrução)
− 2 ciclos se for zero (salta)
São geralmente utilizados para controle de loops.
Instruções de desvio (cont.)
O código a seguir pode ser usado para repetição de um
trecho de programa 10 vezes.
movlw 10
movwf 0x20 ; carrega contador
Loop:
Quadrado:
addwf PCL,f ; PCL é incrementado antes da execução.
retlw 0 ; Assim, PCL = 5 + 2 = 7
retlw d'1'
retlw d'4'
retlw d'9'
retlw d'16'
retlw d'25'
retlw d'36'
main
movlw 0x05
call Quadrado
goto $
END
Tabelas (cont.)
Deve-se ter o cuidado de não haver cruzamento de página na
tabela. Se houver, PCLATH deve ser modificado.
Quadrado:
movwf Temp
movlw HIGH Quadrado2
movwf PCLATH
movf Temp, w
addlw LOW Quadrado2
btfsc STATUS, C
incf PCLATH, f
movwf PCL
Quadrado2:
retlw 0
retlw 1
...
Exercício
Escreva um programa em assembly para acionamento
de um display de 7 segmentos usando uma tabela. Os bits
de acionamento dos números de 0 a 9 devem estar
disponíveis em uma tabela.
Atrasos (Delays)
Unidade básica de tempo é o ciclo de instrução:
Ciclo de instrução = 4 / freqüência de clock
Ex.: Para um clock de 4 MHz:
Ciclo de instrução = 4 / 4 MHz = 1 us.
Atrasos de tempo podem ser convertidos em ciclos de
instrução pela expressão:
Ciclos de instrução = Atraso de tempo * (Freq. Clock / 4)
Ex.: Para um atraso de 5 ms em um PIC rodando a 4 MHz,
temos:
Ciclos de instrução = 5 x 10-3 (4 x 106 / 4) = 5.000
Assim, são necessários 5.000 ciclos de instruções para
obter um atraso de 5 ms.
Atrasos (cont.)
A maneira mais simples de criar atrasos é 'gastando tempo' com
instruções.
Para isso, pode-se usar loops que decrementem um contador,
podendo-se contar 256 vezes (ciclos de instrução).
Com um contador duplo, conta-se aproximadamente o quadrado
disto. Ex. Contador de ~(200)2 = 400.000 ciclos = 0.4 s
delay:
movlw .200 ; w = 200 decimal
movwf j ; j = w
jloop:
movwf k ; k = w
kloop:
decfsz k,f ; k = k-1, pula se zero
goto kloop
decfsz j,f ; j = j-1, pula se zero
goto jloop
return
Atrasos (cont.)
Forma alternativa:
delay:
movlw LOW Valor
movwf DelayL
movlw HIGH Valor
movwf DelayH
loop:
decf DelayL, f
btfsc STATUS, Z
decfsz DelayH, f
goto loop
return