Baixe Memórias e Microcontroladores 2 e outras Notas de estudo em PDF para Cultura, somente na Docsity!
Instruções de movimentação de dados
Instrução MOV
O 8051 possui instruções que permitem copiar o conteúdo de um registrador ou localidade para outro registrador ou localidade de memória. Nas seções anteriores foram vistos os registradores do 8051. Para que a informação contida em um registrador possa ser “movimentada” para outro registrador ou para a memória usa-se a instrução:
MOV dest , orig
Significado: Copia o conteúdo de origem do para destino.
Vejamos alguns exemplos:
MOV A,B copia o conteúdo do registrador B para o registrador A. MOV R1,R5 copia o conteúdo de R5 em R0.
A B R1 R
Os exemplos anteriores mostram a forma como é feita a cópia de um registradora para outro. Entretanto, existem outras formas de movimentação de dados. Além de registradores, podem envolver endereços da memória RAM interna. Essas formas são vistas a seguir:
Modos de movimentação
No 8051, existem 3 formas básicas de movimentação de dados:
- modo imediato
- modo direto
- modo indireto
1) IMEDIATO
MOV A,#03h
Coloca no registrador A o valor 03h. Para dizer que 03h é um valor imediato, deve ser precedido por “grade” (#).
Podemos observar que o valor de origem está contido na própria instrução.
dest orig
2) DIRETO
MOV A,03h
O valor 03h agora é um endereço da memória RAM interna e o seu conteúdo é que será colocado no registrador A.
Se tivermos, por exemplo, o byte 4Dh no endereço 03h, esse valor (4Dh) será colocado no registrador A.
Podemos observar que o valor de origem vem da memória RAM interna.
3) INDIRETO
MOV A,@R
O μP toma o valor contido no registrador R0, considera-o como sendo um endereço, busca o byte contido nesse endereço e coloca-o em A.
Supondo que R0 contém 03h, o μP pega o valor de R0 (03h), considera esse valor como sendo um endereço, busca o byte contido no endereço 03h (4Dh, por exemplo) e coloca esse byte em A (A=4Dh).
Podemos observar que o valor de origem também vem da memória RAM interna.
IMPORTANTE!!! Esse modo usa somente os registradores RO e R1. ( @R0 e @R1 ).
Instruções Lógicas e Aritméticas
O 8051 possui uma unidade que realiza operações lógicas e aritméticas (ULA - Unidade Lógica e Aritmética) que realiza funções de soma, subtração, multiplicação e divisão, AND, OR, XOR, etc.
acumulador
Rtemp
U.L.A.
Todas as operações precisam de dois parâmetros: Por exemplo: para somar, são necessários os dois números que serão somados. 2 + 5 é um exemplo de soma onde existem dois parâmetros: 2 e 5.
Mas, como se sabe, o acumulador é um dos registradores empregados nessa unidade. Portanto, o acumulador é obrigatoriamente um dos parâmetros e o resultado é colocado de volta no acumulador. No exemplo acima, o valor 2 estaria no acumulador, ocorreria a instrução de soma com o valor 5 e o resultado (7) seria colocado no acumulador no lugar do valor
1. INSTRUÇÃO DE SOMA
ADD A, parâm ;”add”
Realiza a soma A+ parâm e coloca o resultado em A. O valor anterior de A é perdido. Exemplos:
ADD A,#03h ;A+3 ÆÆÆÆ A ADD A,03h ;A+”end.03h” ÆÆÆÆ A ADD A,B ;A+B ÆÆÆÆ A ADD A,R0 ;A+R0 ÆÆÆÆ A ADD A,@R0 ;A+”end.@R0” ÆÆÆÆ A
A instrução de soma afeta o registrador de 1 bit CARRY. Sempre que o resultado for um número de mais de 8 bits (um valor acima de FFH) a ULA coloca o “vai-um” automaticamente no CARRY. Isso significa que,
quando o valor “extrapolar” 8 bits o CARRY=1. Quando a soma não extrapolar, o CARRY=0.
2. INSTRUÇÃO DE SOMA COM CARRY
Parecida com a instrução anterior, a soma com carry pode utilizar o CARRY gerado do resultado anterior junto na soma:
ADDC A, parâm ;”add with carry”
Realiza a soma A + parâm + CARRY e coloca o resultado em A. Como o CARRY é um registrador de um único bit, o seu valor somente pode ser 0 ou 1. Então, quando CARRY=0, o efeito das instruções ADD e ADDC é o mesmo.
É muito importante notar que, as operações ADD e ADDC podem resultar valores acima de FFH e, com isso, afetar o CARRY como resultado da soma. A instrução ADDC usa o CARRY na soma. Portanto, o valor contido no CARRY antes da operação ADDC pode ser diferente do valor após a operação. Exemplo: supondo A=F3H e CARRY=0:
ADDC A,#17H ;F3H+17H+0=10AH. A=0AH e CARRY= ADDC A,#17H ;0AH+17H+1=22H. A=22H e CARRY= ADDC A,#17H ;22H+17H+0=39H. A=39H e CARRY=
3. INSTRUÇÃO DE SUBTRAÇÃO COM CARRY
Por razões técnicas, não seria possível implantar ambos os tipos de subtração. Por ser mais completa, foi implantada a subtração com carry.
SUBB A, parâm ;”subtract with borrow”
Realiza a subtração A – (^) parâm – CARRY e coloca o resultado em A.
No caso da subtração, o resultado pode ser positivo ou negativo. Quando o resultado for positivo, CARRY=0. Quando for negativo, CARRY=1.
No caso de se desejar fazer uma subtração simples, deve-se assegurar que o valor do CARRY seja 0 antes da instrução para não afetar o resultado. Por isso, é comum usar a instrução:
CLR C ;”clear carry”
Exemplo: CLR C ;carry= SUBB A,B ;A-B-0 = A-B
3. INSTRUÇÃO EXCLUSIVE-OR LÓGICO
XRL A, param ;”exclusive-or logic”
Faz um XOR lógico bit-a-bit de A com parâm. O resultado é colocado em A.
Exemplo: supondo A=9EH e B=3BH, a operação XRL A,B ;9EH “xor” 3BH = __H pois:
A B L 0 0 0 1 1 0 1 1
Função lógica XOR.
XOR
H =
9EH = 10011110
3BH = 00111011
MÁSCARAS LÓGICAS
A idéia de máscaras lógicas surgiu da observação do comportamento das operações lógicas. Como foi visto anteriormente, não é difícil realizar uma operação lógica entre dois parâmetros; esses parâmetros podem ser chamados entradas , e o resultado saída. Se mudarmos o ponto de vista, considerando a primeira entrada como sendo valor original e a outra entrada como a máscara , e o resultado como o valor modificado , podemos entender como as máscaras lógicas funcionam.
AND
OBH = 00001011
OFH = 00001111
3BH = 00111011
VALOR MODIFICADO
VALOR ORIGINAL
MÁSCARA
No exemplo acima foi escolhida uma máscara com o valor 0FH para melhor ilustrar os exemplos. Fique bem claro: a máscara pode conter qualquer valor de 8 bits.
No caso da função AND , os bits da máscara com valor zero modificam os bits do valor original para zero. Os bits uns, não modificam o valor original. Observe que os 4 bits MSB da máscara são zeros e transformam os 4 bits MSB do valor original em zero. Já os 4 bits LSB da máscara não causam alterações nos 4 bits LSB do valor original.
OR
3FH = 00111111
OFH = 00001111
3BH = 00111011
No caso da função OR , o efeito dos bits da máscara é diferente: Os bits zeros da máscara _______________________________________ Os bits uns da máscara _________________________________________
XOR
34H = 00110100
OFH = 00001111
3BH = 00111011
No caso da função XOR , o efeito dos bits da máscara é: Os bits zeros da máscara _______________________________________ Os bits uns da máscara _________________________________________
Isso nos permite concluir que, com o uso das máscaras podemos causar qualquer efeito em cada um dos bits do valor original: pode-se zerá-los, setá-los ou invertê-los.
AND 0000XXXX
OFH = 00001111
XXXXXXXX
OR XXXX
OFH = 00001111
XXXXXXXX
XOR
XXXXXXXX
OFH = 00001111
XXXXXXXX
Nos exemplos anteriores foi utilizado um valor pré-estabelecido 3BH como valor original. Poderíamos partir da premissa de que o valor original é desconhecido. Desse modo, o valor original poderia ser expresso como XXXXXXXX onde cada um dos X pode ser 0 ou 1. Assim, o efeito das máscaras binárias poderia ser expresso conforme as figuras a seguir:
Para obter efeitos mesclados, como por exemplo, ter alguns bits do valor original zerados e outros invertidos devem ser usadas duas máscaras para obter o valor desejado.
Faz a rotação dos bits de A uma posição em direção ao LSB. O bit LSB é colocado no lugar do MSB. As figuras ao lado exemplificam essa rotação.
Um exemplo de um byte genérico 01001011 após sofrer rotação à direita. 0 1 0 0 1 0 1 1
1 0 1 0 0 1 0 1
2. INSTRUÇÃO DE ROTAÇÃO À ESQUERDA
RL A ;”rotate left”
1 0 1 1
esquerda 0 1 0 0
Faz a rotação dos bits de A uma posição em direção ao MSB. O bit MSB é colocado no lugar do LSB. As figuras ao lado exemplificam essa rotação.
Um exemplo de um byte genérico 01001011 após sofrer rotação à direita.
0 1 0 0 1 0 1 1
1 0 0 1 0 1 1 0
3. INSTRUÇÃO DE ROTAÇÃO À DIREITA COM CARRY
RRC A ;”rotate right with carry”
1 0 1 1
direita CARRY 0 1 0 0 0
Faz a rotação dos bits de A uma posição em direção ao LSB. O bit LSB é colocado no CARRY e, este, no lugar do MSB.
Um exemplo de um byte genérico 01001011 após sofrer rotação à direita com carry 0 1 0 0 1 0 1 1
0 0 1 0 0 1 0 1
0
1
4. INSTRUÇÃO DE ROTAÇÃO À ESQUERDA COM CARRY
RLC A ;”rotate left with carry”
1 0 1 1
esquerda CARRY 0 1 0 0 0
Faz a rotação dos bits de A uma posição em direção ao MSB. O bit MSB é colocado no CARRY e, este, no lugar do LSB.
Um exemplo de um byte genérico 01001011 após sofrer rotação à esquerda com carry 0 1 0 0 1 0 1 1
1 0 0 1 0 1 1 0
0
0
EXEMPLOS
EXEMPLO 1: Esse trecho de programa inverte o nibble MSB com o nibble LSB do acumulador. nibble=grupo de 4 bits byte =grupo de 8 bits.
RL A RL A RL A RL A
EXEMPLO 2: Esse trecho de programa pega cada bit MSB dos registradores R0 até R7 e coloca-os um a um nos bits do acumulador.
MOV R4,# MOV A,R RLC A MOV A,R RLC A MOV R4,A MOV A,R
Instruções de incremento e decremento
INSTRUÇÃO DE INCREMENTO (SOMA 1)
INC destino
Faz o conteúdo de destino ser somado de 1.
Exemplo:
MOV A,#14h INC A
Sintaxes válidas:
INC A INC DPL INC 02h INC @RO
INSTRUÇÃO DE DECREMENTO (SUBTRAI 1)
DEC destino
Faz o conteúdo de destino ser subtraído de 1.
Exemplo:
MOV B,#23h DEC A
Sintaxes válidas:
DEC R DEC 79h DEC @R DEC #03h
A última instrução não é válida: mesmo que se faça a subtração de um valor imediato (no exemplo acima, 03-1=02) a instrução não especifica onde deve ser guardado o resultado.
EXERCÍCIOS
Instruções de desvio
Esse tipo de instruções são de extrema utilidade na programação dos microprocessadores. Até então, as instruções eram executadas em seqüência, uma após a outra.
As instruções de desvio permitem alterar a seqüência de execução das instruções.
As instruções de desvio possuem diferentes graus de abrangência. Nos 8051 temos:
1. DESVIO LONGÍNQUO (LONG JUMP)
LJMP endereço
Essa instrução, quando executada, permite que o μP desvie o seu “trajeto normal” da execução das instruções e vá direto para “endereço” continuando lá a execução das instruções.
Exemplo:
0160 74 03 MOV A,#03h 0162 75 11 0D MOV 11h,#0Dh 0165 25 11 ADD A,11h 0167 02 01 0D LJMP 016Bh 016A 04 INC A 016B 25 11 ADD A,11h 016D FB MOV R3,A
2. DESVIO MÉDIO
AJMP endereço
Como visto anteriormente, a instrução LJMP pode desviar para qualquer endereço de 16 bits, ou seja, abrange qualquer localidade dentro de 64 KBytes. Já o AJMP não consegue abranger uma quantidade de memória tão grande, mas apenas endereços de 11 bits, ou seja, 2 KBytes. Mas de onde vêm os bits de endereço restantes A 10 até A 15? Resposta: esses bits vêm do registrador PC. Isso permite concluir o seguinte:
Imaginemos a memória de 64 KBytes segmentada em 64 partes de 1 KByte:
0169 04 INC A 016A AE F0 MOV R6,A
Para encontrarmos o endereço para onde será feito o desvio, o endereço de referência quando a instrução SJMP estiver sendo executada é o endereço da próxima instrução após o SJMP, que no exemplo acima é 0169h. Sobre esse endereço de referência, aplicamos o valor relativo do desvio, que no exemplo é +01. Fazendo então 0169h + 01 = 016Ah que é o endereço para onde é feito o desvio. O endereço final 016Ah é comumente chamado de endereço efetivo (endereço final obtido após os cálculos).
Outro exemplo:
0160 74 03 MOV A,#03h 0162 75 F0 02 MOV B,#02h 0165 25 F0 ADD A,B 0167 80 01 SJMP -09 (______h) 0169 04 INC A 016A AE F0 MOV R6,A
Pergunta: para onde será feito o desvio quando for executada a instrução SJMP acima? resp.: ___________________
A grande vantagem do desvio relativo é que ele é relativo à localização da instrução SJMP, não importando onde essa instrução esteja. Aqueles bytes do exemplo acima poderiam ser escritos em qualquer lugar da memória que o programa funcionaria sempre do mesmo modo. No primeiro exemplo, o programa foi colocado no endereço 0160h e o SJMP desviava para 016Ah. Se esse mesmo programa do exemplo estivesse em outro endereço, não haveria nenhum problema, pois, o desvio é relativo e sempre desviaria +01 à frente. Isso dá origem a um outro conceito muito importante: o de código realocável.
Vejamos os exemplos a seguir:
Exemplo 1: 0150 74 03 MOV A,#03h 0152 75 F0 02 MOV B,#02h 0155 25 F0 ADD A,B 0157 80 01 SJMP -09 (______h) 0159 04 INC A 015A AE F0 MOV R6,A
Exemplo 2: 0290 74 03 MOV A,#03h 0292 75 F0 02 MOV B,#02h 0295 25 F0 ADD A,B 0297 80 01 SJMP -09 (______h) 0299 04 INC A 029A AE F0 MOV R6,A
Observe que os bytes que compõem o programa são absolutamente os mesmos mas estão localizados em endereços diferentes. Entretanto, em ambos os casos, o trecho de programa funciona perfeitamente. No primeiro caso, a instrução SJMP causa desvio para o endereço 0159h - 09 = 0150h. No segundo caso, a instrução SJMP causa desvio para o endereço 0299h - 09 = 0290h.
DEC A JNZ repete
outra solução: MOV B,# repete: INC B MOV A,B XRL A,#0Ah ; poderia ser XRL A,# JNZ repete
Exemplo: Fazer um pequeno programa que procure detectar uma chave pressionada, considerando o circuito ao lado:
+5Vcc
P1.
P1.
P1.
P1.
P1.
P1.
P1.
P1.
solução: repete: MOV A,P1 ;lê o conteúdo das chaves JZ repete ;se nada for pressionado, repete
Instrução JC (Jump If Carry Set)
JC endereço_relativo
Causa o desvio se o CARRY=1.
Instrução JNC (Jump If Carry Not Set)
JNC endereço_relativo
Causa o desvio se o CARRY=0.
Instrução JB (Jump If Direct Bit Set)
JB end-bit,endereço_relativo
Causa o desvio se o o conteúdo do “endereço de bit” = 1.
Instrução JNB (Jump If Direct Bit Not Set)
JNB end-bit,endereço_relativo
Causa o desvio se o o conteúdo do “endereço de bit” = 0.
Para compreender o funcionamento dessas duas instruções devemos analisar um novo conceito: Os 8051 foram construídos para terem dois modos de endereçamento da memória RAM interna:
- endereçamento de byte
- endereçamento de bit Endereçamento de byte é o que vimos até então; exemplo: MOV A,1CH.
O endereçamento de bit ocorre a partir do endereço 0020H até 002FH. Observe o esquema a seguir (figura 2):
Onde existe o endereço de byte 0020H exitem 8 bits endereçá- veis através de endereçamento de bit: endereços: 00H, 01H, 02H, 03H, 04H, 05H, 06H e 07H. Portanto, podemos dizer que nesse local da memória RAM interna existem dois endereça-mentos.
O endereço de byte é usado nas instruções que acessam todos os 8 bits que compõem um byte nesse local da memória (ver figura 3a). O endereço de bit é usado por outras instruções que acessam 1 único bit nesse local da memória (ver figura 3b).
Os endereços não são coinciden-tes e nem poderiam ser. O avan-ço de 1 byte é o mesmo que o avaço de 8 bits.
Supondo que o conteúdo do endereço 0020H é C5H, veremos como esse valor é acessado através das figuras 3a e 3b.
0023H
0022H
0021H
Figura 2. Mapeamento da memória RAM interna dos 8051. Endereçamen- to de byte e Endereçamento de bit.
007FH
0032H
0031H
0030H
001FH 0020H 07H 06H 05H 04H 03H 02H 01H 00H
001EH
Região onde ocorre o endereçamento de bit
0000H
0027H
0026H
0025H
0024H
002BH
002AH
0029H
0028H
002FH
002EH
002DH
002CH
0FH 0EH 0DH 0CH 0BH0AH 09H 08H 17H 16H 15H 14H 13H 12H 11H 10H 1FH 1EH 1DH 1CH 1BH1AH 19H 18H 27H 26H 25H 24H 23H 22H 21H 20H 2FH 2EH 2DH 2CH 2BH2AH 29H 28H 37H 36H 35H 34H 33H 32H 31H 30H 3FH 3EH 3DH 3CH 3BH3AH 39H 38H 47H 46H 45H 44H 43H 42H 41H 40H 4FH 4EH 4DH 4CH 4BH4AH 49H 48H 57H 56H 55H 54H 53H 52H 51H 50H 5FH 5EH 5DH 5CH 5BH5AH 59H 58H 67H 66H 65H 64H 63H 62H 61H 60H 6FH 6EH 6DH 6CH 6BH6AH 69H 68H 77H 76H 75H 74H 73H 72H 71H 70H 7FH 7EH 7DH 7CH 7BH7AH 79H 78H
