Instruções do Microcontrolador HC908Q

Transcrição

1 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). 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. 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.

2 LDX Carrega um valor imediato ou da memória no registrador X. 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. 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. 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). 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.

3 MOV Copia uma constante imediata para uma posição de memória ou um valor entre um aposição de memória e outra. 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 TAP Apaga o conteúdo de um registrador ou posição de memória especificada. 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 Copia o conteúdo do Acumulador para o CCR (registrador de estado do processador). LDA #$FA TAP ;Carrega o acumulador com o valor $FA ;Copia o conteúdo de A para o registrador CCR TPA Copia o conteúdo do CCR para o acumulador TPA ;Copia o conteúdo do CCR para A

4 TAX O conteúdo do Acumulador é copiado para o registrador X. LDA #5 TAX ;Carrega o acumulador com o valor 5 decimal ;Copia o valor e A para X (A=5) TXA O conteúdo do registrador X é copiado para o Acumulador. TXA acumulador (A). ;Supondo que X valha $10, esse comando copia o valor de X para o TSX O conteúdo do apontador de pilha (SP) mais 1 é copiado para o registrador de índice (H:X). 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). 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). RSP (SP=$00FF) ;Supondo que SP =$F0, esse comando reinicia o apontador de pilha

5 PSHA (Pop A) Armazena o Acumulador na Pilha, e logicamente o apontador da pilha é decrementado em 1. 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. 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) em 1. O conteúdo do registrador H é armazenado no topo da pilha e o SP é decrementado 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. PULH ;Supondo que SP=$F0 e ($F1)=$05. Tal comando faz SP conter $F1 e faz o registrador H conter $05

6 PSHX (POP X) O conteúdo do registrador X é armazenado no topo da pilha e o apontador da pilha é decrementado em 1. 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. 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.

7 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. 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 B (Binário) BCLR (BIT CLEAR) Apaga o bit n (de 0 a 7) de uma posição de memória. MOV #$FF, $80 ;Primeiro copiamos o valor $FF ( B) 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 ( B)

8 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). 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 ( B). A soma ultrapassou 8 bits, então será armazenado apenas os 8 bits inferiores( B) 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. 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 ( B). A soma ultrapassou 8 bits, então será armazenado apenas os 8 bits inferiores( B) 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). 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)

9 AIX O operando sinalizado imediato é adicionado ao conteúdo do registrador de índice (H:X). 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). 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 = =60 SEC ;Seta o flag C (C=1) SBC #59 ;Subtrai 59 e o C do conteúdo de A (A= =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) 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) = =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)

10 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). 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. 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. 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

11 DEC Decrementa (subtrai 1) do conteúdo de um registrador ou posição de memória. 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) 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. 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)

12 ORA Efetua OU lógico, bit a bit, do conteúdo do acumulador com alguma posição específica de memória 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. 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

13 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. 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. 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. 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.

14 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. 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 $ ($34) (Carry) (Carry) 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-. 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 ($FA) ($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. 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 ($FA) ($FD)

15 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. MOV #$65,$80 memória CLC ;Copia o valor 67 hexadecimal para o endereço $80 de ;Apaga o flag C (C=0) ROR $80 ;Rotaciona o conteúdo do endereço $ ($65) (aqui entra o zero do C) pro C (valor=$32)

16 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. 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). 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

17 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 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 ($ $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). 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)

18 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) MOV #$14, $80 ;Carrega o valor $14 ( B) 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 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 BIH IRQ_UM ; Teste o pino IRQ e se estiver em 1 desvia para IRQ_UM

19 TST Testa o conteúdo do registrador A,X ou da memória, modificando os bits Z e N no CCR, de acordo. 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. 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. BSR MULT16 ;Desvia para a subrotina chamada MULT16

20 JMP (JUMP) Desvio absoluto da rotina 10 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 JSR Retorno de uma subrotina 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 RTS Retorno de interrupção. RTS ;Retorna da rubrotina atual RTI Provoca o retorno do fluxo do programa ao ponto seguinte ao de onde ocorreu a interrupção. RTI ;Retorno de interrupção

21 Instruções de controle do Processador SEC (SET C) Seta o flag de transporte, ou carry, fazendo com que C=1. SEC ;Seta C (C=1) CLC (CLEAR C) Apaga o flag de transporte, ou carry, fazendo com que C=0. 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. 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. 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. NOP ;Gasta 4 ciclos de clock principal

22 SWI Parada completa do processador, ocorrndo um interrupção na execução do programa. Possui a mais alta prioridade dentre as interrupções. SWI ;Provoca uma interrupção STOP Parada do processador, desligando o clock da CPU, reduzindo o consumo de energia. 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. WAIT ;Coloca a CPU no modo de espera