You are on page 1of 36

UNIVASF

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 Carry: “empréstimo negativo”
movwf 0x20 Resultado negativo: C = 0
movlw 2
subwf 0x20, w Resultado positivo: C = 1
Instruções de processamento de dados (cont.)
 sublw k
− Operação: w ← k + (-w)
− Trabalha de modo similar a subwf.
−Ex.: Se quiséssemos realizar as operações 1 – 2 e 2 – 1 no
PIC, faríamos:
movlw 2
sublw 1

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

 Escreva um programa que realize a multiplicação 9 x 5
(note que N x 5 = N x 4 + N x 1).
 Lembrar que uma rotação à esquerda com um zero em
LSB equivale a uma multiplicação por 2, uma segunda
rotação equivale a multiplicar por 4 e assim por diante.
 Não usar desvio condicional, apenas as operações de
transferência e de processamento de dados.
Exercício 2

 Escreva um programa para somar dois números de 16
bits.
 DICA: Utilize labels para especificar os registradores que
guardarão os valores a serem usados. Dica: use a diretiva
CBLOCK para definir blocos de constantes.
CBLOCK 0x20
Var1, Var2, Var3, ..., VarN
ENDC
 Não usar desvio condicional, apenas as operações de
transferência e de processamento de dados.
Instruções de desvio
 goto k
− Desvia programa para o ponto k (geralmente um label)
− Desvio incondicional sem retorno.
− Dois ciclos de máquina.
− Lembrar que a instrução só consegue endereçar 211 bytes =
2048 bytes (0x800). Para valores de labels acima disso, deve-
se usar os bits PCLATH<4:3>.
Organização da Memória (cont.)‫‏‬
 Memória de programa
− 13 bits para endereçamento
− 8k palavras x 14 bits

0x0800 = 0000 1000 0000 0000
0x1000 = 0001 0000 0000 0000
0x1800 = 0001 1000 0000 0000

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

org 0x1B76 ; Endereco na pagina 3
SecondLabel: ; Execução do goto $ abaixo

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)

Pilha (13-bits x 8)‫‏‬
Topo da pilha

ULA
Exercício

 Re-escreva o programa para somar dois números de 16
bits, utilizando agora uma sub-rotina, de forma a que seja
possível realizar a soma diversas vezes a partir da
chamadas à sub-rotina.
Instruções de desvio (cont.)
 Desvios condicionais – só desviam fluxo se condição for verdadeira.
 Instruções “skip on bit condition” - salta a próxima instrução dependendo
da condição do bit testado.
 btfsc f, b (bit test file-reg, skip if clear)
− Testa o bit b do registrador f e salta próxima instrução se b = 0.
 btfss f, b (bit test file-reg, skip if set)
− Testa o bit b do registrador f e salta próxima instrução se b = 0.
 Tempo de execução:
− 1 ciclo se condição for falsa (sem desvio)
− 2 ciclos se verdadeira (desvio)
 Ex.: Saltar para um endereço se flag Z for 1.
btfsc STATUS, Z ; Testa se Z = 0 e salta se V
goto Label ; Se Z = 1, desvia para Label
Exercício

 Escreva um programa em assembly que compare dois
valores vA e vB. Caso eles sejam iguais, escreva no
registrador 0x25 o valor 0x0E. Caso sejam diferentes,
escreva 0x0D.
Instruções de desvio (cont.)
 Desvios condicionais – de forma geral, desvios baseados na
comparação de dois valores têm uma forma definida.
 Pseudo-código: if (A condição B) then goto Label
 Assembly:
movf FirstValue, w
subwf SecondValue, w
btfs# STATUS, flag
goto Label

 Onde FirstValue, SecondValue e # são definidos na tabela a seguir.
 Caso sejam usadas constantes, movf e subwf devem ser substituídas
por molw e sublw.
Instruções de desvio (cont.)
Instruções de desvio (cont.)

 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:

; Instruções a serem executadas repetidamente

decfsz 0x20, f ; decrementa contador
goto Loop ; se não é zero, repete
; caso contrário, continua
Exercício

 Escreva um programa em assembly para multiplicação
de dois números de 8 bits.
 Lembre que o resultado deve ser um número de 16 bits.
Tabelas
 Estruturas de dados para armazenamento de constantes e
apontadas por um índice (banco de dados de uma coluna).
 Ex.: Tabela de quadrados de números.
 São usadas para retornar valores de acordo com o parâmetro
passado à tabela.
 A forma mais tradicional no PIC é com o uso de uma subrotina
que adiciona uma constante ao PC, com o uso da instrução
addwf PCL, f.
No novo endereço, uma instrução retlw é usada para salvar
em WREG o valor a ser retornado.
 IMPORTANTE: PC é incrementado antes da execução da
instrução!!
Tabelas (cont.)
 Exemplo: Programa para determinar quadrado de um número
entre 0 e 6.

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

Valor = ((atraso * freqüência/4)/5) + 256
Ex.: 5 ms com clock 4 MHz
Valor = ( (5 x 10-3 x 4 x 106) / 5) + 256 = 2.756 = 0x0AC4
Atrasos (cont.)
 Para atrasos maiores, usa-se loop delay:
externo. movlw 4
movwf ValorRep
 Valor pode ir até 65.505 (0xFFFF).
loopExt:
Porém, por facilidade, faz-se Valor
movlw LOW Valor
máximo = 50.256 (0xC450), o que dá
movwf DelayL
250.000 ciclos (0.25 s com 4 MHz).
movlw HIGH Valor
 Para ~1 s, repete-se 4 vezes o loop. movwf DelayH
loop:
decf DelayL, f
 Exercício: Testar código ao lado
para que acenda e apague um led btfsc STATUS, Z
conectado ao pino RB0. decfsz DelayH, f
goto loop
decfsz ValorRep
goto loopExt
return
Exercício
 Escreva um programa em assembly que conte de 0 até
9, mostrando cada número da contagem em um display de
7 segmentos.
 Cada número deve ser mostrado durante um intervalo de
tempo de 0,5 s.
Bibliografia
 MPASM User's Guide, Microchip Technology Inc., 2005.
 PIC16F87xA Data Sheet, Microchip Technology Inc., 2003.
 M. Predko, “Programming and Customizing the PIC
Microcontroller”, 3rd. Ed., McGraw-Hill, 2008.
 F. Pereira, “Microcontroladores PIC: Técnicas Avançadas –
16F627 e 16F628”, 5a. Ed., Érica, 2008.