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