Buscar

253782 Instrucoes HC08

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 3, do total de 22 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 6, do total de 22 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 9, do total de 22 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Prévia do material em texto

Instruções do Microcontrolador HC908Q 
 
 
As instruções inerentes ao microcontrolador possuem algumas classificações, 
listadas abaixo: 
 
Instruções de movimentação de dados – para efetuar a carga, movimentação e 
manipulação de dados; 
 
Instruções de manipulação de bits – para setar/apagar bits na memória ou no registrador 
CCR (code condition register); 
 
Instruções aritméticas e lógicas – para realizar operações matemáticas ou lógicas; 
 
Instruções de teste condicional e desvio – para realizar testes e desvios no fluxo do 
programa; 
 
Instruções de controle do processador – para o controle interno do processador. 
 
A seguir, os comandos usados em cada classificação: 
 
 
Instruções de movimentação de dados 
 
 
LDA 
 
 Carrega um valor imediato ou da memória no acumulador (A). 
 
 Exemplos 
 
 LDA #5 ;Carrega A com o valor 5 
LDA 128 ;Supondo que o conteúdo da posição 128 da memória é igual á $10, 
tal comando carrega no Acumulador esse conteúdo, fazendo com que A=$10. 
 
STA 
 
 Copia o conteúdo do acumulador (A) para a memória. 
 
 Exemplos 
 
 Considerando A=$50: 
 STA $80 ;Armazena o valor de A na posição $80 da memória 
 STA ,X ;Armazena o conteúdo do Acumulador na posição de memória 
indicada por X:H. 
 
LDX 
 
 Carrega um valor imediato ou da memória no registrador X. 
 
 Exemplos 
 
 LDX #5 ;Carrega X com o valor 5 decimal 
 LDX 128 ;Supondo que o conteúdo da posição 128 da memória é $81, esse 
comando carrega tal conteúdo ($81) em X. 
 
STX 
 
 Armazena o conteúdo do registrador X numa posição especificada de memória. 
 
 Exemplos 
 
 STX $80 ;Considerando o valor de X igual a 40 ($40), tal comando armazena 
na posição $80 da memória o valor de X, 40. 
 
LDHX 
 
 Carrega um valor imediato ou da memória no par de registradores H:X. 
 
 Exemplos 
 
 LDHX #$1234 ;Carrega H:X com $1234 (H=$12 e X=$34) 
 LDHX 128 ;Supondo que o conteúdo da posição de memória 128 é igual 
a $F0 e 129 igual a $00, tal comando carrega H com o conteúdo da posição 128 da 
memória e X com o conteúdo da posição 129. (H=$F0 e X=$00). 
 
STHX 
 
 Copia o conteúdo de 16 bits de H:X para a posição de memória (Sendo X 
armazenado no endereço seguinte). 
 
 Exemplos 
 
 STHX $80 ;Supondo que H:X valha $1234, tal comando armazena o 
valor de H (no caso, $12) na posição 80 da memória e o valor de X ($34) na posição 
seguinte, 81. 
 
 
 
 
 
 
 
MOV 
 
 Copia uma constante imediata para uma posição de memória ou um valor entre um 
aposição de memória e outra. 
 
 Exemplos 
 
 MOV $80,$81 ;Se o conteúdo da posição de memória $80 é igual a $10, esse 
comando copia tal valor na posição $81 de memória (assim, ($81)=$10). 
 MOV ,X+,$80 ;Supondo que H:X aponta para o endereço $90 e esse 
endereço armazena o valor 0, tal comando copia o conteúdo do endereço $90 para o 
endereço $80, fazendo com que $80 seja igual a 0. Após essa operação H:X será 
incrementado (H:X = $91 (armazenará o endereço 91). 
 
CLR 
 
 Apaga o conteúdo de um registrador ou posição de memória especificada. 
 
 Exemplos 
 
 CLRA ;Apaga o conteúdo do acumulador (A=0) 
 CLRX ;Apaga o conteúdo de X (X=0) 
 CLRH ;Apaga o conteúdo de H (H=0) 
 CLR $80 ;Apaga o conteúdo da posição $80 da memória 
 
TAP 
 
 Copia o conteúdo do Acumulador para o CCR (registrador de estado do 
processador). 
 
 Exemplos 
 
 LDA #$FA ;Carrega o acumulador com o valor $FA 
 TAP ;Copia o conteúdo de A para o registrador CCR 
 
TPA 
 
 Copia o conteúdo do CCR para o acumulador 
 
 Exemplo 
 
 TPA ;Copia o conteúdo do CCR para A 
 
 
 
 
 
TAX 
 
 O conteúdo do Acumulador é copiado para o registrador X. 
 
 Exemplos 
 
 LDA #5 ;Carrega o acumulador com o valor 5 decimal 
 TAX ;Copia o valor e A para X (A=5) 
 
 TXA 
 
 O conteúdo do registrador X é copiado para o Acumulador. 
 
 Exemplo 
 
 TXA ;Supondo que X valha $10, esse comando copia o valor de X para o 
acumulador (A). 
 
TSX 
 
 O conteúdo do apontador de pilha (SP) mais 1 é copiado para o registrador de índice 
(H:X). 
 
 Exemplo 
 
 TSX ;Supondo que SP=$F0, esse comando copia o conteúdo do SP mais 1, 
para H:X, fazendo com que H:X = $F1 
 
TXS 
 
 O conteúdo do registrador de índice (H:X) menos 1 é copiado para o apontador de 
pilha (SP). 
 
 Exemplo 
 
 TXS ;supondo que H:X = $F1, tal comando copia o conteúdo de H:X 
menos 1 para o SP, fazendo com que SP=$F0 
 
RSP 
 
 Reseta o conteúdo do SP (apontador de pilha), restaurando sua condição-padrão 
($00FF). 
 
 Exemplo 
 
 RSP ;Supondo que SP =$F0, esse comando reinicia o apontador de pilha 
(SP=$00FF) 
PSHA (Pop A) 
 
 Armazena o Acumulador na Pilha, e logicamente o apontador da pilha é 
decrementado em 1. 
 
 Exemplo 
 
 PSHA ;Supondo que o Acumulador seja $AB e que o apontador aponte para 
$FF (SP=$FF), esse endereço, $FF, conterá o valor do Acumulador, $AB, e SP valerá $FE, 
pois foi decrementado. 
 
PULA (PUSH AND LOAD A) 
 
 O acumulador é carregado com o conteúdo do endereço apontado pelo apontador de 
pilha, SP. Este é incrementado em 1 para apontar para o próximo endereço. 
 
 Exemplo 
 
 PULA ;Supondo que SP=$FE e que ($FF)=$1F. O apontador SP é 
incrementado, valendo $FF e o valor do endereço $FF será imbutido no Acumulador 
 
PSHH (POP H) 
 
 O conteúdo do registrador H é armazenado no topo da pilha e o SP é decrementado 
em 1. 
 
 Exemplo 
 
 PSHH ;Supondo que H=$10 e que SP=$FF. Assim, nesse comando o 
conteúdo do endereço $FF passa a valer $10, e o SP decrementa e contém $FE 
 
PULH (PUSH AND Load H) 
 
 O indicador do topo da pilha é incrementado e o ultimo valor empilhado é retirado 
da pilha e armazenado em H . 
 
 Exemplo 
 
PULH ;Supondo que SP=$F0 e ($F1)=$05. Tal comando faz SP conter $F1 e faz o 
registrador H conter $05 
 
 
 
 
 
 
 
PSHX (POP X) 
 
 O conteúdo do registrador X é armazenado no topo da pilha e o apontador da pilha é 
decrementado em 1. 
 
 Exemplo 
 
 PSHX ;Supondo que X=$15 e que SP=$F5. Após a execução da instrução, 
SP irá conter $F4 e o conteúdo do endereço $F5 conterá o valor do registrado X, no caso, 
$15. 
 
PULX (PUSH AND LOAD X) 
 
 O indicador do topo da pilha (SP) é incrementado e o ultimo valor empilhado é 
retirado da pilha e armazenado em X. 
 
 Exemplo 
 
 PULX ;Supondo que SP=$F4 e $F5=$1A. Esse comando incrementa o SP, 
valendo agora $F5 e coloca o valor dessa posição de memória em X. 
Instruções de Manipulação de Bits 
 
 
BSET (BIT SET) 
 
 Seta o bit n(de 0 a 7) de uma posição da memória. 
 
 Exemplos 
 
 CLR $80 ;Limpa o conteúdo da posição $80 da memória 
 BSET 0,$80 ;Seta o bit 0 da posição $80 da memória 
 BSET 1,$80 ;Seta o bit 1 da posição $80 da memória 
 BSET 7,$80 ;Seta o bit 7 da posição $80 da memória. Ao total, nesse ponto o 
valor contido nessa posição de memória de zero será $83 ou 10000011B (Binário) 
 
BCLR (BIT CLEAR) 
 
 Apaga o bit n (de 0 a 7) de uma posição de memória. 
 
 Exemplos 
 
MOV #$FF, $80 ;Primeiro copiamos o valor $FF (11111111B) para a posição 
$80 da memória 
 BCLR 3,$80 ;Apaga o bit 3 da posição $80 da memória 
 BCLR 2,$80 ;Apaga o bit 2 da posição $80 d amemória 
 BCLR 7,$80 ;Apaga o bit 7 da posição $80 da memória. Nesse ponto, o seu 
conteúdo valerá $73 (01110011B) 
Instruções Aritméticas e Lógicas 
 
 
ADC (ADD WITH CARRY) 
 
 Efetua adição com o Acumulador mais o operando de algum endereço de memória 
mais o conteúdo de Carry. O Carry, ou C, está presente no registrador de código de 
condição (CCR). Nesse caso, C será 1 se a soma ultrapassou 8 bits. (Realiza soma para 
valores maioresque 8 bits). 
 
 Exemplos 
 
 MOV #10, $90 ;Copia o valor 10 decimal para o endereço $90 
 LDA #10 ;Copia o valor 10 decimal para o acumulador 
 SEC ;SET C – seta o bit de carry no CCR 
 ADC $90 ;soma tudo, A + ($90) + C -> $10 + $10 +1, que será $21. 
como a soma não deu overflow, o bit C do CCR será zero de novo... 
 ADC #$FF ;soma, A + $FF + C -> $21 + $FF + 0, que será 276 
(100010100B). A soma ultrapassou 8 bits, então será armazenado apenas os 8 bits 
inferiores( 00010100B) em A e o nono bit irá para o C, valendo 1 no caso. 
 
ADD 
 
 Soma o conteúdo do Acumulador com o do operando da memória. O resultado da 
soma é armazenado em A. 
 
 Exemplos 
 
 MOV #10, $90 ;Copia o valor 10 decimal para o endereço $90 
 LDA #10 ;Copia o valor 10 decimal para o acumulador 
 SEC ;SET C – seta o bit de carry no CCR 
 ADD $90 ;Soma tudo, A + ($90) -> $10 + $10, que será $20. como a 
soma não deu overflow, o bit C do CCR será zero de novo... 
 ADD #$FF ;Soma, A + $FF + -> $20 + $FF + , que será 275 
(100010011B). A soma ultrapassou 8 bits, então será armazenado apenas os 8 bits 
inferiores( 00010011B) em A e o nono bit irá para o C, valendo 1 no caso. 
 
AIS 
 
O operando sinalizado imediato é adicionado ao conteúdo do apontador de pilha (SP). 
 
 Exemplos 
 
 LDHX #$1234 ;Carrega H:X com o valor $1234 
 TXS ;Copia o conteúdo de H:X -1 para SP (SP=$1233) 
AIS #$10 ;Adiciona 10 ao conteúdo de H:X (H:X=$1243) 
AIX 
 
 O operando sinalizado imediato é adicionado ao conteúdo do registrador de índice 
(H:X). 
 
 Exemplos 
 
 LDHX #$1234 ;Carrega H:X com o valor $1234 
 AIX #$10 ;Adiciona 10 ao conteúdo de H:X (H:X=$1234) 
 
SBC (SUBTRACT WITH CARRY) 
 
 Efetua subtração com o Acumulador mais o operando de algum endereço de 
memória mais o conteúdo de Carry. O Carry, ou C, está presente no registrador de código 
de condição (CCR). Nesse caso, C será 1 se o resultado da subtração ultrapassou 8 bits. 
(Valor da memória mais C eram maiores que o conteúdo do acumulador). 
 
 Exemplos 
 
 MOV #40,$81 ;Copia o valor 20 decimal para o endereço $81 
 LDA #100 ;Copia o valor 100 decimal para o acumulador 
 CLC ;CLEAR C, ou seja, apaga o flag C do CCR (C=0) 
SBC $81 ;Subtrai o Acumulador com o conteúdo da posição $81 e o 
flag C (A=A-($81)-C = 100 -40 -0 =60 
SEC ;Seta o flag C (C=1) 
SBC #59 ;Subtrai 59 e o C do conteúdo de A (A=60-59-1=0) 
SBC #1 ;Subtrai 1 e C do conteúdo de A (A=0-1-0=$FF). Nesse caso, 
o bit C foi setado pois o resultado é um número negativo 
 
SUB 
 
 Subtrai o conteúdo do acumulador do operando. O resultado é armazenado no 
acumulador (A) 
 
 Exemplos 
 
 MOV #40,$81 ;Copia o valor 20 decimal para o endereço $81 
 LDA #100 ;Copia o valor 100 decimal para o acumulador 
 CLC ;Apaga o flag C (C=0) 
 SUB $81 ;Subtrai o conteúdo da posição $81 do conteúdo do 
acumulador (A=A-($81) = 100 – 40=60 
 SUB #70 ;Subtrai 60 do conteúdo de A (A=60-70=-10=$F6). Comoo 
resultado deu negativo, o valor binário de C foi setado (C=1) 
 
 
 
 
MUL 
 
 Multiplicação do conteúdo de X pelo conteúdo de A, armazenando o resultado de 
até 16 bits de forma concatenada nos registradores X (parte alta do resultado) e A (parte 
baixa do resultado). 
 
 Exemplos 
 
 LDX #$10 ;Carrega X com o valor $10 
 LDA #$8 ;Carrega A com o valor $8 
 MUL ;Multiplica A*X = $8 * $10 = $80 (A=$8, X=0) 
 LDX #$10 ;Carrega X com o valor $10 
MUL ;Multiplica A * X = $80 * $10 = $800 (A=0, X=$8) 
 
 
DIV 
 
 Efetua a operação H:A / X, ou seja, divide o conteúdo de 16 bits formado pela 
concatenação de H(parte alta do valor) e A(parte baixa) pelo conteúdo de X. O quociente 
da divisão é armazenado em A e o resto é armazenado em H. 
 Caso o quociente seja maior que 255 ($FF) ou X seja igual a zero (divisão por zero), 
o flag C será setado, indicando o erro. Nesse caso, o resultado em A e H é indeterminado. 
 
 Exemplos 
 
 LDA #$03 ;Carrega A com $03 
 PSHA ;Guarda A na pilha 
 LDA #$E8 ;Carrega A com $E8 
 PULH ;Carrega H da pilha (H=$03), H:A = $03EB (1000 decimal) 
 LDX #$14 ;Carrega X com $14 (20 decimal) 
 DIV ;Divide H:A por X ($03EB / $14 = $32, ou seja, 1000 / 20 = 50. O 
valor $32 é armazenado em A e o resto é armazenado em H (H=0) 
 
 
INC 
 Incrementa ao conteúdo de um registrador ou posição de memória. 
 
 Exemplos 
 
 LDA #100 ;Copia o valor 100 decimal para o Acumulador 
 INCA ;Incrementa A 
 STA $80 ;Copia o conteúdo de A ,101, para o endereço $80 da memória 
 INC $80 ;Incrementa o valor aramzenado na posição $80 da memória, que 
passa ser 102 
 
 
 
DEC 
 Decrementa (subtrai 1) do conteúdo de um registrador ou posição de memória. 
 
 Exemplos 
 
 LDA #100 ;Copia o valor 100 decimal para o acumulador 
 DECA ;Decrementa A (A=99 decimal) 
 STA $80 ;Copia o conteúdo de A para o endereço $80 da memória 
 DEC $80 ;Decrementa o conteúdo do endereço $80 de memória 
 
DAA 
 
 Após uma operação, tal comando ajusta o resultado no formato BCD (Binary Code 
Decimal) 
 
 Exemplos 
 
 MOV #$39,$81 ;Copia o valor 39 hexadecimal para o endereço $81 da 
memória 
 LDA #3 ;Carrega o valor 3 no Acumulador 
 ADD $81 ;Adiciona o acumulador ao valor contido no endereço $81 da 
memória (A = $3 + $30 = $3C) 
 DAA ;Ajusta o valor do acumulador (A = 42) 
 MOV #$60,$80 ;Copia o valor hexadecimal 60 para o endereço $80 da 
memória 
 ADD $80 ;Adiciona o acumulador ao conteúdo do endereço $80 de 
memória. Assimo acumulador contém o valor $102. 
 DAA ;Ajusta o acumulador (A=$02) e C=1, indicando o estouro da 
capacidade de representação BCD do Acumulador 
 
AND 
 
 Realiza a operação AND, bit a bit, do conteúdo do acumulador e um valor contido 
em alguma posição específica de memória. 
 
 Exemplos 
 
 MOV #$67, $80 ;Copia o valor 67 hexadecimal para a posição $80 de memória 
 LDA #$F0 ;Carrega A com $F0 
 AND $80 ;Efetua a operação AND entre o conteúdo do acumulador e o 
conteúdo da posição $80 de memória (A= $FO & $67 = $60) 
 AND #$85 ;Efetua a operação AND entre o conteúdo do acumulador e 
aconstante imediata $85 (A = $60 & $85 = $00) 
 
 
 
 
ORA 
 
 Efetua OU lógico, bit a bit, do conteúdo do acumulador com alguma posição 
específica de memória 
 
 Exemplos 
 
 MOV #$67, $80 ;Copia o valor hexadecimal $67 para a posição $80 d 
ememória 
 LDA #$10 ;Carrega A com $10 
 ORA $80 ;Efetua OU lógico entre o Acumulador e o valor da posição 
$80 de memória(A = $10 + $67 = $77) 
 ORA #$85 ;Efetua o OU lógico entre o Acumulador e a constante 
imediata $85, ou seja, o resultado será $F7 
 
EOR 
 
 Efetua a operação OU EXCLUSIVO bit a bit do conteúdo do acumulador ao 
conteúdo de algum endereço de memória especificado. 
 
 EXEMPLOS 
 
 MOV #$67, $80 ;Copia o valor 67 hexadecimal para o endereço $80 da 
memória 
 LDA #$12 ;Carrega A com 12 
 EOR $80 ;Efetua o OR EXCLUSIVO entre o conteúdo do Acumulador 
e o endereço $80. (A=$12 XOU $67 = $75) 
 EOR #$75 ;Efetua a operação XOR entre o conteúdo do acumulador e a 
constante imediata $85 (A=$75 XOU $75 = $00) 
 
COM 
 
 Faz o complemento de um em algum oerando especificado (A, X ou memória) e 
armazenado também. 
 
 Exemplos 
 
 MOV #$67, $80 ;Copia o valor 67 hexa na posição $80 da mem 
 LDA #$F1 ;Carrega A Com $F1 
 COM $80 ;Complementa o conteúdo da posição 80 de mem (era $67, 
passa a ser $98) 
 COMA ;Complementa o conteúdo do acumulador (seu conteúdo, que 
era $F1, passa a ser $0E 
 
 
 
 
NEG 
 
 Faz a negação do operando especificado (A, X ou memória) e armazenado também. 
 Ela equivale a operação complemento de dois, que é o complemento de um seguido 
de um incremento. 
 
 Exemplos 
 
 MOV #$67, $80 ;Copia o valor 67 hexa na posição $80 da mem 
 LDA #$F1 ;CarregaA Com $F1 
 NEG $80 ;Nega o conteúdo da posição $80 de memória (de $67 passa a 
ser $99) 
 NEGA ;Nega o conteúdo do Acumulador (o seu conteúdo, que era 
$F1, passa a ser $0F) 
 
 
NSA (NIBBLE AND STORE A) 
 
 Faz a troca dos Nibbles (grupo de 4 dígitos) do acuulador e armazena o resultado no 
próprio Acumulador. 
 
 Exemplos 
 
 LDA #$F1 ;Carrega A com $F1 
 NSA ;Troca os nibbles do acumulador, ou seja, após a operação, 
passa conter $1F 
 
 
ASL (ARITMETIC SHIFT LEFT) 
 
 Efetua o deslocamento aritmético em uma unidade à esquerda do operando (A, X ou 
memória). O bit mais significativo vai pro Carry - C – e o bit menos significativo é 
preenchido com zero. 
 
 Exemplos 
 
 MOV #$13,$80 ;Copia o valor 13 hexa para o endereço $80 
 ASL $80 ;Desloca o conteúdo de $80 uma posição à esquerda e seu 
conteúdo passa valer $26. 
 
 O deslocamento de um bit à esquerda equivale a multilicar por dois. Por exemplo, 
01B vale 1 decimal. Deslocando à esquerda temos 010, que é 2, e deslocando mais uma vez 
teremos 0100, o valor 4. ASLA desloca A à esquerda. 
 
LSL (LOGICAL SHIFT LEFT) 
 
 O mesmo que ASL. 
ROL (ROTATE LEFT) 
 
 Faz a rotação do conteúdo do operando (A, X ou a memória), ou seja, os bits do 
operando são deslocados uma posição à esquerda, sendo o bit mais significativo deslocado 
para o carry – C –e o conteúdo de C anterior é armazenado no bit menos significativo. 
 
 Exemplos 
 
 MOV #$34,$80 ;Copia o valor 34 hexadecimal para o endereço $80 da 
memória 
 SEC ;Seta o carry 
 ROL $80 ;Rotaciona o valor contido em $80 
 0011 0100 ($34) 
 0011 0100 � 1 (Carry) 
 (Carry) 0 � 0110 1001 
 
ASR (ARITMETIC SHIFT RIGTH) 
 
 Efetua o deslocamento aritmético em uma unidade à direita do operando (A, X ou 
memória). O bit mais significativo (o da extrema esquerda) permanece inalterado e o bit 
menos significativo é deslocado pro Carry -C-. 
 
 Exemplos 
 
 MOV #$FA, $80 ;copia o valor hexadecimal FA para a posição de memória 
$80 
 ASR $80 ;Desloca o conteúdo do endereço $80 da memória uma 
posição à direita. O 1 à extrema esquerda permanece inalterado e o zero à extrema direita 
vai pro Carry do registrador CCR. 
 1111 1010 ($FA) 
 � 1111 1010 
 1111 1101 � 0 ($FD) 
 
LSR (LEFT SHIFT RIGTH) 
 O mesmo esquema com o ASR, porem ao invéz de copiar o bit à extrema esquerda, 
ele é preenchido com zero. 
 
 Exemplos 
 
 MOV #$FA, $80 ;copia o valor hexadecimal FA para a posição de memória 
$80 
 ASR $80 ;Desloca o conteúdo do endereço $80 da memória uma 
posição à direita. O 1 à extrema esquerda é preenchido com zero e o zero à extrema direita 
vai pro Carry do registrador CCR. 
 1111 1010 ($FA) 
 � 1111 1010 
 0111 1101 � 0 ($FD) 
 
ROR (ROTATE RIGTH) 
 
 Faz a rotação do conteúdo do operando (A, X ou a memória), ou seja, os bits do 
operando são deslocados uma posição à direita, sendo o bit menos significativo deslocado 
para o carry – C –e o conteúdo de C anterior é armazenado no bit mais significativo. 
 
 Exemplos 
 
 MOV #$65,$80 ;Copia o valor 67 hexadecimal para o endereço $80 de 
memória 
 CLC ;Apaga o “flag” C (C=0) 
 ROR $80 ;Rotaciona o conteúdo do endereço $80 
 0110 0101 ($65) 
 � 0110 0101 
(aqui entra o zero do C) 0011 0010 � 1 pro C (valor=$32) 
 
Instruções de teste e desvio 
 
 
CMP (COMPARE) 
 
 Compara o conteúdo do acumulador com o conteúdo da posição de memória ou do 
operando imediato especificado. Tal comparação é feita subtraindo o conteúdo da memória 
do conteúdo do acumulador. 
 
 Exemplos 
 
 MOV #$39, $80 ;Copia o valor 39 hexadecimal para o endereço $81 
 LDA #$38 ;Carrega o valor $38 para o Acumulador 
 CMP $80 ;Compara o acumulador com a posição $80 de memória. C=1, 
indicando que o conteúdo da memória é maior que o conteúdo do Acumulador. 
 MOV #$10,$80 ;Copia o valor hexa 10 para o endereço $80 
 CMP $80 ;Compara o valor contido nesse endereço com o acumulador. 
C=0, indicando que o conteúdo da memória é menor que o conteúdo do acumulador. O flag 
Z, presente no registrador CCR, será zero (Z=0) pois o resultado não foi igual a zero (38 do 
acumulador – 10 da posição de memoria > 0). Nos outros caso acima também. 
 MOV #$38,$80 ;Copia o valor hexa 38 para a posição $80 de memória 
 CMP $80 ;Compara o valor contido nesse endereço com o acumulador. 
O flag Z, presente no registrador CCR, será setado (Z=1) pois o resultado foi igual a zero 
(38 do acumulador – 38 da posição de memoria = 0) realizado na comparação. 
 
 
CPX (COMPARE X) 
 
 Compara o conteúdo do registrador de índice X com o conteúdo da posição de 
memória ou do operando imediato especificado. A comparação é feita subtraindo o 
conteúdo da posição de memória especificado com o conteúdo armazenado em X. Z será 
setado se tal subtração for igual a 0 e C será setado se se o resultado for menor que zero 
(Valor da memória maior que o conteúdo do registrador X). 
 
 Exemplos 
 
 MOV #$5A, $80 ;Copia o valor 5A hexadecimal para o endereço $81 
 LDX #$80 ;Carrega o valor $80 para o X 
 CMP $80 ;Compara o X com a posição $80 de memória. Como X é 
maior que o conteúdo de memória, V=1 e C=0 
 
 
 
 
 
 
CPHX (COMPARE HX) 
 
 Compara o conteúdo do par de registradores H:X com o conteúdo de 16 bits da 
memória ou do operando imediato. Como envolve uma comparação de 16 bits, usa-se o 
endereço especificado (MSB – MOST SIGNIFICANT BIT) e o endereço seguinte (LSB – 
LESS SIGNIFICANT BIT).Os bits C e Z se comportam de maneira similar ao CPX 
 
 Exemplos 
 
 MOV #$12,$80 ;Copia o valor hexa 12 para a posição $80 de memória 
 MOV #$35,$81 ;Copia o valor hexa 35 para a posição seguinte de memória, 
$81 
 LDHX #$1234 ;Carrega em HX o valor $1234 
 CPHX $80 ;Compara H:X com o conteúdo do endereço $80 e $81.C 
NÃO será setado pois o resultado da subtração não é menor que zero ($1235 - $1234 >0) 
 
CBEQ (COMPARE AND BRANCH IF EQUAL) 
 
 Compara o conteúdo do acumulador (A) ou registrador de índice (X) com o 
conteúdo de uma posição específica de memória e desvia se forem iguais. 
 É uma instrução que é considerada a união de outras duas, a CMP e BEQ(desvia se 
igual), e tem o bebefício de não alterar os flags e ser mais rapida que as outas duas. 
 Existem variantes, com mnemonicos diferentes: CBEQA (para o Acumulador) e 
CBQEX (para o X). 
 
 Exemplos 
 
 Nesse exmplo tem-se uma rotina que procura um caractere (no caso o espaço) em 
uma string de memória. 
LDA #$20 ;Carrega o valor $20 – um codigo de um caractere – a 
ser procurado 
LDHX #$0080 ;Carrega o endereço inicial da string em H:X 
DENOVO CBEQ X+,DENOVO ;Compara o conteúdo do acumulador com o conteúdo 
da posição de memória apontada por H:X 
 AIX #-1 ;Subtrai 1 de H:X 
 
BRA (BRANCH) 
 
 Efetua o desvio do fluxo do programa. O operando da instrução é um endereço 
relativo de 8 bits em complemento de dois, permitindo o desvio para até 127 posições 
adiante e 128 posições para trás. 
 
Ao todo são 24 instruções diferentes para o desvio do programa 
 
 BRA – desvio incondicional 
 BRN – não desvia (equivale a um NOP d etrês ciclos) 
 BEQ – desvia se igual (ou seja, Z=1) 
 BNE – desvia se diferente (se Z=0) 
 BPL – desvia se positivo (se N=0) 
 BMI – desvia se negativo (se N=1) 
 BCC – desvia se o carry igual a zero (C=0) 
 BCS – desvia se o carry igual a um (C=1) 
 BHCC – desvia se o carry de dígito igual a zero (H=0) 
 BHCS – desvia se o carry de dígito igual a um (H=1) 
 BMC – desvia se as interrupções estiverem habilitadas (se I=0) 
 BMS – desvia se as interrupções estiverem desabilitadas (se I=1) 
 BRCLR – desvia se o bit n da memória estiver apagado (nivel 0) 
 BRSET – desvia se o bit n d amemória estiver apagado (nivel 1) 
Após operações (CMP, CPHX, CPX, SBC,ou SUB)envolvendo operandos sem sinal: 
 BHI – desvia se maior (se C e Z=0) 
 BHS – desvia se maior ou igual (se C=0) 
 BLS – desvia se menor ou igual (se C ou Z=1) 
 BLO – desvia se menor (se C=1) 
Após operações (CMP, CPHX, CPX, SBC ou SUB) envolvendo operandos no formato 
complemento de dois: 
 BGT – desvia se maior(se Z=1 ou N=V) 
 BGE – desvia se maior ou igual (se N=V) 
 BLE – desvia se menor ou igual (se Z=1 ou N=V) 
 BLT – desvia se menor (se N!=V)(N não igual a V) 
 
 Exemplos 
 
 MOV #$14, $80 ;Carrega o valor $14 (00010100B) no endereço $80 
 BRSET 2,$80,Teste ;Testa se o bit 2 do valor da posição de memória $80 
está em nível 1. Como é o caso, desvia para o fluxo Teste. 
 BRA FIM ;Desvia o programa para a etiqueta FIM 
 
BIL 
 Testa o pino IRQ e desvia para o endereço relativo caso esteja em nível ‘0’ 
 
 Exemplo 
 
 BIL IRQ_ZERO ;Teste o pino IRQ e se estiver em 0 desvia para IRQ_ZERO 
 
BIH 
 Testa o pino IRQ e desvia para o endereço relativo caso esteja em nível ‘1’ 
 
 Exemplo 
 
 BIH IRQ_UM ; Teste o pino IRQ e se estiver em 1 desvia para IRQ_UM 
 
 
 
 
TST 
 
 Testa o conteúdo do registrador A,X ou da memória, modificando os bits Z e N no 
CCR, de acordo. 
 
 Exemplos 
 
 TSTA ;Caso o conteúdo do acumulador seja 0, tal comando testa esse valor 
e como ele é zero, o bit Z é setado e o N é apagado, pois A=0 
 TST $90 ; Caso o conteúdo da posição d ememória $90 seja 129, tal comando 
testa esse valor e como ele maior que 8 bits, o bit Z é apagado e o N é setado, pois o bit 7 
do valor esta em nivel lógico 1. 
 
DBNZ 
 
 Decrementa o conteúdo do operando (A, Xou a memória) e desvia para o endereço 
relativo caso o resultado seja diferente de zero. 
 
 Exemplos 
 
 DBNZA PONTO_A ;Decremnta o acumulador (A) e desvia para o 
endereço PONTO_A caso A difira de zero 
 DBNZX REPETE ;Decrementa X e desvia para REPETE caso X seja 
diferente de zero 
 DBNZ $80,REP ;Decremneta o conteúdo do endereço $80 e desvia 
para REP caso o conteúdo do mesmo seja diferente de zero 
 DBNZ 5,X,LOOP ;Decrementa o conteúdo do endereço especificado pela 
soma de H:X mais 5. Caso o resultado seja diferente de zero, desvia para LOOP 
 
BSR 
 
 Faz o desvio do fluxo do programa. O operando da instrução é um endereço relativo 
de 8 bits em complemento de dois, permitindo io desvio para até 127 posições adiante e 
128 posições para trás. 
 O conteúdo do PC mais 2 é salvo na pilha em duas partes: primeiro é empilhada a 
parte baixa (8 bits menos significativos) depois a parte alta (8 bits mais significativos). 
 Em seguida, o endereço da subrotina é carregado no PC, fazendo com que o 
programa desvie. 
 
 Exemplo 
 
 BSR MULT16 ;Desvia para a subrotina chamada MULT16 
 
 
 
 
 
JMP (JUMP) 
 
 Desvio absoluto da rotina 
 
 Exemplos 
 
 JMP $80 ;Desvia para o endereço $0080 da memória 
 JMP $1000 ;Desvia para o endereço $1000 da memória 
 JMP INICIO;Desvia para o endereço DESVIO da memória 
 JMP 10,X ;Desvia para o endereço obtido oela soma do conteúdo de H:X mais 
10 
 
JSR 
 
 Retorno de uma subrotina 
 
 Exemplos 
 
 JSR $20 ;Desvia para a subrotina no endereço $20 
 JSR CALCULA ;Desvia para a subrotina CALCULA 
 JSR 1000,X ;Desvia para a subrotina no endereço especificado pelo 
conteúdo de H:X + 1000 
 
RTS 
 
 Retorno de interrupção. 
 
 Exemplo 
 
 RTS ;Retorna da rubrotina atual 
 
RTI 
 
 Provoca o retorno do fluxo do programa ao ponto seguinte ao de onde ocorreu a 
interrupção. 
 
 Exemplo 
 
 RTI ;Retorno de interrupção 
 
Instruções de controle do Processador 
 
 
SEC (SET C) 
 
 Seta o flag de transporte, ou carry, fazendo com que C=1. 
 
 Exemplo 
 
 SEC ;Seta C (C=1) 
 
CLC (CLEAR C) 
 
 Apaga o flag de transporte, ou carry, fazendo com que C=0. 
 
Exemplo 
 
CLC ;Apaga C (C=0) 
 
SEI (SET INTERRUPTION) 
 
 Seta o bit de interrupção (flag I do CCR – registrador de codigo de condição) 
fazendo com que as interrupções sejam desabilitadas. 
 
 Exemplo 
 
 SEI ;Seta o bit I do CCR 
 
CLI (CLEAR INTERRUPTION) 
 
Limpa o bit de interrupção (flag I do CCR – registrador de codigo de condição) 
fazendo com que as interrupções sejam habilitadas. 
 
Exemplo 
 
CLI ;Limpa o bit I do CCR 
 
NOP (NO OPERATION) 
 Interrupção por software, nenhuma instrução é executada. Apenas o PC é 
incrementado de forma a apontar a próxima instrução a ser executada. 
 
 Exemplo 
 
 NOP ;Gasta 4 ciclos de clock principal 
 
 
SWI 
 
 Parada completa do processador, ocorrndo um interrupção na execução do 
programa. Possui a mais alta prioridade dentre as interrupções. 
 
 Exemplo 
 
 SWI ;Provoca uma interrupção 
 
STOP 
 
 Parada do processador, desligando o clock da CPU, reduzindo o consumo de 
energia. 
 
 Exemplo 
 
 STOP ;Coloca a CPU em modo de parada 
 
WAIT 
 
 Coloca a CPU em modo de espera (WAIT) no qual o clock da CPU é paralizado, 
mas os periféricos continuam ativos (caso estejam habilitados) e sõa capazes de gerar 
interrupções. 
 
 Exemplo 
 
 WAIT ;Coloca a CPU no modo de espera

Outros materiais

Outros materiais