| Mnemonik | Beschreibung | Funktion | Flags | T. | Kode/Emul. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ADD Rd,Rr | Addiert zwei Register | Rd ← Rd + Rr | Z,C,N,V,S,H | 1 | 000011rd ddddrrrr
| ADC Rd,Rr
| Addiert Carry und zwei Register
| Rd ← Rd + Rr + C
| Z,C,N,V,S,H
| 1
| 000111rd ddddrrrr
| ADIW Rd,K
| Addiert eine Konstante zu einem Registerpaar
| Rd+1:Rd ← Rd+1:Rd + K
| Z,C,N,V,S
| 2
| 10010110 KKddKKKK
| SUB Rd,Rr
| Subtrahiert zwei Register
| Rd ← Rd - Rr
| Z,C,N,V,S,H
| 1
| 000110rd ddddrrrr
| SUBI Rd,K
| Subtrahiert eine Konstante vom Register
| Rd ← Rd - K
| Z,C,N,V,S,H
| 1
| 0101KKKK ddddKKKK
| SBC Rd,Rr
| Subtrahiert Carry und Register vom Register
| Rd ← Rd - Rr - C
| Z,C,N,V,S,H
| 1
| 000010rd ddddrrrr
| SBCI Rd,K
| Subtrahiert eine Konstante und Carry vom Register
| Rd ← Rd - K - C
| Z,C,N,V,S,H
| 1
| 0100KKKK ddddKKKK
| SBIW Rd,K
| Subtrahiert eine Konstante von einem Registerpaar
| Rd+1:Rd ← Rd+1:Rd - K
| Z,C,N,V,S
| 2
| 10010111 KKddKKKK
| AND Rd,Rr
| Logische UND-Verknüpfung zweier Register
| Rd ← Rd • Rr
| Z,N,V,S
| 1
| 001000rd ddddrrrr
| ANDI Rd,K
| Logische UND-Verknüpfung Register mit Konstante
| Rd ← Rd • K
| Z,N,V,S
| 1
| 0111KKKK ddddKKKK
| OR Rd,Rr
| Logische ODER-Verknüpfung zweier Register
| Rd ← Rd ∨ Rr
| Z,N,V,S
| 1
| 001010rd ddddrrrr
| ORI Rd,K
| Logische ODER-Verknüpfung Register mit Konstante
| Rd ← Rd ∨ K
| Z,N,V,S
| 1
| 0110KKKK ddddKKKK
| EOR Rd,Rr
| Logische XOR-Verknüpfung zweier Register
| Rd ← Rd ⊕ Rr
| Z,N,V,S
| 1
| 001001rd ddddrrrr
| COM Rd
| Einerkomplement des Registers
| Rd ← FFh - Rd
| Z,C,N,V,S
| 1
| 1001010d dddd0000
| NEG Rd
| Zweierkomplement des Registers
| Rd ← 00h - Rd
| Z,C,N,V,S,H
| 1
| 1001010d dddd0001
| SBR Rd,K
| Setzt Bit(s) in Register
| Rd ← Rd ∨ K
| Z,N,V,S
| 1
| OR Rd,K
| CBR Rd,K
| Löscht Bit(s) in Register
| Rd ← Rd • (FFh - K)
| Z,N,V,S
| 1
| AND Rd,~K
| INC Rd
| Inkrementieren Register
| Rd ← Rd + 1
| Z,N,V,S
| 1
| 1001010d dddd0011
| DEC Rd
| Dekrementieren Register
| Rd ← Rd - 1
| Z,N,V,S
| 1
| 1001010d dddd1010
| TST Rr
| Test ob Register Null oder negativ
| Rr ?
| Z,N,V,S
| 1
| AND Rr,Rr
| CLR Rd
| Löschen Register
| Rd ← 0
| Z,N,V,S
| 1
| EOR Rd,Rd
| SER Rd
| Setzen des Registers
| Rd ← FFh
| keines
| 1
| LDI Rd,0xFF
| MUL Rd,Rr
| Multipliziert Rd und Rr, ohne Vorzeichen
| R1:R0 ← Rd × Rr
| Z,C
| 2
| 100111rd ddddrrrr
| MULS Rd,Rr
| Multipliziert Rd und Rr, mit Vorzeichen
| R1:R0 ← Rd × Rr
| Z,C
| 2
| 00000010 ddddrrrr
| MULSU Rd,Rr
| Multipliziert Rd und Rr, mit / ohne Vorzeichen
| R1:R0 ← Rd × Rr
| Z,C
| 2
| 00000011 0ddd0rrr
| FMUL Rd,Rr
| Multipliziert Rd und Rr, gebrochene Zahlen ohne Vorzeichen
| R1:R0 ← (Rd×Rr)≪1
| Z,C
| 2
| 00000011 0ddd1rrr
| FMULS Rd,Rr
| Multipliziert Rd und Rr, gebrochene Zahlen mit Vorzeichen
| R1:R0 ← (Rd×Rr)≪1
| Z,C
| 2
| 00000011 1ddd0rrr
| FMULSU Rd,Rr
| Multipliziert Rd und Rr, gebrochene Zahlen mit / ohne Vorzeichen
| R1:R0 ← (Rd×Rr)≪1
| Z,C
| 2
| 00000011 1ddd1rrr
| |
| Mnemonik | Beschreibung | Funktion | Flags | T. | Kode/Emul. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| MOV Rd,Rr | Kopiert von Register nach Register | Rd ← Rr | keines | 1 | 001011rd ddddrrrr
| MOVW Rd,Rr
| Kopiert von Registerpaar nach Registerpaar
| Rd+1:Rd ← Rr+1:Rr
| keines
| 1
| 00000001 ddddrrrr
| LDI Rd,K
| Register mit Konstante laden
| Rd ← K
| keines
| 1
| 1110KKKK ddddKKKK
| LDS Rd,k
| Register mit Konstante aus Datenspeicher laden
| Rd ← (k)
| keines
| 2
| 1001000d dddd0000 | kkkkkkkk kkkkkkkk LD Rd,z
| Register indirekt laden
| Rd ← (z)
| keines
| 2
| 1001000d ddddzz00
| LD Rd,z+
| Register indirekt laden, Zeiger inkrementieren
| Rd ← (z), z ← z + 1
| keines
| 2
| 1001000d ddddzz01
| LD Rd,-z
| Zeiger dekrementieren, Register indirekt laden
| z ← z - 1, Rd ← (z)
| keines
| 2
| 1001000d ddddzz10
| LDD Rd,z+q
| Register indirekt mit Offset laden
| Rd ← (Y + q)
| keines
| 2
| 10q0qq0d ddddzqqq
| STS k,Rr
| Register in Datenspeicher speichern
| (k) ← Rr
| keines
| 2
| 1001001d dddd0000 | kkkkkkkk kkkkkkkk ST z,Rr
| Register indirekt speichern
| (z) ← Rr
| keines
| 2
| 1000001r rrrrzz00
| ST z+,Rr
| Register indirekt speichern, Zeiger inkrementieren
| (z) ← Rr, X ← X + 1
| keines
| 2
| 1001001r rrrrzz01
| ST -z,Rr
| Zeiger dekrementieren, Register indirekt speichern
| X ← X - 1, (X) ← Rr
| keines
| 2
| 1001001r rrrrzz10
| STD z+q,Rr
| Register indirekt mit Offset speichern
| (Y + q) ← Rr
| keines
| 2
| 10q0qq1r rrrrzqqq
| LPM
| Laden aus dem Programmspeicher in R0
| R0 ← (Z)
| keines
| 3
| 10010101 11001000
| LPM Rd,Z
| Laden aus dem Programmspeicher in Rd
| Rd ← (Z)
| keines
| 3
| 1001000d dddd0100
| LPM Rd,Z+
| Laden aus dem Programmspeicher in Rd, Z inkrementieren
| Rd ← (Z), Z ← Z + 1
| keines
| 3
| 1001000d dddd0101
| ELPM
| Laden aus dem erweiterten Programmspeicher in R0
| R0 ← (RAMPZ:Z)
| keines
| 3
| 10010101 11011000
| ELPM Rd,Z
| Laden aus dem erweiterten Programmspeicher in Rd
| Rd ← (RAMPZ:Z)
| keines
| 3
| 1001000d dddd0110
| ELPM Rd,Z+
| Laden aus dem erweiterten Programmspeicher in Rd, Z inkrementieren
| Rd ← (RAMPZ:Z), Z ← Z + 1
| keines
| 3
| 1001000d dddd0111
| SPM
| In den Programmspeicher speichern
| (Z) ← R1:R0
| keines
| -
| 10010101 11101000
| IN Rd,A
| I/O-Adresse lesen
| Rd ← (A+0x20)
| keines
| 1
| 10110AAd ddddAAAA
| OUT A,Rr
| I/O-Adresse beschreiben
| (A+0x20) ← Rr
| keines
| 1
| 10111AAr rrrrAAAA
| PUSH Rr
| Sichert Rr in den Stack
| (SP) ← Rr, SP ← SP - 1
| keines
| 2
| 1001001d dddd1111
| POP Rd
| Holt Stackspitze in Rd
| SP ← SP + 1, Rd ← (SP)
| keines
| 2
| 1001000d dddd1111
| |
| Mnemonik | Beschreibung | Funktion | Flags | T. | Kode/Emul. | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| BREAK | Unterbrechung | siehe Beschreibung der Break-Funktion | keines | 1 | 10010101 10011000
| NOP
| Leerbefehl
| keine Operation
| keines
| 1
| 00000000 00000000
| SLEEP
| Übergang in den Sleep-Modus
| siehe Beschreibung der Sleep-Funktion
| keines
| 1
| 10010101 10001000
| WDR
| Watchdog-Reset
| siehe Beschreibung Watchdog-Zeitgeber
| keines
| 1
| 10010101 10101000
| |
| Mnemonik | Beschreibung | Funktion | Flags | T. | Kode/Emul. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| RJMP k | Relativer Sprung | PC ← PC + k + 1 | keines | 2 | 1100kkkk kkkkkkkk
| IJMP
| Indirekter Sprung zu (Z)
| PC(15:0) ← Z, PC(21:16) ← 0
| keines
| 2
| 10010100 00001001
| EIJMP
| Erweiterter indirekter Sprung zu (Z)
| PC(15:0) ← Z, PC(21:16) ← EIND
| keines
| 2
| 10010100 00011001
| JMP k
| Direkter Sprung
| PC ← k
| keines
| 3
| 1001010k kkkk110k | kkkkkkkk kkkkkkkk RCALL k
| Relativer Unterprogramm-Aufruf
| PUSH PC, PC ← PC + k + 1
| keines
| 3/4
| 1101kkkk kkkkkkkk
| ICALL
| Indirekter Unterprogramm-Aufruf
| PUSH PC, PC(15:0) ← Z, PC(21:16) ← 0
| keines
| 3/4
| 10010101 00001001
| EICALL
| Erweiterter indirekter Unterprogramm-Aufruf
| PUSH PC, PC(15:0) ← Z, PC(21:16) ← EIND
| keines
| 4
| 10010101 00011001
| CALL k
| Direkter Unterprogramm-Aufruf
| PUSH PC, PC ← k
| keines
| 4
| 1001010k kkkk111k | kkkkkkkk kkkkkkkk RET
| Rückkehr aus Unterprogramm
| POP PC
| keines
| 4
| 10010101 00001000
| RETI
| Rückkehr aus Interrupt-Routine
| POP PC, I ← 1
| I
| 4
| 10010101 00011000
| CPSE Rd,Rr
| Vergleichen, überspringen wenn gleich
| Wenn (Rd=Rr) dann PC ← PC + 2 oder 3
| keines
| 1/2/3
| 000100rd ddddrrrr
| CP Rd,Rr
| Vergleichen
| Rd - Rr ?
| Z,N,S,V,C,H
| 1
| 000101rd ddddrrrr
| CPC Rd,Rr
| Register vergleichen mit Carry
| Rd - Rr - C ?
| Z,N,S,V,C,H
| 1
| 000001rd ddddrrrr
| CPI Rd,K
| Vergleiche Register mit Konstante
| Rd - K ?
| Z,N,S,V,C,H
| 1
| 0011KKKK ddddKKKK
| SBRC Rr,b
| Überspringen, wenn Bit in Register gelöscht
| Wenn (Rr(b)=0) dann PC ← PC + 2 oder 3
| keines
| 1/2/3
| 1111110r rrrr0bbb
| SBRS Rr,b
| Überspringen, wenn Bit in Register gesetzt
| Wenn (Rr(b)=1) dann PC ← PC + 2 oder 3
| keines
| 1/2/3
| 1111111r rrrr0bbb
| SBIC A,b
| Überspringen, wenn Bit in I/O-Register gelöscht
| Wenn (A[b]=0) dann PC ← PC + 2 oder 3
| keines
| 1/2/3
| 10011001 AAAAAbbb
| SBIS A,b
| Überspringen, wenn Bit in I/O-Register gesetzt
| Wenn (A[b]=1) dann PC ← PC + 2 oder 3
| keines
| 1/2/3
| 10011011 AAAAAbbb
| BRBS s,k
| Verzweigen, wenn Statusbit s gesetzt ist.
| Wenn (SREG[s]=1) dann PC ← PC + k + 1
| keines
| 1/2
| 111100kk kkkkksss
| BRBC s,k
| Verzweigen, wenn Statusbit s gelöscht ist.
| Wenn (SREG[s]=0) dann PC ← PC + k + 1
| keines
| 1/2
| 111101kk kkkkksss
| BREQ k
| Verzweigen wenn gleich
| Wenn (Z=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 1,k
| BRNE k
| Verzweigen wenn nicht gleich
| Wenn (Z=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 1,k
| BRCS k
| Verzweigen wenn Carry gesetzt ist.
| Wenn (C=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 0,k
| BRCC k
| Verzweigen wenn Carry gelöscht ist.
| Wenn (C=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 0,k
| BRSH k
| Verzweigen wenn gleich oder größer
| Wenn (C=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 0,k
| BRLO k
| Verzweigen wenn kleiner
| Wenn (C=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 0,k
| BRMI k
| Verzweigen wenn Minus
| Wenn (N=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 2,k
| BRPL k
| Verzweigen wenn Plus
| Wenn (N=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 2,k
| BRGE k
| Verzweigen wenn größer oder gleich, vorzeichenbehaftet
| Wenn (N ⊕ V = 0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 4,k
| BRLT k
| Verzweigen wenn kleiner als, vorzeichenbehaftet
| Wenn (N ⊕ V = 1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 4,k
| BRHS k
| Verzweigen wenn H-Carry Flag gesetzt ist
| Wenn (H=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 5,k
| BRHC k
| Verzweigen wenn H-Carry Flag gelöscht ist
| Wenn (H=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 5,k
| BRTS k
| Verzweigen wenn T-Flag gesetzt ist
| Wenn (T=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 6,k
| BRTC k
| Verzweigen wenn T-Flag gelöscht ist
| Wenn (T=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 6,k
| BRVS k
| Verzweigen wenn Overflow-Flag (V) gesetzt ist
| Wenn (V=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 3,k
| BRVC k
| Verzweigen wenn Overflow-Flag (V) gelöscht ist
| Wenn (V=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 3,k
| BRIE k
| Verzweigen wenn Interrupt freigegeben
| Wenn (I=1) dann PC ← PC + k + 1
| keines
| 1/2
| BRBS 7,k
| BRID k
| Verzweigen wenn Interrupt gesperrt
| Wenn (I=0) dann PC ← PC + k + 1
| keines
| 1/2
| BRBC 7,k
| |
| Mnemonik | Beschreibung | Funktion | Flags | T. | Kode/Emul. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| SBI A,b | Bit in I/O-Register setzen | [A+0x20] |= 1≪b | keines | 2 | 10011010 AAAAAbbb
| CBI A,b
| Bit in I/O-Register löschen
| [A+0x20] &=~ 1≪b
| keines
| 2
| 10011000 AAAAAbbb
| LSL Rd
| Logisches Linksschieben
| Rd(n+1) ← Rd(n), Rd(0) ← 0
| Z,C,N,V,H
| 1
| ADD Rd,Rd
| LSR Rd
| Logisches Rechtsschieben
| Rd(n) ← Rd(n+1), Rd(7) ← 0
| Z,C,N,V
| 1
| 1001010d dddd0110
| ROL Rd
| Links rotieren durch Carry
| Rd(0) ← C, Rd(n+1) ← Rd(n), C ← Rd(7)
| Z,C,N,V,H
| 1
| ADC Rd,Rd
| ROR Rd
| Rechts rotieren durch Carry
| Rd(7) ← C, Rd(n) ← Rd(n+1), C ← Rd(0)
| Z,C,N,V
| 1
| 1001010d dddd0111
| ASR Rd
| Arithmetisches Rechtsschieben
| Rd(n) ← Rd(n+1), n = 0...6
| Z,C,N,V
| 1
| 1001010d dddd0101
| SWAP Rd
| Nibbles vertauschen
| Rd(3..0) ← Rd (7..4), Rd(7..4) ← Rd(3..0)
| keines
| 1
| 1001010d dddd0010
| BSET s
| Flag im SREG setzen
| SREG(s) ← 1
| SREG(s)
| 1
| 10010100 0sss1000
| BCLR s
| Flag im SREG löschen
| SREG(s) ← 0
| SREG(s)
| 1
| 10010100 1sss1000
| BST Rr,b
| Bit von Register nach T speichern
| T ← Rr(b)
| T
| 1
| 1111101d dddd0bbb
| BLD Rd,b
| Bit von T nach Register laden
| Rd(b) ← T
| keines
| 1
| 1111100d dddd0bbb
| SEC
| Carry setzen
| C ← 1
| C
| 1
| BSET 0
| CLC
| Carry löschen
| C ← 0
| C
| 1
| BCLR 0
| SEZ
| Zero-Flag setzen
| Z ← 1
| Z
| 1
| BSET 1
| CLZ
| Zero-Flag löschen
| Z ← 0
| Z
| 1
| BCLR 1
| SEN
| Negativ-Flag N setzen
| N ← 1
| N
| 1
| BSET 2
| CLN
| Negativ-Flag N löschen
| N ← 0
| N
| 1
| BCLR 2
| SEV
| Zweierkomplement-Überlauf setzen
| V ← 1
| V
| 1
| BSET 3
| CLV
| Zweierkomplement-Overflow löschen
| V ← 0
| V
| 1
| BCLR 3
| SES
| Vorzeichen Test-Flag setzen
| S ← 1
| S
| 1
| BSET 4
| CLS
| Vorzeichen Test-Flag löschen
| S ← 0
| S
| 1
| BCLR 4
| SEH
| Half-Carry-Flag setzen
| H ← 1
| H
| 1
| BSET 5
| CLH
| Half-Carry-Flag löschen
| H ← 0
| H
| 1
| BCLR 5
| SET
| T setzen
| T ← 1
| T
| 1
| BSET 6
| CLT
| T löschen
| T ← 0
| T
| 1
| BCLR 6
| SEI
| Globale Interrupt-Freigabe
| I ← 1
| I
| 1
| BSET 7
| CLI
| Globale Interrupt-Sperre
| I ← 0
| I
| 1
| BCLR 7
| |