conjunto de instrucoes pic 16f877a

UNIVASFUNIVASFMicroprocessadores e Microprocessadores e MicrocontroladoresMicrocontroladores

Prof. Rodrigo Ramos

[email protected]

Conjunto de Instruções do Conjunto de Instruções do PIC16F877APIC16F877A

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 dadosInstruções de processamento de dados

Copie o seguinte trecho do programa e verifique os flags C e DC sendo modificados.

movlw 10movwf 0x20 ; adiciona 0x0A a 0x0Aaddwf 0x20, w ; e guarda em WREG/ Flag DC = 1

movlw 160movwf 0x20 ; adiciona 0xA0 a 0xA0addwf 0x20, w ; e guarda em WREG/ Flag C = 1goto $

Instruções de processamento de dados (cont.)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)

− Na verdade: d ← f + [ (w ^ 0xFF) + 1 ]

− Ex.: Se quiséssemos realizar a operação 1 – 2 no PIC, faríamos:

movlw 1

movwf 0x20

movlw 2

subwf 0x20, w

Carry: “empréstimo negativo”

Resultado negativo: C = 0

Resultado positivo: C = 1


XOR

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


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


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 $


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.


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>


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, wrrf 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>).


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 1Exercí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 2Exercí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.

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>.

Instruções de desvioInstruções de desvio

Organização da Memória (cont.)‏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

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.)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.


ULA

Topo da pilha

Pilha (13-bits x 8)‏


return

− Retorno de sub-rotina.

retlw k

− Retorno de sub-rotina, com valor k copiado em WREG, útil para criação de tabelas.

− Equivalente a

retfie

− Retorno de interrupção. INTCON<GIE> = 1 (habilita interrupções)

ULA

Topo da pilha

Pilha (13-bits x 8)‏

movlw kreturn

ExercícioExercí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.

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


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.

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.

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.


O código a seguir pode ser usado para repetição de um trecho de programa 10 vezes.

movlw 10movwf 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



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.

TabelasTabelas

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.)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.)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

...


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 (Atrasos (DelaysDelays))

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.)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 sdelay:

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


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 MHzValor = ( (5 x 10-3 x 4 x 106) / 5) + 256 = 2.756 = 0x0AC4


Para atrasos maiores, usa-se loop externo.

Valor pode ir até 65.505 (0xFFFF). Porém, por facilidade, faz-se Valor máximo = 50.256 (0xC450), o que dá 250.000 ciclos (0.25 s com 4 MHz).

Para ~1 s, repete-se 4 vezes o loop.

Exercício: Testar código ao lado para que acenda e apague um led conectado ao pino RB0.

delay:

movlw 4

movwf ValorRep

loopExt:

movlw LOW Valor

movwf DelayL

movlw HIGH Valor

movwf DelayH

loop:

decf DelayL, f

btfsc STATUS, Z

decfsz DelayH, f

goto loop

decfsz ValorRep

goto loopExt

return


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.

BibliografiaBibliografia

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.

conjunto de instrucoes pic 16f877a

Documents