Registradores da CPU do padrão 8051/52.

Símbolo Nome Endereço Valor inicialACC * Accumulator E0 0000 0000 (00)

B * B Register F0 0000 0000 (00)

PSW * Program Status Word D0 0000 0000 (00)

SP Stack Pointer 81 0000 0111 (07)

DPL Low Byte Dptr 82 0000 0000 (00)

DPH High Byte Dptr 83 0000 0000 (00)

P0 * Port 0 80 1111 1111 (FF)

P1 * Port 1 90 1111 1111 (FF)

P2 * Port 2 A0 1111 1111 (FF)

P3 * Port 3 B0 1111 1111 (FF)

IP * Interrupt Priority Control B8 xxx0 0000 (?0)

IE * Interrupt Enable Control A8 0xx0 0000 (?0)

TMOD Timer/Counter Mode Control 89 0000 0000 (00)

TCON * Timer/Counter Control 88 0000 0000 (00)

T2CON * ^ Timer/Counter 2 Control C8 0000 0000 (00)

TH0 Timer/Counter 0 High Byte 8C 0000 0000 (00)

TL0 Timer/Counter 0 Low Byte 8A 0000 0000 (00)

TH1 Timer/Counter 1 High Byte 8D 0000 0000 (00)

TL1 Timer/Counter 1 Low Byte 8B 0000 0000 (00)

TH2 ^ Timer/Counter 1 High Byte CD 0000 0000 (00)

TL2 ^ Timer/Counter 2 Low Byte CC 0000 0000 (00)

RCAP2H ^ T/C 2 Capture Reg. High Byte CB 0000 0000 (00)

RCAP2L ^ T/C 2 Capture Reg. Low Byte CA 0000 0000 (00)

SCON * Serial Control 98 0000 0000 (00)

SBUF Serial Data Buffer 99 xxxx xxxx (??)

PCON Power Control 87 0xxx 0000 (?0)

Descrição: ^ = 80C52 * = Bit endereçável x = Estado desconhecido.

XRL

XRL <dest-byte>,<src-byte>Função: OR exclusiva para variáveis do tipo byteDescrição: XRL realiza a operação OR exclusiva bit-a-bit entre as variáveis indicadas e armazena o resultado na

variável de destino. Nenhuma flag é afetada. Os dois operandos permitem seis combinações de endereçamento. Quando o destino é o acumulador, a fonte pode usar endereçamento por registrador, direto, registrador-indireto, ou imediato; quando o destino é um endereço direto, a fonte pode ser o Acumulador ou dado imediato. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: Se o acumulador contém 0C3H (11000011B) e o registrador 0 contém AAH (10101010B) então a instrução, XRL A, R0 deixa 69H (01101001B) no acumulador. Quando o destino é um byte endereçado diretamente, esta instrução poderá complementar combinações de bits de qualquer posição da RAM ou registrador do hardware. O byte máscara que determina o padrão de bits a serem limpados pode ser tanto uma constante contida na instrução como um valor calculado no acumulador durante a execução. A instrução,XRL P1, #00110001B

complementa os bits 5, 4, e 0 da porta de saída P1.

XRL A,Rn

Função: OR exclusiva com registrador para ACCBytes: 1Ciclos: 12Codificação: 0 1 1 0:1 r r rOperação: (A) « (A) XOR (Rn)Flags:

XRL A,direct

Função: OR exclusiva com byte direto para ACCBytes: 2Ciclos: 12Codificação: 0 1 1 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (A) XOR (direto)Flags:

XRL A,@Ri

Função: OR exclusiva com RAM indireta para ACCBytes: 1Ciclos: 12Codificação: 0 1 1 0:0 1 1 iOperação: (A) « (A) XOR ((Ri))Flags:

XRL A,#data

Função: OR exclusiva com dado imediato para ACCBytes: 2Ciclos: 12Codificação: 0 1 1 0:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (A) « (A) XOR #dadoFlags:

XRL direct,A

Função: OR exclusiva com ACC para byte diretoBytes: 2Ciclos: 12Codificação: 0 1 1 0:0 0 1 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « (direto) XOR ACCFlags:

XRL direct,#data

Função: OR exclusiva com dado imediato para byte diretoBytes: 3Ciclos: 24Codificação: 0 1 1 0:0 0 1 1 a7 a6 a5 a4:a3 a2 a1 a0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « (direto) XOR #dadoFlags:

XCHD

XCHD A,@RiFunção: Troca nibble inferior de RAM indireta com ACCDescrição: XCHD troca o nibble inferior do (Bits 3-0), geralmente representando um número hexadecimal ou um

digito BCD, com o conteúdo da RAM interna endereçado indiretamente pelo registrador especificado. Os nibbles superiores (bits 7-4) de cada registrador não são afetados. Nenhuma flag é afetada.

Exemplo: R0 contém o endereço 20H. O acumulador contém o valor 36H (00110110B). A posição 20H da RAM contém o valor 75H (01110101B). A instrução, XHCD A,@R0 deixa a posição 20H da RAM com o valor 76H (01110110B) e 35H (00110101B) no acumulador.

Bytes: 1Ciclos: 12Codificação: 1 1 0 1:0 1 1 iOperação: (A3-0) «» ((Ri3-0))Flags:

XCH

XCH A,<byte>Função: Troca o acumulador com variável byteDescrição: XCH carrega o acumulador com o conteúdo da variável indicada, ao mesmo tempo que escreve o valor

original do acumulador na variável indicada. O operando fonte/destino pode usar endereçamento por registrador, direto ou registrador-indireto.

Exemplo: R0 contém o endereço 20H. O acumulador contém o valor 3FH (00111111B). A posição 20H da RAM contém o valor 75H (01110101B). A instrução, XCH A, @R0 deixa a posição 20H da RAM com os valores 3FH (00111111B) e 75H (01110101B) no acumulador.

XCH A,Rn

Função: Troca registrador com ACCBytes: 1Ciclos: 12Codificação: 1 1 0 0:1 r r rOperação: (A) «» (Rn)Flags:

XCH A,direct

Função: Troca byte direto com ACCBytes: 2Ciclos: 12Codificação: 1 1 0 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) «» (direto)Flags:

XCH A,@Ri

Função: Troca RAM indireta com ACCBytes: 1Ciclos: 12Codificação: 1 1 0 0:0 1 1 iOperação: (A) «» ((Ri))Flags:

SWAP

SWAP AFunção: Troca os nibbles no acumuladorDescrição: SWAP A permuta os nibbles(campos de quatro bits) de alta e baixa ordem do acumulador (bits 3-0 e bits

7-4). Essa operação também pode ser entendida como uma instrução de rotação de quatro bits.Nenhuma flag é afetada.

Exemplo: O acumulador contém o valor 0C5H (11000101B). A instrução, SWAP A deixa o acumulador com o valor 5CH (01011100B).

Bytes: 1Ciclos: 12Codificação: 1 1 0 0:0 1 0 0Operação: (A3-0) «» (A7-4)Flags: Nenhuma

SUBB

SUBB A,<src-byte>Função: Subtração com empréstimoDescrição: SUBB subtrai a variável indicada e a flag de carry do acumulador, deixando o resultado no acumulador.

SUBB seta a flag de carry (emprestado) se for necessário tomar emprestado para o bit 7, e limpa C caso contrário (se C estava setado antes da execução da instrução SUBB, isso indica que foi necessário tomar emprestado na etapa anterior de uma subtração de múltipla precisão, assim o carry é subtraído do acumulador juntamente com o operando fonte). AC é setada se for necessário tomar emprestado para o bit 3, e limpada caso contrário. OV é setada se for necessário tomar emprestado para o bit 6 mas não para o bit 7, ou para o bit 7 mas não para o bit 6 ; caso contrário OV é limpada. Em subtrações de inteiros com sinal, OV indica um número negativo produzido quando um número negativo é subtraído de um número positivo, ou um resultado positivo quando um número positivo é subtraído de um número negativo. São permitidos quatro modos de endereçamento do operando fonte: registrador, direto, registrador-indireto, ou imediato.

Exemplo: O acumulador contém 0C9H (11001001B), o registrador contém 54H (01010100B), e a flag de carry está setada. A instrução, SUBB A, R2 deixa o valor 74H (01110100B) no acumulador, com a flag de carry e AC limpadas mas OV setada. Note que 0C9H menos 54H é 75H. A diferença entre os resultados se deve ao fato de que o carry(emprestado) estava setado antes da operação. Se o estado do carry é desconhecido antes de uma subtração simples ou de múltipla precisão, ele não deve então ser limpado explicitamente por uma instrução CLR C.

SUBB A,Rn

Função: Subtrai registrador do ACC com empréstimoBytes: 1Ciclos: 12Codificação: 1 0 0 1:1 r r rOperação: (A) « (A) - (C) - (Rn)Flags: C AC OV

SUBB A,direct

Função: Subtrai byte direto do ACC com empréstimoBytes: 2Ciclos: 12Codificação: 1 0 0 1:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (A) - (C) - (direto)Flags: C AC OV

SUBB A,@Ri

Função: Subtrai RAM indireta do ACC com empréstimoBytes: 1Ciclos: 12Codificação: 1 0 0 1:0 1 1 iOperação: (A) « (A) - (C) - ((Ri))Flags: C AC OV

SUBB A,#data

Função: Subtrai dado imediato do ACC com empréstimoBytes: 2Ciclos: 12Codificação: 1 0 0 1:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0

Operação: (A) « (A) - (C) - #dadoFlags: C AC OV

SJMP

SJMP rel8Função: Desvio curtoDescrição: SJMP causa um desvio incondicional para o endereço indicado. O endereço de destino é calculado a

partir da adição do deslocamento relativo com sinal no segundo byte de instrução com o PC, após o incremento do PC em duas unidades. Consequentemente, a região de endereçamento permitida é de 128 bytes antes desta instrução e 127 bytes após a mesma.

Exemplo: O indicador "RELADR" é atribuído à instrução no endereço 0123H da memória de programa. A instrução, SJMP RELADR está localizada no endereço 0100H. Após a execução da instrução, o PC conterá o valor 0123H. Nota: Nas condições apresentadas acima a instrução seguinte a SJMP está localizada no endereço 0102H. Consequentemente, o deslocamento relativo da instrução é dado pela diferença (0123H - 0102H) = 21H. Em outras palavras, uma instrução SJMP com um deslocamento de 0FEH causaria um laço infinito de apenas uma instrução.

Bytes: 2Ciclos: 24Codificação: 1 0 0 0:0 0 0 0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

(PC) « (PC) + relFlags:

SETB

SETB <bit>Função: Seta bitDescrição: SETB seta o bit indicado para o valor um. SETB pode operar na flag de carry ou em qualquer bit

diretamente endereçável. Nenhuma outra flag é afetada.Exemplo: A flag de carry está limpa. A porta de saída P1 foi carregada com o valor 34h(00110100B).

As instruções,SETB C SETB P1.0 setam a flag de carry para o valor 1 e alteram os dados na porta P1 para 35H (00110101B).

SETB C

Função: Seta a flag de carryBytes: 1Ciclos: 12Codificação: 1 1 0 1:0 0 1 1Operação: (C) « 1Flags: C

SETB <bit>

Função: Seta variável bitBytes: 2Ciclos: 12Codificação: 1 1 0 1:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (bit) « 1Flags:

RRC

RRC AFunção: Rotaciona o acumulador à direita pela flag de carryDescrição: Os oito bits do acumulador e a flag de carry são rotacionados juntos um bit à direita. O bit 0 se move para

a flag de carry; O valor original da flag de carry se move para a posição do bit 7. Nenhuma outra flag é afetada.

Exemplo: O acumulador contém o valor 0C5h (11000101B), e o carry é zero. A instrução, RRC A deixa o acumulador com o valor 62 (01100010B) e a flag de carry setada.

Bytes: 1Ciclos: 12Codificação: 0 0 0 1:0 0 1 1Operação: (An) « (An + 1) n = 0-6

(A7) « (C) (C) « (A0)

Flags: C

RR

RR AFunção: Rotaciona o acumulador à direitaDescrição: Os oito bits do acumulador são rotacionados um bit à direita. O bit 0 é rotacionado para a posição do bit

7. Nenhuma flag é afetada. Exemplo: O acumulador contém o valor 0C5H (11000101B). A instrução,

RR A deixa o acumulador com o valor 0E2H (11100010B) sem alterar o carry.

Bytes: 1Ciclos: 12Codificação: 0 0 0 0:0 0 1 1Operação: (An) « (An + 1) n = 0-6

(A7) « (A0)Flags: Nenhuma

RLC

RLC AFunção: Rotaciona o acumulador à esquerda pela flag de carryDescrição: Os oito bits do acumulador e a flag de carry são rotacionados juntos um bit à esquerda. O bit 7 se move

para a flag de carry; O valor original da flag de carry se move para a posição do bit 0. Nenhuma outra flag é afetada.

Exemplo: O acumulador contém o valor 0C5h (11000101B), e o carry é zero. A instrução, RCL A deixa o acumulador com o valor 8AH (10001010B) e a flag de carry setada.

Bytes: 1Ciclos: 12Codificação: 0 0 1 1:0 0 1 1Operação: (An + 1) « (An) n = 0-6

(A0) « (C) (C) « (A7)

Flags: C

RL

RL AFunção: Rotaciona o acumulador à esquerdaDescrição: Os oito bits do acumulador são rotacionados um bit à esquerda. O bit 7 é rotacionado para a posição do

bit 0. Nenhuma flag é afetada. Exemplo: O acumulador contém o valor 0C5H (11000101B). A instrução,

RL A deixa o acumulador com o valor 8BH (10001011B) sem alterar o carry.

Bytes: 1Ciclos: 12Codificação: 0 0 1 0:0 0 1 1Operação: (An + 1) « (An) n = 0-6

(A0) « (A7)Flags: Nenhuma

RETI

RETIFunção: Retorno de interrupçãoDescrição: RETI retira da pilha, sucessivamente, os bytes de alta e baixa ordem do PC e restaura a lógica de

interrupções para aceitar interrupções adicionais do mesmo nível dee prioridade que aquela recém processada. O Stack Pointer é decrementado em duas unidades. Nenhum outro registrador é afetado; o PSw não é automaticamente restaurado ao seu estado pré-interrupção. A execução do programa continua no endereço resultante, o qual está geralmente na instrução imediatamente após o ponto onde o pedido de interrupção foi detectado. Se uma interrupção de nível menor ou igual estava pendente quando a instrução RETI é executada, aquela instrução é executada antes que a interrupção pendente seja processada.

Exemplo: O Stack Pointer contém inicialmente o valor 0BH. Uma interrupção foi detectada durante a instrução que termina no endereço 0122H. As posições internas da RAM 0AH e 0BH contêm os valores 23H e 01H, respectivamente. A instrução,RETI deixa o Stack Pointer igual a 09H e retorna a execução do programa para o endereço 0123H.

Bytes: 1Ciclos: 24Codificação: 0 0 1 1:0 0 1 0Operação: (PC15-8) « ((SP))

(SP) « (SP) - 1 (PC7-0) « ((SP)) (SP) « (SP) - 1

Flags: Nenhuma

RET

RETFunção: Retorno de subrotinaDescrição: RET retira da pilha, sucessivamente, os bytes de alta e baixa ordem do PC, decrementando o Stack

Pointer em duas unidades. A execução do programa continua no endereço resultante, geralmente na instrução seguinte a um ACALL ou um LCALL. Nenhuma flag é afetada.

Exemplo: O Stack Pointer contém inicialmente o valor 0BH. As posições internas da RAM 0AH e 0BH contêm os valores 23H e 01H, respectivamente. A instrução,RET deixa o Stack Pointer com o valor 09H. A execução do programa continua no endereço 0123H.

Bytes: 1Ciclos: 24Codificação: 0 0 1 0:0 0 1 0Operação: (PC15-8) « ((SP))

(SP) « (SP) - 1 (PC7-0) « ((SP)) (SP) « (SP) - 1

Flags: Nenhuma

PUSH

PUSH directFunção: Coloca na pilhaDescrição: O Stack Pointer é incrementado em uma unidade.

O conteúdo da variável indicada é então copiado para a posição interna da RAM endereçada pelo Stack Pointer. Nenhuma flag é afetada.

Exemplo: Ao entrar na rotina de interrupção o Stack Pointer contém o valor 09H. O Data Pointer contém o valor 0123H. A sequencia de instruções, PUSH DPL PUSH DPH deixa o Stack Pointer com 0BH e armazena os valores 23H e 01H nas posições 0AH e 0BH da RAM, respectivamente.

Bytes: 2Ciclos: 24Codificação: 1 1 0 0:0 0 0 0 a7 a6 a5 a4:a3 a2 a1 a0Operação: (SP) « (SP) + 1

((SP)) « (direto)Flags: Nenhuma

POP

POP directFunção: Retira da pilhaDescrição: O conteúdo da posição interna da RAM endereçada pelo Stack Pointer é lido, e o Stack Pointer é

decrementado em uma unidade. O valor lido é então transferido para o byte diretamente endereçável indicado. Nenhuma flag é afetada.

Exemplo: O Stack Pointer contém inicialmente o valor 32H, e as posições de 30H a 32H da RAM contêm os valores 20H, 23H, e 01H, respectivamente. A sequencia de instruções, POP DPH POP DPL deixa o Stack Pointer com o valor 30H e o Data Pointer com 0123H. Nesse ponto a instrução, POP SP deixa o Stack Pointer com o valor 20H. Note que nesse caso especial o Stack Pointer foi decrementado para 2FH antes de ser carregado com o valor retirado da pilha (20H).

Bytes: 2Ciclos: 24Codificação: 1 1 0 1:0 0 0 0 a7 a6 a5 a4:a3 a2 a1 a0Operação: (direto) « ((SP))

(SP) « (SP) -1Flags: Nenhuma

ORL

ORL <dest-byte>,<src-byte>Função: OR lógica para variáveis do tipo byteDescrição: ORL realiza a operação OR lógica bit-a-bit entre as variáveis indicadas e armazena o resultado na

variável de destino. Nenhuma flag é afetada. Os dois operandos permitem seis combinações de endereçamento. Quando o destino é o acumulador, a fonte pode usar endereçamento por registrador, direto, registrador-indireto, ou imediato; quando o destino é um endereço direto, a fonte pode ser o Acumulador ou dadoimediato. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: Se o acumulador contém 0C3H (11000011B) e o registrador 0 contém 55H (01010101B) então a instrução, ORL A, R0 deixará 0D7H (11010111B) no acumulador. Quando o destino é um byte endereçado diretamente, esta instrução limpará combinações de bits de qualquer posição da RAM ou registrador do hardware. O byte máscara que determina o padrão de bits a serem limpados pode ser tanto uma constante contida na instrução como um valor calculado no acumulador durante a execução. A instrução, ORL P1, #00110010b limpará os bits 5, 4, e 1 da porta de saída P1.

ORL A,Rn

Função: OR lógica com registrador para ACCBytes: 1Ciclos: 12Codificação: 0 1 0 0:1 r r rOperação: (A) « (A) v (Rn)Flags:

ORL A,direct

Função: OR lógica com byte direto para ACCBytes: 2Ciclos: 12Codificação: 0 1 0 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (A) v (direto)Flags:

ORL A,@Ri

Função: OR lógica com RAM indireta para ACCBytes: 1Ciclos: 12Codificação: 0 1 0 0:0 1 1 iOperação: (A) « (A) v ((Ri))Flags:

ORL A,#data

Função: OR lógica com dado imediato para ACCBytes: 2Ciclos: 12Codificação: 0 1 0 0:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (A) « (A) v #dadoFlags:

ORL direct,A

Função: OR lógica com ACC para byte diretoBytes: 2Ciclos: 12Codificação: 0 1 0 0:0 0 1 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « (direto) v ACCFlags:

ORL direct,#data

Função: OR lógica com dado imediato para byte diretoBytes: 3Ciclos: 24Codificação: 0 1 0 0:0 0 1 1 a7 a6 a5 a4:a3 a2 a1 a0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « (direto) v #dadoFlags:

ORL C,<src-bit>Função: OR lógica para variáveis do tipo bitDescrição: Seta a flag de carry se o valor booleano do bit fonte é um 1 lógico; caso contrário, esta instrução deixa a

flag de carry no seu estado atual. Uma barra ("/") precedendo o operando no assembly indica que o complemento lógico do bit endereçado é usado como valor de origem, mas o próprio bit de origem não é afetado. Nenhuma outra flag é afetada.

Exemplo: Seta a flag de carry se, P1.0 = 1, ACC.7 = 1, ou OV = 0 MOV C, P1.0 ; CARREGA CARRY COM ESTADO DO PINO DE ENTRADA ORL C, ACC.7 ; OR DA CARRY COM BIT 7 DO ACC ORL C,/OV ; OR DA CARRY COM INVERSO DA FLAG DE OVERFLOW

ORL C,bit

Função: OR lógica com bit para carryBytes: 2Ciclos: 24Codificação: 0 1 1 1:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (C) « (C) v (bit)Flags: C

ORL C,/bit

Função: OR lógica com complemento do bit para carryBytes: 2Ciclos: 24Codificação: 1 0 1 0:0 0 0 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (C) « (C) v (bit)Flags: C

NOP

NOPFunção: Nenhuma OperaçãoDescrição: A execução continua na instrução seguinte. Além do PC, nenhum registrador ou flag é afetada.Exemplo: Deseja-se produzir um pulso de saída no bit 7 da porta P2 durando exatamente 5 ciclos.

Uma sequência simples SETB/CLR geraria um pulso de um ciclo, logo, quatro ciclos adicionais devem ser inseridos. Isto pode ser feito (assumindo que nenhuma interrupção está habilitada) com a sequência de instruções, CLR P2.7 NOP NOP NOP NOP SETB P2.7

Bytes: 1Ciclos: 12Codificação: 0 0 0 0:0 0 0 0Operação: (PC) « (PC) + 1Flags: Nenhuma

MUL

MUL ABFunção: MultiplicaçãoDescrição: MUL AB multiplica os inteiros de oito bits sem sinal do acumulador e do registrador B.

O byte de menor ordem do produto de dezesseis bits é deixado no acumulador, e o byte de maior ordem em B. Se o produto for maior do que 255 (OFFH) a flag de overflow é setada; caso contrário ela é limpada. A flag de carry é sempre limpada.

Exemplo: O acumulador contém o valor 80 (50H). O registrador contém o valor 160 (OAOH). A instrução, MUL AB resultará no produto 12,800 (3200H), assim, B é alterado para 32H (00110010B) e o acumulador é limpado. A flag de overflow é setada, a carry é limpada.

Bytes: 1Ciclos: 48Codificação: 1 0 1 0:0 1 0 0Operação: (PC) « (PC) + 1Flags: OV C

MOVX

MOVX A,@A+<base-reg>Função: Move byte externoDescrição: As instruções MOVX transferem dados entre o acumulador e um byte de uma memória de dados

externa, daí o "X" adicionado ao MOV. Há dois tipos de instruções, diferindo em se elas fornecem um endereço indireto de oito ou dezesseis bits para a RAM de dados externa. No primeiro tipo, o conteúdo de R0 ou R1 do banco de registradores atual fornece um endereço de oito bits multiplexado com os dados em P0. Oito bits são suficientes para decodificação na expansão de I/O externa ou para um vetor da RAM relativamente pequeno. Para vetores um tanto grandes, qualquer pino de uma porta pode ser usado para acessar bits com endereços de maior ordem. Estes pinos seriam controlados por uma instrução de acesso a saída precedindo MOVX. No segundo tipo da instrução MOVX, o data pointer gera um endereço de dezesseis bits. A porta P2 envia os oito bits de endereço de maior ordem (o conteúdo de DPH) enquanto a porta P0 multiplexa os oito bits de menor ordem (DPL) com os dados. O registrador de funções especiais P2 retem seu conteúdo prévio enquanto o buffer de saída de P2 emite o conteúdo de DPH. Este modo é mais rápido e mais eficiente no acesso de vetores de dados muito grandes (até 64K bytes), uma vez que nenhuma instrução adicional é necessária para configurar as portas de saída. Em algumas situações é possível misturar os dois tipos de MOVX. Um vetor grande da RAM com suas linhas de endereço de maior ordem direcionadas por P2 pode ser endereçado pelo data pointer, ou com código para enviar os bits de maior ordem do para P2 seguido por uma instrução MOVX usando R0 ou R1.

Exemplo: Uma RAM externa de 256 bytes usando linhas de endereço/dados multiplexada está conectada à porta P0 do 80C51. A porta P3 fornece linhas de controle para a RAM externa. As portas P0 e P2 são usadas para operações comuns de I/O. Os registradores 0 e 1 contém 12H e 34H. A posição 34H da RAM externa contém o valor 56H. A sequência de instruções, MOVX A, @R1 MOVX @R0, A copia o valor 56H para ambos o acumulador e a posição 12H da RAM externa.

MOVX A,@Ri

Função: Move byte externo em registrador para ACCBytes: 1Ciclos: 24Codificação: 1 1 1 0:0 0 1 iOperação: (A) « ((Ri))Flags: Nenhuma

MOVX A,@DPTR

Função: Move byte externo em DPTR para ACCBytes: 1Ciclos: 24Codificação: 1 0 0 0:0 0 1 1Operação: (A) « ((DPTR))Flags: Nenhuma

MOVC

MOVC A,@A+<base-reg>Função: Move byte códigoDescrição: As instruções MOVC carregam o acumulador com um byte código, ou uma constante da memória de

programa. O endereço do byte acessado é a soma do conteúdo original de 8 bits do acumulador e do conteúdo de um registrador base de 16 bits, o qual pode ser o data pointer ou o PC. No último caso, o PC é incrementado para o endereço da instrução seguinte antes de ser adicionado ao acumulador; caso contrário o registrador base não é alterado. Uma adição de dezesseis bits é realizada então um transporte dos bits de menor ordem pode se propagar para os bits de maior ordem. Nenhuma flag é afetada.

Exemplo: O acumulador contém um valor entre 0 e 3. As seguintes instruções irão alterar o valor do acumulador para um dos quatro valores definidos pela diretiva DB (define byte). REL_PC: INC A

MOVC A, @A + PC

RET

DB 66H

DB 77H

DB 88H

DB 99H

Se a subrotina for chamada com o acumulador igual a 01H, o programa retornará com 77H no acumulador. A instrução INC A antes de MOVC é necessária para "esquivar-se" da intrução RET acima da tabela. Se vários bytes de código separassem a instrução MOVC da tabela, o número correspondente seria adicionado ao acumulador.

MOVC A,@A+DPTR

Função: Move byte código em ACC + DPTR para ACCBytes: 1Ciclos: 24Codificação: 1 0 0 1:0 0 1 1Operação: (A) « ((A) + (DPTR))Flags: Nenhuma

MOVC A,@A+PC

Função: Move byte código em ACC + PC para ACCBytes: 1Ciclos: 24Codificação: 1 0 0 0:0 0 1 1Operação: (PC) « (PC) + 1

(A) « ((A) + (PC))Flags: Nenhuma

MOV

MOV <dest>,<source>Função: Move variável byteDescrição: A variável indicada pelo segundo operando é copiada para o local especificado pelo primeiro operando.

O byte fonte não é afetado. Nenhum outro registrador ou flag é afetado.Está é de longe a operação mais flexível. São possíveis quinze combinações de modos de endereçamento de origem e destino: MOV A,Rn MOV A,direto MOV A,@Ri MOV A,#dado MOV Rn,A MOV Rn,direto MOV Rn,#dado MOV direct,A MOV direto,Rn MOV direto,direto MOV direto,@Ri MOV direto,#dado MOV @Ri,A MOV @Ri,direto MOV @Ri,#dadoNota: Mov A,ACC não é uma instrução válida.

Exemplo: O endereço interno da RAM 30H contém 40H. O valor do endereço 40H da RAM é 10H. O dado presente na porta de entrada P1 é 11001010B (0CAH). MOV R0, #30H ; R0 <= 30h MOV A, @R0 ; A <= 40H MOV R1, A ; R1 <= 40h MOV R, @R1 ; B <= 10h MOV @R1, P1 ; RAM (40H) <= OCAH MOV P2, P1 ; P2 # 0CAH deixa o valor 30H no registrador 0, 40H em ambos acumulador e registrador 1, 10H no registrador B, e 0CAH (11001010B) em ambos endereço 40H da RAM e porta de saída P2.

MOV A,Rn

Função: Move registador para ACCBytes: 1Ciclos: 12Codificação: 1 1 1 0:1 r r rOperação: (A) « (Rn)Flags:

MOV A,direct

Função: Move byte direto para ACCBytes: 2Ciclos: 12Codificação: 1 1 1 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (direto)Flags:

MOV A,@Ri

Função: Move RAM indireta para ACCBytes: 1Ciclos: 12Codificação: 1 1 1 0:0 1 1 iOperação: (A) « ((Ri))Flags:

MOV A,#data

Função: Move dado imediato para ACCBytes: 2Ciclos: 12Codificação: 0 1 1 1:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (A) « #dado

Flags:

MOV Rn,A

Função: Move ACC para registradorBytes: 1Ciclos: 12Codificação: 1 1 1 1:1 r r rOperação: (Rn) « (A)Flags:

MOV Rn,direct

Função: Move byte direto para registradorBytes: 2Ciclos: 24Codificação: 1 0 1 0:1 r r r a7 a6 a5 a4:a3 a2 a1 a0Operação: (Rn) « (direto)Flags:

MOV Rn,#data

Função: Move dado imediato para registradorBytes: 2Ciclos: 12Codificação: 0 1 1 1:1 r r r d7 d6 d5 d4:d3 d2 d1 d0Operação: (Rn) « #dadoFlags:

MOV direct,A

Função: Move ACC para byte diretoBytes: 2Ciclos: 12Codificação: 1 1 1 1:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (direto) « (A)Flags:

MOV direct,Rn

Função: Move registrador para byte diretoBytes: 2Ciclos: 24Codificação: 1 0 0 0:1 r r r a7 a6 a5 a4:a3 a2 a1 a0Operação: (direto) « (Rn)Flags:

MOV direct,direct

Função: Move byte direto para byte diretoBytes: 3Ciclos: 24Codificação: 1 0 0 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0(src) a7 a6 a5 a4:a3 a2 a1 a0(dest)Operação: (direto) « (direto)Flags:

MOV direct,@Ri

Função: Move RAM indireta para byte diretoBytes: 2Ciclos: 24Codificação: 1 0 0 0:0 1 1 i a7 a6 a5 a4:a3 a2 a1 a0Operação: (direto) « ((Ri))

Flags:

MOV direct,#data

Função: Move dado imediato para byte diretoBytes: 3Ciclos: 24Codificação: 1 0 0 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « #dadoFlags:

MOV @Ri,A

Função: Move ACC para RAM indiretaBytes: 1Ciclos: 12Codificação: 1 1 1 1:0 1 1 iOperação: ((Ri)) « (A)Flags:

MOV @Ri,direct

Função: Move byte direto para RAM indiretaBytes: 2Ciclos: 24Codificação: 1 0 1 0:0 1 1 i a7 a6 a5 a4:a3 a2 a1 a0Operação: ((Ri)) « (direto)Flags:

MOV @Ri,#data

Função: Move dado imediato para RAM indiretaBytes: 2Ciclos: 12Codificação: 0 1 1 1:0 1 1 i d7 d6 d5 d4:d3 d2 d1 d0Operação: ((Ri)) « #dadoFlags:

MOV <dest-bit>,<source-bit>Função: Move bitDescrição: A variável booleana indicada pelo segundo operando é copiada para o local especificado pelo primeiro

operando. Um dos operandos deve ser a flag de carry; o outro pode ser qualquer bit diretamente endereçável. Nenhum outro registrador ou flag é afetado.

Exemplo: A flag de carry está originalmente setada. O dado presente na porta de entrada P3 é 11000101B. O dado previamente enviado para a porta de saída P1 é 35H (00110101B). MOV P1.3, C MOV C, P3.3 MOV P1.2, C deixará a carry limpa e mudará a porta P1 para 39H (00111001B).

MOV C,bit

Função: Move bit para carryBytes: 2Ciclos: 12Codificação: 1 0 1 0:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (C) « (bit)Flags:

MOV A,direct

Função: Move carry para bitBytes: 2Ciclos: 24Codificação: 1 0 0 1:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (bit) « (C)Flags:

MOV DPTR,#data16Função: Carrega o data pointer com uma constante de 16 bitsDescrição: O data pointer é carregado com a constante de 16 bits indicada.

A constante de 16 bits é carregada para o segundo e terceiro bytes da instrução. O segundo byte (DPH) é o byte de maior ordem, enquanto o terceiro byte (DPL) contém o byte de menor ordem. Nenhuma flag é afetada. Esta é a única instrução que move dados de 16 bits de uma vez.

Exemplo: A instrução, MOV DPTR, 1234H carregará o valor 1234H para o data pointer: DPH conterá 12H e DPL conterá 34H.

Bytes: 3Ciclos: 24Codificação: 1 0 0 1:0 0 0 0 d15 d14 d13 d12:d11 d10 d9 d8 d7 d6 d5 d4:d3 d2 d1 d0Operação: (DPH) « #dado15-8

(DPL) « #dado7-0Flags: Nenhuma

LJMP

LJMP addr16Função: Desvio longoDescrição: LJMP causa um desvio incondicional para o endereço indicado, através do carregamento dos bytes de

maior e menor ordem do PC (respectivamente) com o segundo e o terceiro byte da instrução. Consequentemente, o destino pode estar em qualquer lugar nos 64K bytes da memória de programa. Nenhuma flag é afetada

Exemplo: O indicador "JMPADR" é atribuído à instrução no endereço 1234H da memória de programa. A instrução, LJMP JMPADR no endereço 0123H carregará o PC com 1234H.

Bytes: 3Ciclos: 24Codificação: 0 0 0 0:0 0 1 0 a15 a14 a13 a12:a11 a10 a9 a8 a7 a6 a5 a4:a3 a2 a1 a0Operação: (PC) « addr15-0Flags: Nenhuma

LCALL

LCALL addr16Função: Chamada longaDescrição: LCALL chama uma subrotina localizada no endereço indicado.

A instrução incrementa o PC três vezes para obter o endereço da próxima instrução, então coloca esse endereço de 16 bits na pilha(byte de mais baixa ordem primeiro) e incrementa o Stack Pointer duas vezes. Os bytes de maior e menor ordem do PC são carregados, respectivamente, com o segundo e o terceiro byte da instrução LCALL. A execução do programa continua nesse endereço. Consequentemente, a subrotina pode começar em qualquer lugar nos 64K bytes da memória de programa. Nenhuma flag é afetada.

Exemplo: Inicialmente o Stack Pointer é igual a 07H. O indicador "SUBRTN" é atribuído ao endereço 1234H da memória de programa. Após a execução da instrução, LCALL SUBRTN no endereço 0123H, o Stack Pointer irá conter 09H, os endereços internos da RAM 08H e 09H irão conter 26H e 01H, e o PC irá conter 1235H.

Bytes: 3Ciclos: 24Codificação: 0 0 0 1:0 0 1 0 a15 a14 a13 a12:a11 a10 a9 a8 a7 a6 a5 a4:a3 a2 a1 a0Operação: (PC) « (PC) + 3

(SP) « (SP) + 1 ((SP)) « (PC7-0) (SP) « (SP) + 1 ((SP)) « (PC15-8) (PC) « addr15-0

Flags: Nenhuma

JZ

JZ rel8Função: Desvia se o acumulador for zeroDescrição: Se todos os bits do acumulador são zero, desvia para o endereço indicado; caso contrário continua com

a próxima instrução. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte.O acumulador não é modificado. Nenhuma flag é afetada.

Exemplo: O acumulador contém originalmente 01H. A sequência de instruções, JZ LABEL1 DEC A JZ LABEL2 modificará o acumulador para 00H e continuará a execução no indicador LABEL2.

Bytes: 2Ciclos: 24Codificação: 0 1 1 1:0 0 0 0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

IF (A) = 0 THEN (PC) « (PC) + rel

Flags: Nenhuma

JNZ

JNZ rel8Função: Desvia se o acumulador não for zero Descrição: Se qualquer bit do acumulador é um ‘1’, desvia para o endereço indicado; caso contrário continua com

a próxima instrução. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte.O acumulador não é modificado. Nenhuma flag é afetada.

Exemplo: O acumulador contém originalmente 00H. A sequência de instruções, JNZ LABEL1 INC A JNZ LABEL2 modificará o acumulador para 01H e continuará a execução no indicador LABEL2.

Bytes: 2Ciclos: 24Codificação: 0 1 1 1:0 0 0 0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

IF (A) <> 0 THEN (PC) « (PC) + rel

Flags: Nenhuma

JNC

JNC rel8Função: Desvia se a flag de carry não estiver setadaDescrição: Se a flag de carry é um ‘0’, desvia para o endereço indicado; caso contrário continua com a próxima

instrução. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte.A flag de carry não é modificada.

Exemplo: A flag de carry está setada. A sequência de instruções, JNC LABEL1 CPL C JNC LABEL2 limpará a carry e e fará com que a execução do programa continue na instrução indentificada pelo indicador LABEL2.

Bytes: 2Ciclos: 24Codificação: 0 1 0 1:0 0 0 0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

IF (C) = 0 THEN (PC) « (PC) + rel

Flags: Nenhuma

JNB

JNB bit,rel8Função: Desvia se bit não estiver setadoDescrição: Se o bit indicado é um ‘0’, desvia para o endereço indicado; caso contrário continua com a próxima

instrução. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte.O bit testado não é modificado. Nenhuma flag é afetada.

Exemplo: O dado presente na porta de entrada P1 é 11001010B. O acumulador contém 56 (01010110B). A sequência de instruções. JNB P1.3, LABEL1 JNB ACC3, LABEL2 causará um desvio na execução do programa para a instrução no indicador LABEL 2.

Bytes: 3Ciclos: 24Codificação: 0 0 1 1:0 0 0 0 b7 b6 b5 b4:b3 b2 b1 b0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF (bit) = 0 THEN (PC) « (PC) + rel

Flags: Nenhuma

JMP

JMP @A+DPTRFunção: Desvio indiretoDescrição: Adiciona o byte sem sinal contido no acumulador ao data pointer de 16 bits, e carrega o PC com o

resultado da soma. Este será o endereço para referência de instruções subsequentes. Uma adição de 16 bits é realizada (modulo 216): um transporte do byte de menor ordem se propaga para o byte de maior ordem. Nem o acumulador nem o data pointer é alterado. Nenhuma flag é afetada.

Exemplo: Um número par de 0 a 6 está no acumulador. A seguinte sequência de instruções desviará para uma das quatro instruções AJMP em uma tabela de jumps a partir do indicador JMP-TBL: MOV DPTR,#JMP_TBL JMP @A + DPTR JMP_TBL: AJMP LABEL0 AJMP LABEL1 AJMP LABEL2 AJMP LABEL3 Se o acumulador é igual a 04H no começo da sequência, a execução será desviada para o indicador LABEL2. Como AJMP é uma instrução de dois bytes, as instruções jump começam em cada um dos outros endereços.

Bytes: 1Ciclos: 24Codificação: 0 1 1 1:0 0 1 1Operação: (PC) « ((A)) + (DPTR)Flags: Nenhuma

JC

JC bit,rel8Função: Desvia se carry estiver setadaDescrição: Se a flag de carry estiver setada, desvia para o endereço indicado; caso contrário continua com a

próxima instrução. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte.O bit testado não é modificado. Nenhuma flag é afetada.

Exemplo: A flag de carry está limpa. A sequência de instruções, JC LABEL1 CPL C JC LABEL2 setará a carry e fará com que a execução do programa continue na instrução indentificada pelo indicador LABEL2.

Bytes: 2Ciclos: 24Codificação: 0 1 0 0:0 0 0 0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

IF (C) = 1 THEN (PC) « (PC) + rel8

Flags: Nenhuma

JBC

JBC bit,rel8Função: Desvia se bit estiver setado e limpa bitDescrição: Se o bit indicado é um ‘1’, desvia para o endereço indicado; caso contrário continua com a próxima

instrução. O bit não será limpado se ele já for zero.O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte. Nenhuma flag é afetada. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: O acumulador contém 56H (01010110B). A sequência de instruções, JBC ACC.3, LABEL 1 JBC ACC.2, LABEL 2 fará com que a execução do programa continue na instrução identificada pelo indicador LABEL2, com o acumulador modificado para 52H (01010010B).

Bytes: 3Ciclos: 24Codificação: 0 0 0 1:0 0 0 0 b7 b6 b5 b4:b3 b2 b1 b0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF (bit) = 1 THEN (bit) « 0 (PC) « (PC) + rel8

Flags: Nenhuma

JB

JB bit,rel8Função: Desvia se bit estiver setadoDescrição: Se o bit indicado é um ‘1’, desvia para o endereço indicado; caso contrário continua com a próxima

instrução. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte.O bit testado não é modificado. Nenhuma flag é afetada. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: O dado presente na porta de entrada P1 é 11001010B. O acumulador contém 56 (01010110B). A sequência de instruções. JB P1.2, LABEL1

JB ACC.2, LABEL2 causará um desvio na execução do programa para a instrução no indicador LABEL 2.

Bytes: 3Ciclos: 24Codificação: 0 0 1 0:0 0 0 0 b7 b6 b5 b4:b3 b2 b1 b0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF (bit) = 1 THEN (PC) « (PC) + rel8

Flags: Nenhuma

INC

INC byteFunção: Incrementa byteDescrição: INC incrementa a variável indicada em uma unidade.

Para um valor inicial de 0FFH ocorrerá um overflow para 00H. Nenhuma flag é afetada. São permitidos quatro modos de endereçamento do operando fonte: acumulador, registrador, direto, ou registrador-indireto. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: O registrador 0 contém 7EH (011111110B). Os endereços internos da RAM 7EH e 7FH contêm 0FFH e 3FH, respectivamente. A sequência de instruções, INC @R0 INC R0 INC @R0 deixará o registrador 0 com 7FH e os endereços internos da RAM 7EH e 7FH com 00H e 41H, repectivamente.

INC A

Função: Incrementa ACC em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 0:0 1 0 0Operação: (A) « (A) + 1Flags:

INC Rn

Função: Incrementa registrador em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 0:1 r r rOperação: (Rn) « (Rn) + 1Flags:

INC direct

Função: Incrementa byte direto em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 0:0 1 0 1Operação: (direto) « (direto) + 1Flags:

INC @Ri

Função: Incrementa RAM indireta em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 0:0 1 1 iOperação: ((Ri)) « ((Ri)) + 1Flags:

INC DPTRFunção: Incrementa Data PointerDescrição: Incrementa o apontador de dados 16-bits em uma unidade. A incremento de 16-bits (modulo 216) é

realizado, e um overflow do byte de maior ordem do data pointer (DPL) de 0FFH para 00H incrementa

o byte de maior ordem (DPH). Nenhuma flag é afetada. Este é o único registrador de 16-bits que pode ser incrementado.

Exemplo: Os registradores DPH e DPL contêm 12H e 0FEH, respectivamente. A sequência de instruções, INC DPTR INC DPTR INC DPTR mudará DPH e DPL para 13H e 01H.

Bytes: 1Ciclos: 24Codificação: 1 0 1 0:0 0 1 1Operação: (DPTR) « (DPTR) + 1Flags: Nenhuma

DJNZ

DJNZ <byte>,rel8Função: Decrementa e desvia se não for zeroDescrição: DJNZ decrementa o operando indicado em uma unidade, e desvia para o endereço indicado pelo segundo

operando se o valor resultante não for zero. Para um valor inicial de 00H ocorrerá um underflow para 0FFH. Nenhuma flag é afetada. O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte. O operando decrementado pode ser um registrador or um byte diretamente endereçado. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: Os endereços internos da RAM 40H, 50H, e 60H contêm os valores 01H, 70H, e 15H, respectivamente. A sequência de instruções, DJNZ 40H, LABEL_1 DJNZ 50H, LABEL_2 DJNZ 60H, LABEL_3 causará um desvio para a instrução no indicador LABEL2 com os valores 00H, 6FH, e 15H nos três endereços da RAM. O primeiro desvio não foi feito porque o resultado foi zero. Esta instrução fornece uma maneira simples de executar um laço em um programa um dado número de vezes, ou de adicionar um atraso de tempo moderado (de 2 a 512 ciclos de máquina) com uma simples instrução. A sequência de instruções, MOV R2, #8 TOGGLE:

CPL P1.7 DJNZ R2, TOGGLE irá chavear P1.7 oito vezes, enviando quatro pulsos de saída para o pino 7 de P1. Cada pulso irá durar três cilcos de máquina; dois para DJNZ e um para alterar o valor do pino.

DJNZ Rn,rel8

Função: Decrementa registrador, desvia se não for zeroBytes: 2Ciclos: 24Codificação: 1 1 0 1:1 r r r r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

(Rn) « (Rn) - 1 IF (RN) > 0 or (Rn) < 0 THEN (PC) « (PC) + rel8

Flags:

DJNZ direct,rel8

Função: Decrementa byte direto, desvia se não for zeroBytes: 3Ciclos: 24Codificação: 1 1 0 1:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 2

(direto) « (direto) - 1 IF (direto) > 0 or (direto) < 0 THEN (PC) « (PC) + rel8

Flags:

DIV

DIV ABFunção: DivisãoDescrição: DIV AB divide o byte inteiro sem sinal no acumulador pelo byte inteiro sem sinal no registrador B.

O acumulador recebe a parte inteira do quociente ; o registrador B recebe o resto. As flags de carry e OV são limpadas. Exceção : Se B continha originalmente o valor 00H; os valores resultantes no acumulador e no registrador B serão indefinidos e a flag de overflow será setada. A flag de carry é limpada em qualquer caso.

Exemplo: O acumulador contém 251 (0FBH ou 11111011B) e B contém 18 (12H ou 00010010B). A instrução, DIV AB deixará 13 no acumulador (0DH ou 00001101B) e o valor 17 (11H ou 00010001B) em B, uma vez que 251 = (13 × 18) + 17. Ambas as flags carry e OV serão limpadas.

Bytes: 1Ciclos: 48Codificação: 1 0 0 0:0 1 0 0Operação: (A)15-8 « (A)/(B)

(B)7-0Flags: OV, C

DEC

DEC byteFunção: Decrementa byteDescrição: A variável indicada é decrementada em uma unidade.

Para um valor inicial de 00H ocorrerá um underflow para 0FFH. Nenhuma flag é afetada. São permitidos quatro modos de endereçamento do operando fonte: acumulador, registrador, direto, ou registrador-indireto. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: O registrador 0 contém 7FH (01111111B). Os endereços internos da RAM 7EH e 7FH contêm 00H e 40H, respectivamente. A sequência de instruções, DEC @R0 DEC R0 DEC @R0 deixará o registrador 0 com 7EH e os endereços internos da RAM 7EH e 7FH com 0FFH e 3FH.

DEC A

Função: Decrementa ACC em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 1:0 1 0 0Operação: (A) « (A) - 1Flags:

DEC Rn

Função: Decrementa registrador em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 1:1 r r rOperação: (Rn) « (Rn) - 1Flags:

DEC directFunção: Decrementa byte direto em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 1:0 1 0 1Operação: (direto) « (direto) - 1Flags:

DEC @RiFunção: Decrementa RAM indireta em uma unidadeBytes: 1Ciclos: 12Codificação: 0 0 0 1:0 1 1 iOperação: ((Ri)) « ((Ri)) - 1Flags:

DAA

DA AFunção: Ajuste decimal do acumulador para adiçãoDescrição: DA A ajusta o valor de oito bits do acumulador resultante da última adição de duas variáveis (cada uma

no formato BCD), produzindo dois dígitos de quatro bits. Qualquer uma das instruções ADD ou ADDC pode ter sido usada para realizar a adição. Se os bits 3-0 do acumulador forem maiores do que nove (xxxx1010-xxxx1111), ou se a flag AC for um, é adicionado seis ao acumulador produzindo o dígito BCD apropriado no nibble inferior. Esta adição interna setaria a flag de carry se um transporte dos bits do nibble inferior se propagasse para todos os bits do nibble superior, mas ela não limparia a flag de carry caso contrário. Se a flag de carry está setada agora, ou se os quatro bits de maior ordem excedem nove agora (1010xxxx -111xxxx), estes bits de maior ordem são incrementados em seis unidades, produzindo o digito BCD apropriado no nibble superior. Novamente, isto setaria a flag de carry se houvesse um transporte dos bits de maior ordem, mas não limparia o carry caso contrário. Assim, a flag de carry indica se a soma das duas variáveis BCD originais é maior do que 100, permitindo múltipla precisão decimal. OV não é afetada. Tudo isso ocorre durante um ciclo de instrução. Essencialmente, esta instrução realiza a conversão decimal atrvés da adição de 00H, 06H, 60H, ou 66H ao acumulador, dependendo dos valores iniciais do acumulador e PSW. Nota : DA A não pode simplesmente converter um número hexadecimal no acumulador para a notação BCD, nem pode DA A ser aplicada a subtração decimal.

Exemplo: O acumulador contém o valor 56H (01010110B) representando os dígitos do número decimal 56 no formato BCD. O registrador 3 contém o valor 67H (01100111B) representando os dígitos do número decimal 67 no formato BCD. A flag de carry é setada. A sequência de instruções, ADDC A, R3 DA A realizará primeiro uma adição binária padrão em complemento-a-dois, resultando no valor 0BEH (10111110), no acumulador. As flags carry e auxiliar de carry serão limpadas. A instrução de ajuste decimal altera então o valor do acumulador para 24H (00100100B) indicando os dígitos do número decimal 24 no formato BCD, os dois dígitos de mais baixa ordem da soma decimal de 56 e 67, e o carry. A flag de carry será setada pela instrução de ajuste decimal, indicando que um overflow decimal ocorreu. O valor real da soma de 56, 67 e 1 é 124. Variáveis BCD podem ser incrementadas ou decrementadas através da adição de 01H ou 99H. Se o acumulador inicialmente contém 30H (representando os dígitos do decimal 30), então a sequência de instruções, ADD A, #99H DA A deixará a carry setada e 29H no acumulador, uma vez que 30 + 99 = 129. O byte de mais baixa ordem da soma pode ser intrerpretado como sendoThe low-order 30 -1 = 29.

Bytes: 1Ciclos: 12Codificação: 1 1 0 1:0 1 0 0Operação: IF [[(A3 – 0 ) > 9] V [(AC) = 1]]

THEN (A3 – 0 ) « (A3 – 0 ) + 6 AND IF [[(A7 – 4 ) > 9] V [(C) = 1]] THEN (A7 – 4 ) « (A7 – 4 ) + 6

Flags: C

CPL

CPL AFunção: Complementa o acumuladorDescrição: Cada bit do acumulador é logicamente complementado (complemento a um).

Os bits que continham um ‘1’ são alterados para ‘0’ e vice-versa. Nenhuma flag é alterada.Exemplo: O acumulador contém 5CH (01011100B). A instrução,

CPL A deixará o acumulador com 0A3H (10100011B).

Bytes: 1Ciclos: 12Codificação: 1 1 1 1:0 1 0 0Operação: (A) « (A)Flags: Nenhuma

CPL bitFunção: Complementa bitDescrição: A variável bit especificada é complementada. Um bit que tinha o valor ‘1’ é alterada para ‘0’ e

vice-versa. Nenhuma outra flag é alterada. CPL pode operar com a flag de carry ou qualquer bit diretamente endereçável. Note: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: A porta 1 foi previamente escrita com 5DH (01011101B). A sequência de instruções, CPL P1.1 CPL P1.2 deixará a porta com 5BH (01011011B).

CPL C

Função: Complementa a flag de carryBytes: 1Ciclos: 12Codificação: 1 0 1 1:0 0 1 1Operação: (C) « (C)Flags: C

CPL bit

Função: Complementa o bit selecionadoBytes: 2Ciclos: 12Codificação: 1 0 1 1:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (bit) « (bit)Flags:

CLR

CLR AFunção: Limpa o ACCDescrição: O acumulador é limpado (todos os bits são zerados). Nenhuma flag é afetada.Exemplo: O acumulador contém 5CH (01011100B).

A instrução, CLR A deixará o acumulador com 00H (00000000B).

Bytes: 1Ciclos: 12Codificação: 1 1 1 1:0 1 0 0Operação: (A) « 0Flags: Nenhuma

CLR bitFunção: Limpa bitDescrição: O bit indicado é limpado (zerado). Nenhuma outra flag é afetada.

CLR pode operar com a flag de carry ou qualquer bit diretamente endereçável.Exemplo: A porta 1 foi previamente escrita com 5DH (01011101B).

A instrução, CLR P1.2 deixará a porta com 59H (01011001B).

CLR C

Função: Limpa a flag de carryBytes: 1Ciclos: 12Codificação: 1 1 0 0:0 0 1 1Operação: (C) « 0Flags: C

CLR bit

Função: Limpa bitBytes: 2Ciclos: 12Codificação: 1 1 0 0:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (bit) « 0Flags:

CJNE

CJNE <dest-byte>,<src-byte>,rel8Função: Compara e desvia se não for igualDescrição: CJNE compara os valores dos dois operandos, e desvia se os valores não forem iguais.

O endereço de destino é calculado a partir da adição do deslocamento relativo com sinal no último byte de instrução com o PC, após o incremento do PC para o início da instrução seguinte. A flag de carry é setada se o valor inteiro sem sinal do <dest-byte> é menor do que o valor inteiro sem sinal do <src-byte>; caso contrário, a flag de carry é limpada. Nenhum dos operandos é afetado. Os dois primeiros operandos permitem quatro combinações de modo de endereçamento: o acumulador pode ser comparado com qualquer byte diretamente endereçável ou dado imediato, e qualquer posição indireta na RAM ou registrador pode ser comparado com uma constante imediata.

Exemplo: O acumulador contém 34H, o registrador 7 contém 56H. A primeira instrução na sequência, CJNE R7, #60H, NOT_EQ

; ... ... ; R7 = 60H

NOT_EQ: JC REQ_LOW ; IF R7 < 60H

; ... ... ; R7 > 60H

seta a flag de carry e desvia para a instrução no indicador NOT_EQ. Esta instrução determina, a partir do teste da flag de carry, se R7 é maior ou menor do que 60H. Se o dado enviado para a porta 1 for também 34H, então a instrução, WAIT : CJNE A, P1, WAIT

limpa a flag de carry e continua com a próxima instrução na sequência, desde que o acumulador não seja igual ao dado lido de P1. (Se algum outro valor fosse enviado para P1, o programa ficaria nesse ponto até que o dado em P1 mudasse para 34H).

CJNE A,direct,rel8

Função: Compara byte direto com ACC, desvia se não for igualBytes: 3Ciclos: 24Codificação: 1 0 1 1:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF (A) <> (direto) THEN (PC) « (PC) + deslocamento relativoIF (A) < (direto) THEN (C) « 1 ELSE (C) « 0

Flags: C

CJNE A,#data,rel8

Função: Compara dado imediato com ACC, desvia se não for igualBytes: 3Ciclos: 24Codificação: 1 0 1 1:0 1 0 0 a7 a6 a5 a4:a3 a2 a1 a0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF (A) <> dado THEN (PC) « (PC) + deslocamento relativo IF (A) < dato THEN (C) « 1 ELSE (C) « 0

Flags: C

CJNE Rn,#data,rel8

Função: Compara dado imediato com registrador, desvia se não for igualBytes: 3Ciclos: 24Codificação: 1 0 1 1:1 r r r a7 a6 a5 a4:a3 a2 a1 a0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF (Rn) <> dado THEN (PC) « (PC) + deslocamento relativo IF (Rn) < dado THEN (C) « 1 ELSE (C) « 0

Flags: C

CJNE @Ri,#data,rel8

Função: Compara dado imediato com RAM indireta, desvia se não for igualBytes: 3Ciclos: 24Codificação: 1 0 1 1:0 1 1 i a7 a6 a5 a4:a3 a2 a1 a0 r7 r6 r5 r4:r3 r2 r1 r0Operação: (PC) « (PC) + 3

IF ((Ri)) <> data THEN (PC) « (PC) + relative offset IF ((Ri)) < data THEN (C) « 1 ELSE (C) « 0

Flags: C

ANL

ANL <dest-byte>,<src-byte>Função: AND lógica para variáveis byteDescrição: ANL realiza a operação AND lógica bit-a-bit entre as variáveis indicadas e armazena o resultado na

variável de destino. Nenhuma flag é afetada. Os dois operandos permitem seis combinações de endereçamento. Quando o destino é o acumulador, a fonte pode usar endereçamento por registrador, direto, registrador-indireto, ou imediato; quando o destino é um endereço direto, a fonte pode ser o Acumulador ou dadoimediato. Nota: Quando esta instrução é usada para modificar uma porta de saída, o valor usado como dado original da porta será lido do latch de dados de saída, e não dos pinos de entrada.

Exemplo: Se o acumulador contém 0C3H (11000011B) e o registrador 0 contém 55H (01010101B) então a instrução, ANL A, R0

deixará 41H (01000001B) no acumulador. Quando o destino é um byte endereçado diretamente, esta instrução limpará combinações de bits de qualquer posição da RAM ou registrador do hardware. O byte máscara que determina o padrão de bits a serem limpados pode ser tanto uma constante contida na instrução como um valor calculado no acumulador durante a execução. A instrução, ANL P1, #01110011B

limpará os bits 7, 3, e 2 da porta de saída P1.

ANL A,Rn

Função: AND lógica com registrador para ACCBytes: 1Ciclos: 12Codificação: 0 1 0 1:1 r r rOperação: (A) « (A) ^ (Rn)Flags:

ANL A,direct

Função: AND lógica com byte direto para ACCBytes: 2Ciclos: 12Codificação: 0 1 0 1:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (A) ^ (direto)Flags:

ANL A,@Ri

Função: AND lógica com RAM indireta para ACCBytes: 1Ciclos: 12Codificação: 0 1 0 1:0 1 1 iOperação: (A) « (A) ^ ((Ri))Flags:

ANL A,#data

Função: AND lógica com dado imediato para ACCBytes: 2Ciclos: 12Codificação: 0 1 0 1:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (A) « (A) ^ #dadoFlags:

ANL direct,A

Função: AND lógica com ACC para byte diretoBytes: 2Ciclos: 12Codificação: 0 1 0 1:0 0 1 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « (direto) ^ ACCFlags:

ANL direct,#data

Função: AND lógica com dado imediato para byte diretoBytes: 3Ciclos: 24Codificação: 0 1 0 1:0 0 1 1 a7 a6 a5 a4:a3 a2 a1 a0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (direto) « (direto) ^ #dadoFlags:

ANL C,<src-bit>Função: AND lógica para variáveis bitDescrição: Se o valor booleano do bit fonte é um 0 lógico, então ANL C limpa a flag de carry; caso contrário, esta

instrução deixa a flag de carry no seu estado atual. Uma barra ("/") precedendo o operando no assembly indica que o complemento lógico do bit endereçado é usado como valor de origem, mas o próprio bit de origem não é afetado. Nenhuma outra flag é afetada. Somente o endereçamento direto é permitido para o operando de origem.

Exemplo: Seta a flag de carry se, P1.0 = 1, ACC.7 = 1, e OV = 0 MOV C, P1.0 ; CARREGA CARRY COM ESTADO DO PINO DE ENTRADA ANL C, ACC.7 ; E CARRY COM BIT 7 DO ACC ANL C,/OV ; E COM INVERSO DA FLAG DE OVERFLOW

ANL C,bit

Função: AND lógica de bit com carryBytes: 2Ciclos: 24Codificação: 1 0 0 0:0 0 1 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (C) « (C) ^ (bit)Flags: C

ANL C,/bit

Função: AND lógica de complemento do bit com carryBytes: 2Ciclos: 24Codificação: 1 0 1 1:0 0 0 0 b7 b6 b5 b4:b3 b2 b1 b0Operação: (C) « (C) ^ (bit)Flags: C

AJMP

AJMP address11Função: Desvio absoluto para endereçoDescrição: AJMP desvia a execução do programa para o endereço indicado, o qual é formado em tempo de

execução a partir da concatenação dos cinco bits de maior ordem do PC (após o PC ser incrementado em duas unidades), dos bits 7-5 do opcode, e do segundo byte da instrução. Consequentemente, o endereço de destino deve estar dentro do mesmo bloco de 2K da memória de programa tendo como primeiro byte a instrução seguinte a AJMP.

Exemplo: O indicador "JMPADR" “ está no endereço da memória 0123H. A instrução, AJMP JMPADR

está no endereço 0345H e carregará o PC com 0123H.Bytes: 2Ciclos: 24Codificação: a10 a9 a8 0:0 0 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (PC) « (PC) + 2

(PC10-0) « página de endereçoFlags: Nenhuma

ADDC

ADDC A,<src-byte>Função: Adição com CarryDescrição: ADDC adiciona simultaneamente a variável indicada, a flag de carry e o conteúdo do acumulador,

deixando o resultado no acumulador. As flags de carry e auxiliar de carry são setadas, respectivamente, se houver transporte do bit 7 ou do bit 3, e limpadas caso contrário. Em adições de inteiros sem sinal, a flag de carry indica que ocorreu um overflow. OV é setada se houver transporte do bit 6 mas não do bit 7, ou transporte do bit 7 mas não do bit 6 ; caso contrário OV é limpada. Em adições de inteiros com sinal, OV indica um número negativo produzido com a soma de dois operandos positivos, ou uma soma positiva de dois operandos negativos. São permitidos quatro modos de endereçamento do operando fonte: registrador, direto, registrador-indireto, ou imediato.

Exemplo: O acumulador contém 0C3H (11000011B) e o registrador 0 contém 0AAH (10101010B) com a flag de carry setada. A instrução, ADDC A, R0 deixará 6EH (01101110B) no acumulador com AC limpa e ambas carry e OV setadas.

ADDC A,Rn

Função: Adiciona registrador ao ACC com CarryBytes: 1Ciclos: 12Codificação: 0 0 1 1:1 r r rOperação: (A) « (A) + (C) + (Rn)Flags: C AC OV

ADDC A,direct

Função: Adiciona byte direto ao ACC com CarryBytes: 2Ciclos: 12Codificação: 0 0 1 1:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (A) + (C) + (direto)Flags: C AC OV

ADDC A,@Ri

Função: Adiciona RAM indireta ao ACC com CarryBytes: 1Ciclos: 12Codificação: 0 0 1 1:0 1 1 iOperação: (A) « (A) + (C) + ((Ri))Flags: C AC OV

ADDC A,#data

Função: Adiciona dado imediato ao ACC com CarryBytes: 2Ciclos: 12Codificação: 0 0 1 0:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (A) « (A) + (C) + #dadoFlags: C AC OV

ADD

ADD A,<src-byte>Função: AdiçãoDescrição: ADD adiciona o byte indicado ao acumulador, deixando o resultado no acumulador.

As flags de carry e auxiliar de carry são setadas, respectivamente, se houver transporte do bit 7 ou do bit 3, e limpadas caso contrário. Em adições de inteiros sem sinal, a flag de carry indica que ocorreu um overflow. OV é setada se houver transporte do bit 6 mas não do bit 7, ou transporte do bit 7 mas não do bit 6 ; caso contrário OV é limpada. Em adições de inteiros com sinal, OV indica um número negativo produzido com a soma de dois operandos positivos, ou uma soma positiva de dois operandos negativos. São permitidos quatro modos de endereçamento do operando fonte: registrador, direto, registrador-indireto, ou imediato.

Exemplo: O acumulador contém 0C3H (11000011B) e o registrador 0 contém 0AAH (10101010B). A instrução, ADD A, R0

deixará 6DH (01101101B) no acumulador com a flag AC limpa e ambas carry e OV setadas.

ADD A,Rn

Função: Adiciona registrador ao ACCBytes: 1Ciclos: 12Codificação: 0 0 1 0:1 r r rOperação: (A) « (A) +(Rn)Flags: C AC OV

ADD A,direct

Função: Adiciona byte direto ao ACCBytes: 2Ciclos: 12Codificação: 0 0 1 0:0 1 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (A) « (A) + (direto)Flags: C AC OV

ADD A,@Ri

Função: Adiciona RAM indireta ao ACCBytes: 1Ciclos: 12Codificação: 0 0 1 0:0 1 0 iOperação: (A) « (A) + ((Ri))Flags: C AC OV

ADD A,#data

Função: Adiciona dado imediato ao ACCBytes: 2Ciclos: 12Codificação: 0 0 1 0:0 1 0 0 d7 d6 d5 d4:d3 d2 d1 d0Operação: (A) « (A) + #dadoFlags: C AC OV

ACALL

ACALL addr11Função: Chamada absoluta dentro de um bloco de 2KDescrição: ACALL chama incondicionalmente uma subrotina localizada no endereço indicado. A instrução

incrementa o PC duas vezes para obter o endereço da próxima instrução, então coloca esse endereço de 16 bits na pilha(byte de mais baixa ordem primeiro) e incrementa o Stack Pointer duas vezes. O endereço de destino é obtido a partir da concatenação sucessiva dos cinco bits de maior ordem do PC incrementado, dos bits 7-5 do opcode, e do segundo byte da instrução. Consequentemente, a subrotina chamada deve começar dentro do mesmo bloco de 2K da memória de programa tendo como primeiro byte a instrução seguinte a ACALL. Nenhuma flag é afetada.

Exemplo: Inicialmente SP é igual a 07H. O indicador “ SUBRTN “ está no endereço da memória 0345 H. Após a execução da instrução, ACALL SUBRTN no endereço 0123H, SP irá conter 09H, os endereços da RAM interna 08H e 09H irão conter 25H e 01H, respectivamente, e o PC irá conter 0345H.

Bytes: 2Ciclos: 24Codificação: a10 a9 a8 1:0 0 0 1 a7 a6 a5 a4:a3 a2 a1 a0Operação: (PC) « (PC) + 2

(SP) « (SP) + 1 [(SP)] « (PC7-0) (SP) « (SP) + 1 [(SP)] « (PC15-8) (PC10-0) « página de endereço

Flags: Nenhuma

MANIPULAÇÃO BOOLEANA

Instrução Descrição Bytes Períodos C OV ACCLR C Limpa flag de carry 1 12 0CLR bit Limpa bit direto 2 12SETB C Seta flag de carry 1 12 1SETB bit Seta bit direto 2 12CPL C Complementa flag de carry 1 12 xCPL bit Complementa bit direto 2 12ANL C,bit AND com bit direto para carry 2 24 xANL C,/bit AND com complemento do bit direto para carry 2 24 xORL C,bit OR com bit direto para carry 2 24 xORL C,/bit OR com complemento do bit direto para carry 2 24 xMOV C,bit Move bit direto para carry 2 12 xMOV bit,C Move carry para bit direto 2 24JC rel Pula se carry está setada 2 24JNC rel Pula se carry não está setada 2 24JB bit,rel Pula se bit direto está setado 3 24JNB bit,rel Pula se bit direto não está setado 3 24JBC bit,rel Pula se bit direto está setado e limpa esse bit 3 24

TRANSFERÊNCIA DE DADOS

Instrução Descrição Bytes Períodos C OV ACMOV A,Rn Move registrador para ACC 1 12MOV A,direct Move byte direto para ACC 2 12MOV A,@Ri Move RAM indireta para ACC 1 12MOV A,#data Move dado imediato para ACC 2 12MOV Rn,A Mov ACC para registrador 1 12MOV Rn,direct Move byte direto para registrador 2 24MOV Rn,#data Move dado imediato para registrador 2 12MOV direct,A Move ACC para byte direto 2 12MOV direct,Rn Move registrador para byte direto 2 24MOV direct,direct Move byte direto para byte direto 3 24MOV direct,@Ri Mov RAM indireta para byte direto 3 24MOV direct,#data Move dado imediato para byte direto 3 24MOV @Ri,A Move ACC para RAM indireta 1 12MOV @Ri,direct Move byte direto para RAM indireta 2 24MOV @Ri,#data Move dado imediato para RAM indireta 2 12MOV DPTR,#data16 Carrega datapointer com constante de 16bits 3 24MOVC A,@A+DPTR Move byte código em ACC+DPTR para ACC 1 24MOVC A,@A+PC Move byte código em ACC+PC para ACC 1 24MOVX A,@Ri Move RAM externa para ACC 1 24MOVX @Ri,A Move ACC para RAM externa 1 24MOVX A,@DPTR Move RAM externa para ACC 1 24MOVX @DPTR,A Move ACC para RAM externa 1 24PUSH direct Coloca byte direto na pilha 2 24POP direct Retira byte direto da pilha 2 24XCH A,Rn Troca registrador com ACC 1 12XCH A,direct Troca byte direto com ACC 2 12XCH A,@Ri Troca RAM indireta com ACC 1 12XCHD A,@Ri Troca nibble inferior de RAM indireta com ACC 1 12

OPERAÇÕES LÓGICAS

Instrução Descrição Bytes Períodos C OV ACANL A,Rn AND com registrador para ACC 1 12ANL A,direct AND com byte direto para ACC 2 12ANL A,@Ri AND com RAM indireta para ACC 1 12ANL A,#data AND com dado imediato para ACC 2 12ANL direct,A AND com ACC para byte direto 2 12ANL direct,#data AND com dado imediato para byte direto 3 24ORL A,Rn OR com registrador para ACC 1 12ORL A,direct OR com byte direto para ACC 2 12ORL A,@Ri OR com RAM indireta para ACC 1 12ORL A,#data OR com dado imediato para ACC 2 12ORL direct,A OR com ACC para byte direto 2 12ORL direct,#data OR com dado imediato para byte direto 3 24XRL A,Rn XOR com registrador para ACC 1 12XRL A,direct XOR com byte direto para ACC 2 12XRL A,@Ri XOR com RAM indireta para ACC 1 12XRL A,#data XOR com dado imediato para ACC 2 12XRL direct,A XOR com ACC para byte direto 2 12XRL direct,#data XOR com dado imediato para byte direto 3 24CLR A Limpa o ACC 1 12CPL A Complementa o ACC 1 12RL A Rotaciona o ACC a esquerda 1 12RLC A Rotaciona o ACC a esquerda com Carry 1 12 xRR A Rotaciona o ACC a direita 1 12RRC A Rotaciona o ACC a direita com Carry 1 12 xSWAP A Troca os nibbles no ACC 1 12

OPERAÇÕES ARITMÉTICAS

Instrução Descrição Bytes Períodos C OV ACADD A, Rn Adiciona registrador ao ACC 1 12 x x xADD A, direct Adiciona byte direto ao ACC 2 12 x x xADD A, @Ri Adiciona RAM indireta ao ACC 1 12 x x xADD A, #data Adiciona dado imediato ao ACC 2 12 x x xADDC A, Rn Adiciona registrador ao ACC com Carry 1 12 x x xADDC A, direct Adiciona byte direto ao ACC com Carry 2 12 x x xADDC A, @Ri Adiciona RAM indireta ao ACC com Carry 1 12 x x xADDC A, #data Adiciona dado imediato ao ACC com Carry 2 12 x x xSUBB A, Rn Subtrai registrador do ACC com empréstimo 1 12 x x xSUBB A, direct Subtrai byte direto do ACC com empréstimo 2 12 x x xSUBB A, @Ri Subtrai RAM indireta do ACC com empréstimo 1 12 x x xSUBB A, #data Subtrai dado imediato do ACC com empréstimo 2 12 x x xINC A Incrementa ACC 1 12INC Rn Incrementa registrador 1 12INC direct Incrementa byte direto 2 12INC @Ri Incrementa RAM indireta 1 12DEC A Decrementa ACC 1 12DEC Rn Decrementa registrador 1 12DEC direct Decrementa byte direto 2 12DEC @Ri Decrementa RAM indireta 1 12INC DPTR Incrementa Data Pointer 1 24MUL AB Multiplica A e B 1 48 0 xDIV AB Divide A por B 1 48 0 xDA A Ajuste decimal do ACC 1 12 x

Tabela de caracteres ASCIIDecDecDecDec HexHexHexHex CharCharCharChar DecDecDecDec HexHexHexHex CharCharCharChar DecDecDecDec HexHexHexHex CharCharCharChar DecDecDecDec HexHexHexHex CharCharCharChar0 0 NUL 32 20 64 40 @ 96 60 `1 1 SOH 33 21 ! 65 41 A 97 61 a2 2 STX 34 22 " 66 42 B 98 62 b3 3 ETX 35 23 # 67 43 C 99 63 c4 4 EOT 36 24 $ 68 44 D 100 64 d5 5 ENQ 37 25 % 69 45 E 101 65 e6 6 ACK 38 26 & 70 46 F 102 66 f7 7 BEL 39 27 ' 71 47 G 103 67 g8 8 BS 40 28 ( 72 48 H 104 68 h9 9 TAB 41 29 ) 73 49 I 105 69 i10 A LF 42 2A * 74 4A J 106 6A j11 B VT 43 2B + 75 4B K 107 6B k12 C FF 44 2C , 76 4C L 108 6C l13 D CR 45 2D - 77 4D M 109 6D m14 E SO 46 2E . 78 4E N 110 6E n15 F SI 47 2F / 79 4F O 111 6F o16 10 DLE 48 30 0 80 50 P 112 70 p17 11 DC1 49 31 1 81 51 Q 113 71 q18 12 DC2 50 32 2 82 52 R 114 72 r19 13 DC3 51 33 3 83 53 S 115 73 s20 14 DC4 52 34 4 84 54 T 116 74 t21 15 NAK 53 35 5 85 55 U 117 75 u22 16 SYN 54 36 6 86 56 V 118 76 v23 17 ETB 55 37 7 87 57 W 119 77 w24 18 CAN 56 38 8 88 58 X 120 78 x25 19 EM 57 39 9 89 59 Y 121 79 y26 1A SUB 58 3A : 90 5A Z 122 7A z27 1B ESC 59 3B ; 91 5B [ 123 7B {28 1C FS 60 3C < 92 5C \ 124 7C |29 1D GS 61 3D = 93 5D ] 125 7D }30 1E RS 62 3E > 94 5E ^ 126 7E ~31 1F US 63 3F ? 95 5F _ 127 7F DEL

Exemplos Úteis

Usando Motores de Passo

Usando a Comunicação Serial

Usando Motores de Passo

Exemplo 01 :

Inicio: mov R1, #00h

mov DPTR, #Tabela

Teste: cjne R1, #04h, Motor

sjmp Fim

Motor: mov A, R1

movc A,@A+DPTR

mov P1, A

inc R1

sjmp Teste

org 0100h

Tabela: db 01h

db 02h

db 04h

db 08h

Usando a Comunicação Serial

Opções de geração de baud-rates

Baud-Rate desejado

Baud-Rate obtido

Erro obtido (%)

Clock Utilizado (MHz)

Bit Smod Carga do Timer/Couter1 Programado em Modo 2

1.200 1.200 0 11,059 0 E8h2.400 2.400 0 11,059 0 F4h9.600 9.600 0 11,059 0 FDh19.200 19.200 0 11,059 1 FDh1.200 1.202 0,16 12,000 0 E6h2.400 2.404 0,16 12,000 1 E6h9.600 8.923 7 12,000 1 F9h19.200 20.833 8,5 12,000 1 FDh

Exemplo 01 :

org 0000hsjmp Prog

org 0023hsjmp Serial

org 0027hProg: mov TMOD, #00100000b ;Timer1 no modo 2

mov TH1, #0F4h ;recarga do Timer1 para 2400 Bauds

setb TR1 ;inicia Timer 1mov IE, #90hmov SCON, #01010000b

sjmp $

Serial: mov A, SBUFclr RI ;Reseta the bit RI (Reception

Interrupt)reti