Baixe Manual de Assembly: Instruções de Processamento de Dados e outras Notas de estudo em PDF para Engenharia Elétrica, somente na Docsity!
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 A cumulador 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.
TAX
O conteúdo do A cumulador é 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 A cumulador.
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 = $F
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=$F
RSP
R eseta 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 ( P op A )
Armazena o A cumulador na P ilha, 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 ( PU SH AND L OAD 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 ( P OP 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 ( PU SH AND L oad 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 $
Instruções de Manipulação de Bits
BSET ( B IT S ET)
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 ( B inário)
BCLR ( B IT CL EA R )
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 ( AD D WITH C ARRY)
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 maiores que 8 bits).
Exemplos
MOV #10, $90 ;Copia o valor 10 decimal para o endereço $ LDA #10 ;Copia o valor 10 decimal para o acumulador SEC ; SE T 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 $ LDA #10 ;Copia o valor 10 decimal para o acumulador SEC ; SE T 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 $ 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)
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 $ LDA #$8 ;Carrega A com o valor $ MUL ;Multiplica A*X = $8 * $10 = $80 (A=$8, X=0) LDX #$10 ;Carrega X com o valor $ 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 $ PSHA ;Guarda A na pilha LDA #$E8 ;Carrega A com $E 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 $F 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)
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 ;Carrega A Com $F 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 ( N IBBLE AND S TORE 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 $F NSA ;Troca os nibbles do acumulador, ou seja, após a operação, passa conter $1F
ASL ( A RITMETIC S HIFT L EFT)
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 $ 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 ( L OGICAL S HIFT L EFT)
O mesmo que ASL.
ROL ( RO TATE L EFT)
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 $ 0011 0100 ($34) 0011 0100 1 (Carry) (Carry) 0 0110 1001
ASR ( A RITMETIC S HIFT R IGTH)
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 $ 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 ( L EFT S HIFT R IGTH) 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 $ 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)
Instruções de teste e desvio
CMP ( C O MP ARE)
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 $ 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 $ 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 ( C OM P ARE 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 $ 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=
CPHX ( C OM P ARE 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, $ LDHX #$1234 ;Carrega em HX o valor $ 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 ( C OMPARE AND B RANCH IF EQ UAL)
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 ( BRA NCH)
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)
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= 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 MULT
JMP ( J U MP )
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 $ 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
