Conjunto de instruções Atmel AVR - Atmel AVR instruction set

O conjunto de instruções Atmel AVR é a linguagem de máquina do Atmel AVR , um microcontrolador de chip único RISC de 8 bits com arquitetura Harvard modificada que foi desenvolvido pela Atmel em 1996. O AVR foi uma das primeiras famílias de microcontroladores a usar memória flash no chip para armazenamento do programa.

Registros do processador

Existem 32 registradores de 8 bits de uso geral, R0 – R31. Todas as operações aritméticas e lógicas operam nesses registros; apenas carregue e armazene as instruções de acesso à RAM.

Um número limitado de instruções opera em pares de registradores de 16 bits. O registro de numeração mais baixa do par contém os bits menos significativos e deve ser de numeração par. Os últimos três pares de registradores são usados ​​como registradores de ponteiro para endereçamento de memória. Eles são conhecidos como X (R27: R26), Y (R29: R28) e Z (R31: R30). Os modos de endereçamento pós-incremento e pré-incremento são suportados em todos os três. Y e Z também suportam um deslocamento positivo de seis bits.

As instruções que permitem um valor imediato são limitadas aos registradores R16 – R31 (operações de 8 bits) ou aos pares de registradores R25: R24 – R31: R30 (operações de 16 bits ADIW e SBIW). Algumas variantes da operação MUL são limitadas a oito registros, de R16 a R23.

Registros de propósito especial

Além desses 32 registros de uso geral, a CPU tem alguns registros de uso especial:

  • PC: contador de programa de 16 ou 22 bits
  • SP: ponteiro de pilha de 8 ou 16 bits
  • SREG: registro de status de 8 bits
  • RAMPX, RAMPY, RAMPZ, RAMPD e EIND: registradores de segmento de 8 bits que são prefixados a endereços de 16 bits para formar endereços de 24 bits; disponível apenas em partes com grandes espaços de endereço.

Bits de status

Os bits de registro de status são:

  1. C Carregar bandeira . Este é um sinalizador de empréstimo em subtrações. As instruções INC e não modificam o sinalizador de transporte, portanto, podem ser usadas para fazer um loop em operações aritméticas de vários bytes. DEC
  2. Sinalizador Z Zero . Defina como 1 quando um resultado aritmético for zero.
  3. N Sinalizador negativo . Defina como uma cópia da parte mais significativa de um resultado aritmético.
  4. V Sinalizador de estouro . Definido em caso de estouro de complemento de dois.
  5. S Sinalizar a bandeira. Exclusivo do AVR, é sempre N⊕V e mostra o verdadeiro sinal de uma comparação.
  6. H Meia bandeira de transporte . Este é um transporte interno de adições e é usado para dar suporte à aritmética BCD .
  7. Cópia de bits T. Instruções especiais de carregamento de bits e armazenamento de bits usam esse bit.
  8. I Interromper bandeira . Definido quando as interrupções estão habilitadas.

Endereçando

Os seguintes espaços de endereço estão disponíveis:

  • Os registradores de propósito geral são endereçados por seus números (0–31), embora o número completo de 5 bits não seja armazenado em instruções que só podem operar em um subconjunto desses registradores.
  • Os registradores de E / S têm um espaço de endereço de 6 bits dedicado, a metade inferior do qual é endereçável por bits; algumas partes têm registradores de E / S fora desse espaço de endereço, que são chamados de "E / S estendida" e só são acessíveis como E / S mapeada em memória no espaço de endereço de dados.
  • O espaço de endereço de dados mapeia os 32 registradores de propósito geral, todos os registradores de E / S (incluindo aqueles também acessíveis por meio do espaço de endereço de E / S) e a RAM; ele pode ser endereçado direta ou indiretamente por meio dos registradores de ponteiro X, Y e Z, prefixados se necessário por RAMPX, RAMPY e RAMPZ respectivamente.
  • A memória de programa ( flash ) tem um espaço de endereço separado, endereçado como palavras de 16 bits com o propósito de buscar instruções
  • Com o propósito de buscar dados constantes, a memória do programa é endereçada bytewise por meio do registrador de ponteiro Z, prefixado, se necessário, por RAMPZ.
  • A EEPROM é mapeada na memória em alguns dispositivos; em outros, não é diretamente endereçável e, em vez disso, é acessado por meio de endereços, dados e registros de E / S de controle.
  • Os registradores de uso geral, o registrador de status e alguns registradores de E / S são endereçáveis ​​por bit, sendo o bit 0 o menos significativo e o bit 7 o mais significativo.

Os primeiros 64 registros de E / S são acessíveis por meio de E / S e do espaço de endereço de dados. Eles têm, portanto, dois endereços diferentes. Geralmente são escritos como "0x00 (0x20)" a "0x3F (0x5F)", onde o primeiro item é o endereço de E / S e o segundo, entre parênteses, o endereço de dados.

Os registros de CPU para fins especiais, com exceção do PC, podem ser acessados ​​como registros de E / S. Alguns registros (RAMPX, RAMPY) podem não estar presentes em máquinas com menos de 64 KiB de memória endereçável.

Registro Endereço de I / O Endereço de dados
SREG 0x3F 0x5F
SP 0x3E: 0x3D 0x5E: 0x5D
EIND 0x3C 0x5C
RAMPZ 0x3B 0x5B
RAMPY 0x3A 0x5A
RAMPX 0x39 0x59
RAMPD 0x38 0x58

Um mapa de memória ATmega típico pode ser semelhante a:

Endereço de dados Endereço de I / O Conteúdo
0x0000 - 0x001F Registra R0 - R31
0x0020 - 0x003F 0x00 - 0x1F Registradores de I / O (endereçáveis ​​por bit)
0x0040 - 0x005F 0x20 - 0x3F Registradores de E / S (não endereçáveis ​​por bits)
0x0060 - 0x00FF Registros de E / S estendidos (somente E / S mapeada em memória)
0x0100 - RAMEND SRAM interna

onde RAMEND é o último endereço de RAM. Em partes sem E / S estendida, a RAM iniciaria em 0x0060.

Tempo de instrução

As operações aritméticas funcionam nos registradores R0 – R31, mas não diretamente na RAM e levam um ciclo de clock, exceto para multiplicação e adição de palavras (ADIW e SBIW) que levam dois ciclos.

RAM e espaço de E / S podem ser acessados ​​apenas copiando de ou para os registradores. O acesso indireto (incluindo pós-incremento opcional, pré-incremento ou deslocamento constante) é possível através dos registradores X, Y e Z. Todos os acessos à RAM levam dois ciclos de clock. A movimentação entre registradores e E / S é um ciclo. Mover dados de oito ou dezesseis bits entre registros ou constantes para registrar também é um ciclo. A leitura da memória do programa (LPM) leva três ciclos.

Lista de instrução

As instruções são uma palavra longa de 16 bits, exceto para aquelas que incluem um endereço de 16 ou 22 bits, que leva duas palavras.

Existem dois tipos de ramificações condicionais: pula para o endereço e pula. Ramificações condicionais (BRxx) podem testar um sinalizador ALU e pular para o endereço especificado. Salta (SBxx) testa um bit arbitrário em um registro ou E / S e salta a próxima instrução se o teste for verdadeiro.

Na sequência:

  • Rd e Rr são registros no intervalo R0-R31
  • Rdh e Rrh são registros no intervalo R16 – R31 (metade alta)
  • Rdq e Rrq são registros no intervalo R16 – R23 (um quarto do arquivo de registro)
  • Rp é um par de registros R25: R24, R27: R26 (X), R29: R28 (Y) ou R31: R30 (Z)
  • XYZ é um registrador de ponteiro, X ou Y ou Z
  • YZ é um registrador de ponteiro, Y ou Z
  • s é um número de bit no registro de status (0 = C, 1 = Z, etc., consulte a lista acima)
  • b é um número de bit em um registro de uso geral ou I / O (0 = menos significativo, 7 = mais significativo)
  • K6 é uma constante sem sinal imediata de 6 bits (intervalo: 0-63)
  • K8 é uma constante imediata de 8 bits; uma vez que é usado apenas em operações de 8 bits, sua sinalização é irrelevante
  • IO5 é um endereço de E / S de 5 bits que cobre a parte endereçável por bits do espaço de endereço de E / S, ou seja, a metade inferior (intervalo: 0-31)
  • IO6 é um endereço de E / S de 6 bits que cobre todo o espaço de endereço de E / S (intervalo: 0-63)
  • D16 é um endereço de dados de 16 bits que cobre 64  KiB ; em partes com mais de 64 KiB de espaço de dados, o conteúdo do registro de segmento RAMPD é anexado
  • P22 é um endereço de programa de 22 bits que cobre 2 22 palavras de 16 bits (ou seja, 8  MiB )
  • S7 e S12 são deslocamentos sinalizados de 7 bits (resp. 12 bits) , em unidades de palavras, em relação ao endereço do programa armazenado no contador do programa
Conjunto de instruções AVR
Aritmética Bit & Outros Transferir Pular Galho Ligar
ADD   Rd, Rr 
ADC   Rd, Rr            
ADIW  Rp+1:Rp, K6       

SUB   Rd, Rr            
SUBI  Rdh, K8           
SBC   Rd, Rr            
SBCI  Rdh, K8           
SBIW  Rp+1:Rp, K6       

INC   Rd                
DEC   Rd                

AND   Rd, Rr            
ANDI  Rdh, K8           
OR    Rd, Rr            
ORI   Rdh, K8                       
COM   Rd                
NEG   Rd                
CP    Rd, Rr            
CPC   Rd, Rr            
CPI   Rdh, K8           
SWAP  Rd                
LSR   Rd                
ROR   Rd                
ASR   Rd                

MUL     Rd, Rr         
MULS    Rdh, Rrh       
MULSU   Rdq, Rrq       
FMUL    Rdq, Rrq       
FMULS   Rdq, Rrq       
FMULSU  Rdq, Rrq
BSET  s    
BCLR  s                 
SBI   IO5, b            
CBI   IO5, b            
BST   Rd, b             
BLD   Rd, b             

NOP                     
BREAK                   
SLEEP                   
WDR
MOV  Rd, Rr 
MOVW Rd+1:Rd, Rr+1:Rr   

IN    Rd, IO6           
OUT   IO6, Rr           

PUSH  Rr                
POP   Rr                

LDI   Rdh, K8           
LDS   Rd, D16           

LD    Rd, X             
LDD   Rd, YZ+K6         
LD    Rd, -XYZ          
LD    Rd, XYZ+          

STS   D16, Rr           

ST    X, Rr             
STD   YZ+K6, Rr         
ST    -XYZ, Rr          
ST    XYZ+, Rr          

LPM                     
LPM   Rd, Z             
LPM   Rd, Z+            
ELPM                    
ELPM  Rd, Z             
ELPM  Rd, Z+            

SPM
RJMP  S12  
IJMP                    
EIJMP                   
JMP   P22
CPSE  Rd, Rr 

SBRC  Rr, b             
SBRS  Rr, b             

SBIC  IO5, b            
SBIS  IO5, b            

BRBC  s, S7             
BRBS  s, S7
RCALL   S12
ICALL                   
EICALL                  
CALL      P22           

RET                     
RETI

Herança do conjunto de instruções

Nem todas as instruções são implementadas em todos os controladores Atmel AVR . É o caso das instruções que realizam multiplicações, cargas / saltos / chamadas estendidas, saltos longos e controle de potência.

As instruções opcionais podem ser agrupadas em três categorias:

  • recursos do núcleo da CPU (computação), adicionados em núcleos de CPU mais capazes
  • recursos de endereçamento de memória, adicionados em todos os modelos com memória grande o suficiente para exigi-los
  • recursos opcionais, alguns periféricos que podem ou não estar presentes em um modelo específico.

Embora os processadores mais avançados tendam a ter núcleos mais capazes e mais memória, a presença de um não garante a presença do outro.

Instruções do núcleo da CPU

Começando com o núcleo "clássico" original, as melhorias são organizadas nos seguintes níveis, cada um incluindo todos os anteriores:

  1. O núcleo "Clássico" possui apenas a forma de operando zero da LPM instrução, que é equivalente a LPM r0,Z .
  2. "Classic plus" adiciona a MOVW instrução para mover pares de registradores e a forma mais geral da instrução LPM ( LPM Rd,Z e LPM Rd,Z+ ) que permite um registrador de destino arbitrário e um incremento automático do ponteiro Z.
  3. Os núcleos "aprimorados" adicionam as instruções de multiplicação.
  4. Os núcleos XMEGA não adicionam novas instruções per se , mas fazem algumas mudanças significativas:
    • O mapa de memória é reorganizado, eliminando o mapeamento de memória do arquivo de registro do processador (então as portas de E / S começam no endereço RAM 0) e expandindo o intervalo de portas de E / S. Agora, o primeiro 4K é registrador de função especial, o segundo 4K é flash de dados e a RAM normal começa em 8K.
    • Não é necessário desabilitar explicitamente as interrupções antes de ajustar os registradores do ponteiro da pilha (SPL e SPH); qualquer gravação no SPL desativa automaticamente as interrupções por 4 ciclos de clock para dar tempo para que o SPH seja atualizado.
    • Outros registradores multibyte são fornecidos com registradores sombra para permitir leitura e gravação atômica . Quando o byte de ordem inferior é lido, os bytes de ordem superior são copiados para os registradores sombra, portanto, lê-los mais tarde produz um instantâneo do registrador no momento da primeira leitura. As gravações em bytes de ordem inferior são armazenadas em buffer até que o byte de ordem mais alta seja gravado, no qual todo o registro multibyte é atualizado atomicamente.
  5. Os núcleos XMEGA posteriores (especificamente, os modelos B, C e AU, como o ATxmega16A4U, mas não os modelos A, D e E anteriores, como o ATxmega16D4) adicionam quatro instruções atômicas de leitura-modificação-gravação : exchange ( XCH ), load- e definir, carregar e limpar e carregar e alternar. Eles ajudam na coordenação com periféricos de acesso direto à memória , principalmente um controlador USB .

Menos capazes do que os núcleos de CPU "clássicos" são dois subconjuntos: o núcleo "AVR1" e o "AVR tiny". Surpreendentemente, os processadores da marca "ATtiny" têm uma variedade de núcleos, incluindo AVR1 (ATtiny11, ATtiny28), clássico (ATtiny22, ATtiny26), clássico + (ATtiny24) e AVRtiny (ATtiny20, ATtiny40).

O subconjunto AVR1 não era popular e nenhum modelo novo foi introduzido desde 2000. Ele omite toda a RAM, exceto para os 32 registradores mapeados no endereço 0–31 e as portas de E / S nos endereços 32–95. A pilha é substituída por uma pilha de hardware de 3 níveis e as instruções PUSH e POP são excluídas. Todas as operações de 16 bits são excluídos, como são IJMP , ICALL e todos os de carga e armazenamento abordando os modos, exceto indirecta através Z.

Uma segunda tentativa, mais bem-sucedida, de subdividir o conjunto de instruções AVR é ​​o núcleo "pequeno AVR".

A mudança mais significativa é que o núcleo AVRtiny omite os registros R0 – R15. Os registradores também não são mapeados na memória, com portas de E / S de 0-63 e RAM de uso geral começando no endereço 64. As operações aritméticas de 16 bits ( ADIW , SBIW ) são omitidas, assim como os modos de endereçamento carregar / armazenar com deslocamento ( Y+d , Z+d ), mas os modos de endereçamento de pré e pós-incremento são mantidos. A LPM instrução é omitida; em vez disso, o ROM do programa é mapeado para o espaço de endereço de dados e pode ser acessado com instruções de carregamento normais.

Finalmente, o núcleo AVRtiny exclui as 2 palavras LDS e STS instruções para endereçamento de RAM direto e, em vez disso, usa o espaço de opcode previamente atribuído ao carregamento / armazenamento com instruções de deslocamento para novas 1 palavra LDS e STS instruções que podem acessar os primeiros 128 locais de RAM de propósito, endereça 0x40 a 0xBF. (As instruções IN e OUT fornecem acesso direto ao espaço de E / S de 0 a 0x3F.)

Instruções de endereçamento de memória

Os menores núcleos têm ≤256 bytes de espaço de endereço de dados (significando ≤128 bytes de RAM depois que as portas de E / S e outros endereços reservados são removidos) e ≤8192 bytes (8 KiB) de ROM do programa. Eles têm apenas um ponteiro de pilha de 8 bits (em SPL) e suportam apenas as instruções de salto / chamada relativas de 12 bits RJMP / RCALL . (Como o contador do programa AVR conta palavras de 16 bits, não bytes, um deslocamento de 12 bits é suficiente para endereçar 2 13 bytes de ROM.)

Recursos adicionais de endereçamento de memória estão presentes conforme necessário para acessar os recursos disponíveis:

  1. Modelos com> 256 bytes de espaço de endereço de dados (≥256 bytes de RAM) têm um ponteiro de pilha de 16 bits, com a metade alta no registrador SPH.
  2. Modelos com> 8 KiB de ROM adicionam 2 palavras (22 bits) JUMP e CALL instruções. (Alguns modelos anteriores sofrem uma errata se uma instrução de salto for seguida por uma instrução de 2 palavras.)
  3. Modelos com> 64 KiB de ROM adicionam a ELPM instrução e o registro RAMPZ correspondente. LPM as instruções estendem para zero o endereço ROM em Z; ELPM as instruções precedem o registro RAMPZ para bits altos. Isso não é a mesma coisa que a LPM instrução mais geral ; existem modelos "clássicos" com apenas a forma de operando zero ELPM (ATmega103 e at43usb320). Quando o incremento automático está disponível (a maioria dos modelos), ele atualiza todo o endereço de 24 bits, incluindo RAMPZ.
  4. Modelos (raros) com> 128 KiB de ROM têm um contador de programa de 3 bytes. Chamadas e retornos de subrotina usam um byte adicional de espaço de pilha, há um novo registrador EIND para fornecer bits altos adicionais para saltos e chamadas indiretas e há novas instruções estendidas EIJMP e EICALL que usam EIND: Z como o endereço de destino. (O anterior IJMP e as ICALL instruções usam Z estendido com zero).
  5. Modelos (raros) com> 64 KiB de espaço de endereço de RAM estendem os limites de endereçamento de RAM de 16 bits com registros RAMPX, RAMPY, RAMPZ e RAMPD. Eles fornecem bits altos adicionais para modos de endereçamento que usam os pares de registradores X, Y ou Z, respectivamente, ou as instruções de endereçamento direto LDS / STS . Ao contrário do acesso à ROM, não há instruções "estendidas" distintas; em vez disso, os registros RAMP são usados ​​incondicionalmente.

Instruções de recursos opcionais

Três instruções estão presentes apenas em modelos que possuem a instalação de hardware correspondente

  • SPM para armazenamento em flash ROM, está presente apenas em processadores com flash ROM (a maioria deles)
  • BREAK para invocar o depurador no chip, é omitido em alguns modelos pequenos sem suporte ao depurador no chip
  • DES para executar rodadas de Data Encryption Standard , está presente em modelos XMEGA com suporte a acelerador DES

As arquiteturas diferentes de AVR1 são nomeadas de acordo com as convenções avr-libc.

Família Membros Aritmética Galhos Transferências Bit-Wise
Núcleo AVR1 mínimo
Classic Core até 8K Program Space ("AVR2") novas instruções: novas instruções: novas instruções: (nada de novo)
AVR2, com instruções MOVW e LPM ("AVR2.5")
  • ATa5272
  • ATtiny13 / a
  • ATtiny2313 / a
  • ATtiny24 / a
  • ATtiny25
  • ATtiny261 / a
  • ATtiny4313
  • ATtiny43u
  • ATtiny44 / a
  • ATtiny45
  • ATtiny461 / a
  • ATtiny48
  • ATtiny828
  • ATtiny84 / a
  • ATtiny85
  • ATtiny861 / a
  • ATtiny87
  • ATtiny88
(nada de novo) (nada de novo) novas instruções:
  • MOVW
  • LPM (Rx, Z [+])
(nada de novo)
Classic Core com até 128K ("AVR3") (nada de novo) novas instruções: novas instruções: (nada de novo)
Enhanced Core com até 8K ("AVR4") novas instruções: (nada de novo) novas instruções: (nada de novo)
Enhanced Core com até 128K ("AVR5", "AVR5.1") (nada de novo) nova instrução: (nada de novo) novas instruções:
Enhanced Core com até 4M ("AVR5" e "AVR6") (nada de novo) novas instruções: (nada de novo) (nada de novo)
XMEGA Core ("avrxmega" 2-6) ATxmega series novas instruções: (nada de novo) novas instruções (da segunda revisão de silício - partes AU, B, C) (nada de novo)
Núcleo AVRtiny reduzido ("avrtiny10") (Idêntico ao núcleo mínimo, exceto para conjunto de registros de CPU reduzido) (Idêntico ao núcleo clássico com até 8K, exceto para conjunto de registros de CPU reduzido) Idêntico ao núcleo clássico com até 8K, com as seguintes exceções: (Idêntico ao núcleo aprimorado com até 128K, exceto para conjunto de registros de CPU reduzido)

Codificação de instrução

Atribuições de bits:

  • rrrrr = Registro fonte
  • rrrr = Registrador fonte (R16 – R31)
  • rrr = registrador fonte (R16 – R23)
  • RRRR = par de registro de origem (R1: R0 – R31: R30)
  • ddddd = Registro de destino
  • dddd = Registro de destino (R16 – R31)
  • ddd = Registro de destino (R16 – R23)
  • DDDD = Par de registro de destino (R1: R0 – R31: R30)
  • pp = Registrar par, W, X, Y ou Z
  • y = bit do par de registro Y / Z (0 = Z, 1 = Y)
  • u = FMUL (S (U)) assinado com 0 = assinado ou 1 = não assinado
  • s = armazenar / carregar bit (0 = carregar, 1 = armazenar)
  • c = ligar / pular (0 = pular, 1 = ligar)
  • cy = com transporte (0 = sem transporte, 1 = com transporte)
  • e = Estenda o salto indireto / endereço de chamada com EIND (0 = 0: Z, 1 = EIND: Z)
  • q = Estender endereço de memória de programa com RAMPZ (0 = 0: Z, 1 = RAMPZ: Z)
  • aaaaaa = endereço de espaço de E / S
  • aaaaa = endereço de espaço de E / S (primeiros 32 apenas)
  • bbb = Número do bit (0–7)
  • B = valor do bit (0 ou 1)
  • kkkk = constante sem sinal de 4 bits (opcode DES)
  • kkkkkk = constante sem sinal de 6 bits
  • KKKKKKKK = constante de 8 bits

O Atmel AVR usa muitos campos divididos, onde os bits não são contíguos na palavra de instrução. As instruções de carregamento / armazenamento com deslocamento são o exemplo mais extremo em que um deslocamento de 6 bits é dividido em três partes.

Visão geral do conjunto de instruções Atmel AVR
1
5
1
4
1
3
1
2
1
1
1
0

9

8

7

6

5

4

3

2

1

0
Instrução
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 NOP
0 0 0 0 0 0 0 1 DDDD RRRR MOVW Rd, Rr Par de registro de movimento
0 0 0 0 0 0 1 0 dddd rrrr MULS Rd, Rr
0 0 0 0 0 0 1 1 0 ddd 0 rrr MULSU Rd, Rr
0 0 0 0 0 0 1 1 0 ddd 1 rrr FMUL Rd, Rr
0 0 0 0 0 0 1 1 1 ddd você rrr FMULS (U) Rd, Rr
0 0 Código de operação r ddddd rrrr Instruções de 2 operandos
0 0 0 c̅y̅ 0 1 r ddddd rrrr CPC / CP Rd, Rr
0 0 0 c̅y̅ 1 0 r ddddd rrrr SBC / SUB Rd, Rr
0 0 0 cy 1 1 r ddddd rrrr ADD / ADC Rd, Rr (LSL / ROL Rd quando Rd = Rr)
0 0 0 1 0 0 r ddddd rrrr CPSE Rd, Rr
0 0 1 0 0 0 r ddddd rrrr AND Rd, Rr
0 0 1 0 0 1 r ddddd rrrr EOR Rd, Rr
0 0 1 0 1 0 r ddddd rrrr OR Rd, Rr
0 0 1 0 1 1 r ddddd rrrr MOV Rd, Rr
0 0 1 1 HAHAHAHA dddd HAHAHAHA CPI Rd, K
0 1 opc HAHAHAHA dddd HAHAHAHA Operações de registro imediato
0 1 0 c̅y̅ HAHAHAHA dddd HAHAHAHA SBCI / SUBI Rd, K
0 1 1 0 HAHAHAHA dddd HAHAHAHA ORI Rd, K
SBR Rd, K
0 1 1 1 HAHAHAHA dddd HAHAHAHA ANDI Rd, K
CBR Rd, K
1 0 k 0 kk s ddddd y kkk LDD / STD Rd a Z + k ou Y + k
1 0 0 1 0 0 s ddddd Código de operação Carregar / armazenar operações
1 0 0 1 0 0 s ddddd 0 0 0 0 LDS rd, i / STS i, rd
Endereço SRAM imediato de 16 bits i
1 0 0 1 0 0 s ddddd y 0 0 1 LD / ST Rd a Z + / Y +
1 0 0 1 0 0 s ddddd y 0 1 0 LD / ST Rd a −Z / −Y
1 0 0 1 0 0 0 ddddd 0 1 q 0 LPM / ELPM Rd, Z
1 0 0 1 0 0 0 ddddd 0 1 q 1 LPM / ELPM Rd, Z +
1 0 0 1 0 0 1 ddddd 0 1 0 0 XCH Z, Rd
1 0 0 1 0 0 1 ddddd 0 1 0 1 LAS Z, Rd
1 0 0 1 0 0 1 ddddd 0 1 1 0 LAC Z, Rd
1 0 0 1 0 0 1 ddddd 0 1 1 1 LAT Z, Rd
1 0 0 1 0 0 s ddddd 1 1 0 0 LD / ST Rd a X
1 0 0 1 0 0 s ddddd 1 1 0 1 LD / ST Rd a X +
1 0 0 1 0 0 s ddddd 1 1 1 0 LD / ST Rd até −X
1 0 0 1 0 0 s ddddd 1 1 1 1 POP / PUSH Rd
1 0 0 1 0 1 0 ddddd 0 Código de operação Instruções de um operando:
1 0 0 1 0 1 0 ddddd 0 0 0 0 COM Rd
1 0 0 1 0 1 0 ddddd 0 0 0 1 NEG Rd
1 0 0 1 0 1 0 ddddd 0 0 1 0 SWAP Rd
1 0 0 1 0 1 0 ddddd 0 0 1 1 INC Rd
1 0 0 1 0 1 0 ddddd 0 1 0 0 (reservado)
1 0 0 1 0 1 0 ddddd 0 1 0 1 ASR Rd
1 0 0 1 0 1 0 ddddd 0 1 1 0 LSR Rd
1 0 0 1 0 1 0 ddddd 0 1 1 1 ROR Rd
1 0 0 1 0 1 0 0 bbb 1 0 0 0 Bit de limpeza / definição de status SEx / CLx
1 0 0 1 0 1 0 1 Código de operação 1 0 0 0 Instruções de operando zero
1 0 0 1 0 1 0 1 0 0 0 0 1 0 0 0 RET
1 0 0 1 0 1 0 1 0 0 0 1 1 0 0 0 RETI
1 0 0 1 0 1 0 1 0 0 1 x 1 0 0 0 (reservado)
1 0 0 1 0 1 0 1 0 1 x x 1 0 0 0 (reservado)
1 0 0 1 0 1 0 1 1 0 0 0 1 0 0 0 DORMIR
1 0 0 1 0 1 0 1 1 0 0 1 1 0 0 0 PAUSA
1 0 0 1 0 1 0 1 1 0 1 0 1 0 0 0 WDR
1 0 0 1 0 1 0 1 1 0 1 1 1 0 0 0 (reservado)
1 0 0 1 0 1 0 1 1 1 0 q 1 0 0 0 LPM / ELPM
1 0 0 1 0 1 0 1 1 1 1 0 1 0 0 0 SPM
1 0 0 1 0 1 0 1 1 1 1 1 1 0 0 0 SPM Z +
1 0 0 1 0 1 0 c 0 0 0 e 1 0 0 1 Salto / chamada indireta para Z ou EIND: Z
1 0 0 1 0 1 0 ddddd 1 0 1 0 DEC Rd
1 0 0 1 0 1 0 0 hahahaha 1 0 1 1 DES rodada k
1 0 0 1 0 1 0 kkkkk 1 1 c k JMP / CALL abs22
kkkkkkkkkkkkkkkkk
1 0 0 1 0 1 1 0 kk pp hahahaha ADIW Rp, uimm6
1 0 0 1 0 1 1 1 kk pp hahahaha SBIW Rp, uimm6
1 0 0 1 1 0 B 0 aaaaa bbb CBI / SBI a, b (limpar / definir bit I / O)
1 0 0 1 1 0 B 1 aaaaa bbb SBIC / SBIS a, b (teste de bit I / O)
1 0 0 1 1 1 r ddddd rrrr MUL, sem sinal: R1: R0 = Rr × Rd
1 0 1 1 s aa ddddd aaaa IN / OUT para o espaço de E / S
1 1 0 c Deslocamento assinado de 12 bits RJMP / RCALL para PC + simm12
1 1 1 0 HAHAHAHA dddd HAHAHAHA LDI Rd, K
1 1 1 1 0 Deslocamento assinado de 7 bits bbb Ramificação condicional no bit de registro de status
1 1 1 1 1 0 s ddddd 0 bbb Bit de registro BLD / BST para STATUS.T
1 1 1 1 1 1 B ddddd 0 bbb SBRC / SBRS pula se o bit de registro for igual a B
1 1 1 1 1 x x ddddd 1 bbb (reservado)

Referências

links externos