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 maiores que 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 ;Carrega A 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