Instruction Pages

각 명령어는 다음과 같은 순으로 설명되어 있다. 명령어 이름: 어셈블러 니모닉과 영문 이름 예: ADC – ADD with Carry

■ 동작 개요:
명령어의 동작을 해설하고 실행과정에서 제약을 설명한다.

■  Register 데이터 이동 내역:



Register 전송 수준의 데이터 이동을 기술

예) Rd ← Rd + Rr + C 명령어 형식과 오퍼랚드 범위, Program Counter 변화 예)
형식, Operand 값의 범위, Program Counter: ADC Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
2 진 수로 기계어를 표현한다 Status Register(SREG) 불리언 값 변화를 Flag 별로 기술: H, S, V, N, Z,
C: 각각에 대한 변화내역을 기술한다. R (계산결과 값)의 위치를 설명한다.

■ 프로그램 예: 대표적인 명령어 사용 예를 제시 한다. 예)
; Add R1:R0 to  R3:R2
ADD R2,R0 ; Add low byte
ADC  R3,R1 ; Add with Carry high byte
■ 길이: 명령어의 길이를 바이트 단위로 나타낸다.
■ 소요 클럭 수: 명령어를 실행할 때 소요되는 시간을 클럭 수로 나타낸다.




ADC

– ADD with Carry

■ 동작 개요:
두 Register 에 저장된 데이터와 C Flag을 함께 더하여 그 결과를 Register Rd에 저장하기 긴 숫자를 더할 때 8bit 단위로 나누어 더하는 과정에 사용할 있음 하위 8 bit 부터 더하면서 Carry를 다음 상위 8 비트로 더하는 과정에 전달하는 것임

■  Register 데이터 이동 내역:
(i) Rd ← Rd + Rr + C
형식, Operand 값의 범위, Program Counter:
(i) ADC Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register(SREG) 불리언 값 변화:
H: Rd3•R R3+R R3• R3+ R3•Rd3 3에 Carry가 발생하면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트에 사용.
V: Rd7•Rr7•R7+Rd7•Rr7•R7 계산결과 2의 보수 Overflow 발생시 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴
N: R7 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4 • R3 • R2 • R1 •R0 결과 값이 $00 이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7•Rr7+Rr7•R7+R7•Rd7 계산결과 MSB에서 Carry가 발생하면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
; Add R1:R0 to  R3:R2
ADD R2,R0 ; Add low byte
ADC  R3,R1 ; Add with Carry high byte
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


ADD

– ADD without Carry

■ 동작 개요:
Carry Flag을 제외하고 두 Register 에 저장된 데이터를 더하여 Rd에 저장하기 가장 평범한 덧셈임

■  Register 데이터 이동 내역:
(i) Rd ← Rd + Rr
형식, Operand 값의 범위, Program Counter:
(i) ADD Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
H: Rd3•R R3+R R3• R3+ R3•Rd3 비트 3으로 부터 Carry가 있으면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7•Rr7•R7+Rd7•Rr7•R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4 • R3 • R2 • R1 •R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 •Rr7 +Rr7 •R7+ R7 •Rd7 계산결과 MSB에서 Carry가 있으면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
ADD R1 R2 ; Add R2 to R1 ( R1= R1+,R2)
ADD R28 R28 ; Add R28 to itself ( R28= R28+,R28)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


ADIW

– ADD Immediate to Word

■ 동작 개요:
즉치 (immediate value (0 - 63))을 Register 쌍에 더해서 그 결과를 그 Register 쌍에 저장한다. 이 명령은 상위 네개의 Register 에 실행된다. 이것은 포인터 Register 에 대한 동작으로 적당하다.

■  Register 데이터 이동 내역:
(i) Rd+1:Rd ← Rd+1:Rd + K
형식, Operand 값의 범위, Program Counter:
(i) ADIW Rd+1:Rd,K
d ∈ {24, 26, 28, 30}
0 ≤ K ≤ 63

PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: RdH7 • R15
2의 보수 계산결과 Overflow 발생 시 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
N: R15 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: R15 • RdH7 계산결과 MSB에서 Carry가 있으면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 RdH:RdL 와 같아짐 (RdH7-RdH0 = R15-R8,RdL7-RdL0=R7-R0).

■ 프로그램 예:
ADIW R25:R24, 1 ; Add 1 to R25:R24
ADIW ZH:ZL, 63 ; Add 63 to the Z-pointer( R31: R30)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2


AND

– Logical AND

■ 동작 개요:
Register Rd 와 Register Rr 간의 논리 AND 를 실행하고 그 결과를 목표 Register Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd • Rr
형식, Operand 값의 범위, Program Counter:
(i) AND Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6 •R5 •R4 • R3• R2 • R1 •R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
AND R2, R3 ; Bitwise And R2 AND  R3, result in R2
LDI R16, 1 ; SET bitmask 0000 0001 in R16
AND R2,R16 ; Isolate bit 0 in R2
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


ANDI

– Logical AND with Immediate

■ 동작 개요:
Register Rd 의 내용과 명령어에 포함된 상수를 AND 시켜서 그 결과를 Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd • K
형식, Operand 값의 범위, Program Counter:
(i) ANDI Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6• R5•R4 • R3• R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
ANDI R17,$0F ; Clear upper nibble of R17
ANDI R18,$10 ; Isolate bit 4 in R18
ANDI R19,$AA ; Clear odd bit of R19
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


ASR

– Arithmetic Shift Right

■ 동작 개요:
Rd 에 들어 있는 모든 비트를 한 자리씩 오른쪽으로 이동시킨다. Bit 7 은 제자리 복사되어 들어가고, bit 0는 Carry Flag로 들어간다. 이명령은 효과적으로 나누기 2와 동일하다. Carry Flag는 반올림하는 데 사용한다.

■  Register 데이터 이동 내역:
(i)
형식, Operand 값의 범위, Program Counter:
(i) ASR Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: N ⊕ C (쉬프트 후의 N 과 C)
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6 •R5• R4 • R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd0 쉬프트 전 Rd의 LSB가 'SET'되어 있으면 'SET'함; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
LDI R16,$10 ; Load decimal 16 into R16
ASR R16 ; R16= R16 / 2
LDI R17,$FC ; Load -4 in R17
ASR R17 ; R17= R17/2
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


BCLR

– Bit Clear in SREG

■ 동작 개요:
SREG에 포함된 한 Flag을 지움(clear).

■  Register 데이터 이동 내역:
(i) SREG(s) ← 0
형식, Operand 값의 범위, Program Counter:
(i) BCLR s
0 ≤ s ≤ 7

PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
I: 0 if s = 7; 그 외에는 변동 없음. T: 0 if s = 6; 그 외에는 변동 없음.
H: 0 if s = 5; 그 외에는 변동 없음.
S: 0 if s = 4; 그 외에는 변동 없음.
V: 0 if s = 3; 그 외에는 변동 없음.
N: 0 if s = 2; 그 외에는 변동 없음.
Z: 0 if s = 1; 그 외에는 변동 없음.
C: 0 if s = 0; 그 외에는 변동 없음.

■ 프로그램 예:
BCLR 0 ; Clear Carry Flag
BCLR 7 ; Disable Interrupt
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


BLD

– Bit Load from the T Flag in SREG to a Bit in Register

■ 동작 개요:
SREG (Status Register) 의 T Flag을 Register Rd의 비트 b에 복사함.

■  Register 데이터 이동 내역:
(i) Rd(b) ← T
형식, Operand 값의 범위, Program Counter:
(i) BLD Rd, b
0 ≤ d ≤ 31, 0 ≤ b ≤ 7
PC ← PC + 1

■  기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
; Copy bit
BST R1, 2 ; Store bit 2 of R1 in T Flag
BLD R0, 4 ; Load T Flag into bit 4 of R0
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


BRBC

– Branch if Bit in SREG is cleared

■ 동작 개요:
상대적 조건 분기 명령이다. SREG 의 한 비트를 테스트하여 그 비트가 0이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If SREG(s) = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRBC s,K
0 ≤ s ≤ 7
, (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1(조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CPI R20, 5 ; Compare R20 to the value 5
BRBC 1, noteq ; Branch if Zero Flag cleared
...
noteq: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRBS

– Branch if Bit in SREG is SET

■ 동작 개요:
상대적 조건 분기 명령이다. SREG 의 한 비트를 테스트하여 그 비트가 1이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If SREG(s) = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRBS s,K
0 ≤ s ≤ 7
, (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1, 조건이 안 맞는 경우

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BST R0, 3 ; Load T bit with bit 3 of R0
BRBS 6, bitet ; Branch T bit was SET
...
bitet: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRCC

– Branch if Carry cleared

■ 동작 개요:
상대적 조건 분기 명령이다. Carry Flag를 테스트하여 그 비트가 0이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If C = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRCC k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
ADD R22,R23 ; Add R23 to R22
BRCC noCarry ; Branch if Carry cleared
...
noCarry: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRCS

– Branch if Carry SET

■ 동작 개요:
상대적 조건 분기 명령이다. Carry Flag를 테스트하여 그 비트가 1이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If C = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRCS k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CPI R26,$56 ; Compare R26 with $56
BRCS Carry ; Branch if Carry SET
...
Carry: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BREAK

– BREAK

■ 동작 개요:
The BREAK 명령어는 시스템 디버그용으로 사용되고 응용프로그램에서는 잘 쓰지 않는다. 이 명령어가 실행되면 AVR CPU는 정지 모드로 들어가게 된다. 정지된 Status에서 디버깅 소프트웨어가 프로세서 내부를 들여다 보게 된다. 만약 Lock bit 가 'SET'되어 있거나 JTAGEN 이나 OCDEN 퓨즈가 프로그램 되어 있지 않으면 CPU 는 BREAK 명령을 NOP로 간주하고 정지 모드로 들어가지 않는다. 이 명령어가 모든 AVR Chip에 적용되지는 않으니 해당 Chip의 매뉴얼을 참고해야 한다.

■  Register 데이터 이동 내역:
(i) On-chip Debug system BREAK.
형식, Operand 값의 범위, Program Counter:
(i) BREAK
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


BREQ

– Branch if Equal

■ 동작 개요:
상대적 조건 분기 명령이다. Zero Flag를 테스트하여 그 비트가 1이면 PC 에 대하여 상대적인 주소로 분기한다. 이 명령어가 CP, CPI, SUB 또는 SUBI 등을 곧 이어 실행된 경우 Rd에 들어 있는 수와 Rr의 수가 같으면 분기가 일어난다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If Rd = Rr (Z = 1) then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BREQ k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CP R1,R0 ; Compare Register s R1 AND R0
BREQ equal ; Branch if Register s equal
...
equal: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRGE

– Branch if Greater or Equal (Signed)

■ 동작 개요:
상대적 조건 분기 명령이다. Signed Flag를 테스트하여 그 비트가 0 이면 PC 에 대하여 상대적인 주소로 분기한다. 이 명령어가 CP, CPI, SUB 또는 SUBI 등을 곧 이어 실행된 경우 Rd에 들어 있는 수가 Rr에 비하여 같거나 크면 분기가 일어난다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If Rd ≥ Rr (N ⊕ V = 0) then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRGE k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CP R11,R12 ; Compare Register s R11 AND R12
BRGE greateq ; Branch if R11 ≥ R12 (signed)
...
greateq: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRHC

– Branch if Half Carry Flag is Cleared

■ 동작 개요:
상대적 조건 분기 명령이다. Half Carry Flag(H)를 테스트하여 그 비트가 0이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If H = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRHC k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BRHC hclear ; Branch if Half Carry Flag cleared
...
hclear: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRHS

– Branch if Half Carry Flag is SET

■ 동작 개요:
상대적 조건 분기 명령이다. Half Carry Flag(H)를 테스트하여 그 비트가 1이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If H = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRHS k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BRHS hset ; Branch if Half Carry Flag SET
...
hset: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRID

– Branch if Global Interrupt is Disabled

■ 동작 개요:
상대적 조건 분기 명령이다. Global Interrupt Flag(I)를 테스트하여 그 비트가 0이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If I = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRID k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BRID intdis ; Branch if inteRrupt disabled
...
intdis: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRIE

– Branch if Global Interrupt is Enabled

■ 동작 개요:
상대적 조건 분기 명령이다. Global Interrupt Flag(I)를 테스트하여 그 비트가 1이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If I = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRIE k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BRIE inten ; Branch if inteRrupt enabled
...
inten: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRLO

– Branch if Lower (Unsigned)

■ 동작 개요:
상대적 조건 분기 명령이다. Carry Flag(C) 를 테스트하여 그 비트가 1 이면 PC 에 대하여 상대적인 주소로 분기한다. 이 명령어가 CP, CPI, SUB 또는 SUBI 등을 곧 이어 실행된 경우 Rd에 들어 있는 부호 없는 수가 Rr에 비하여 작으면 분기가 일어난다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If Rd < Rr (C = 1) then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRLO k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
EOR R19,R19 ; Clear R19
loop: INC R19 ; Increase R19
...
CPI R19,$10 ; Compare R19 with $10
BRLO loop ; Branch if R19 < $10 (unsigned)
NOP ; Exit from loop (do nothing)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRLT

– Branch if Less Than (Signed)

■ 동작 개요:
상대적 조건 분기 명령이다. Carry Flag(C) 를 테스트하여 그 비트가 1 이면 PC 에 대하여 상대적인 주소로 분기한다. 이 명령어가 CP, CPI, SUB 또는 SUBI 등을 곧 이어 실행된 경우 Rd에 들어 있는 부호 있는 수가 Rr에 비하여 작으면 분기가 일어난다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If Rd < Rr (N ⊕ V = 1) then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRLT k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CP R16,R1 ; Compare R16 to R1
BRLT less ; Branch if R16 < R1 (signed)
...
less: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRMI

– Branch if Minus

■ 동작 개요:
상대적 조건 분기 명령이다. Negative Flag(N) 를 테스트하여 그 비트가 1 이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If N = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRMI k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
SUBI R18, 4 ; Subtract 4 from R18
BRMI negative ; Branch if result negative
...
negative: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRNE

– Branch if Not Equal

■ 동작 개요:
상대적 조건 분기 명령이다. Zero Flag(Z) 를 테스트하여 그 비트가 0 이면 PC 에 대하여 상대적인 주소로 분기한다. 이 명령어가 CP, CPI, SUB 또는 SUBI 등을 곧 이어 실행된 경우 Rd에 들어 있는 부호 있는 수가 Rr가 서로 다르면 분기가 일어난다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If Rd ≠ Rr (Z = 0) then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRNE k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
EOR R27,R27 ; Clear R27
loop: INC R27 ; Increase R27
...
CPI R27,5 ; Compare R27 to 5
BRNE loop ; Branch if R27<>5
NOP ; Loop exit (do nothing)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRPL

– Branch if Plus

■ 동작 개요:
상대적 조건 분기 명령이다. Negative Flag(N) 를 테스트하여 그 비트가 0 이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If N = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRPL k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
SUBI R26,$50 ; Subtract $50 from R26
BRPL positive ; Branch if R26 positive
...
positive: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRSH

– Branch if Same or Higher (Unsigned)

■ 동작 개요:
상대적 조건 분기 명령이다. Carry Flag(C) 를 테스트하여 그 비트가 0 이면 PC 에 대하여 상대적인 주소로 분기한다. 이 명령어가 CP, CPI, SUB 또는 SUBI 등을 곧 이어 실행된 경우 Rd에 들어 있는 부호 있는 수가 Rr가 크거나 같으면 분기가 일어난다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If Rd ″컍 (C = 0) then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRSH k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
SUBI R19, 4 ; Subtract 4 from R19
BRSH highsm ; Branch if R19 >= 4 (unsigned)
...
highsm: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRTC

– Branch if the T Flag is Cleared

■ 동작 개요:
상대적 조건 분기 명령이다. T Flag(T) 를 테스트하여 그 비트가 0 이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If T = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRTC k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BST  R3, 5 ; Store bit 5 of  R3 in T Flag
BRTC tclear ; 지워지면 분기함
...
tclear: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRTS

– Branch if the T Flag is SET

■ 동작 개요:
상대적 조건 분기 명령이다. T Flag(T) 를 테스트하여 그 비트가 1 이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If T = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRTS k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
BST  R3, 5 ; Store bit 5 of  R3 in T Flag
BRTS tset ; Branch if this bit was SET
...
tset: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRVC

– Branch if Overflow Cleared

■ 동작 개요:
상대적 조건 분기 명령이다. Overflow Flag(V) 를 테스트하여 그 비트가 0 이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If V = 0 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRVC k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
ADD  R3,R4 ; Add R4 to  R3
BRVC noover ; Branch if no overflow
...
noover: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BRVS

– Branch if Overflow SET

■ 동작 개요:
상대적 조건 분기 명령이다. Overflow Flag(V) 를 테스트하여 그 비트가 1 이면 PC 에 대하여 상대적인 주소로 분기한다. PC에 들어 있는 주소를 중심으로 상대적으로 분기하는데 분기 주소의 범위는 (PC - 63 ≤ Effective Address ≤ PC + 64) 이다. 여기서 변수 k 는 PC로 부터 변위(2의 보수 표현)이다.

■  Register 데이터 이동 내역:
(i) If V = 1 then PC ← PC + k + 1,
else PC ← PC + 1
형식, Operand 값의 범위, Program Counter:
(i) BRVS k (-64 ≤ k ≤ +63)
PC ← PC + k + 1
PC ← PC + 1 (조건 불일치 시)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
ADD  R3,R4 ; Add R4 to  R3
BRVS overfl ; Branch if overflow
...
overfl: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시)
2 (조건 일치 시)


BSET

– Bit SET in SREG

■ 동작 개요:
SREG의 한 Flag를 'SET'시킨다.

■  Register 데이터 이동 내역:
(i) SREG(s) ← 1
형식, Operand 값의 범위, Program Counter:
(i) BSET s
0 ≤ s ≤ 7

PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
I: 1 if s = 7; 그 외에는 변동 없음. T: 1 if s = 6; 그 외에는 변동 없음.
H: 1 if s = 5; 그 외에는 변동 없음.
S: 1 if s = 4; 그 외에는 변동 없음.
V: 1 if s = 3; 그 외에는 변동 없음.
N: 1 if s = 2; 그 외에는 변동 없음.
Z: 1 if s = 1; 그 외에는 변동 없음.
C: 1 if s = 0; 그 외에는 변동 없음.

■ 프로그램 예:
BSET 6 ; SET T Flag
BSET 7 ; Enable inteRrupt
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


BST

– Bit Store from Bit in Register to T Flag in SREG

■ 동작 개요:
SREG의 T Flag에 Rd의 bit b를 저장함.

■  Register 데이터 이동 내역:
(i) T ← Rd(b)
형식, Operand 값의 범위, Program Counter:
(i) BST Rd, b
0 ≤ d ≤ 31, 0 ≤ b ≤ 7
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
T: 0 if bit b in Rd is 지워짐. SET to 1 otherwise.

■ 프로그램 예:
; Copy bit
BST R1, 2 ; Store bit 2 of R1 in T Flag
BLD R0, 4 ; Load T into bit 4 of R0
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CALL

– Long Call to a Subroutine

■ 동작 개요:
프로그램 메모리 어딘가의 서브루틴을 호출하는 명령어이다. 리턴 주소 (서브루틴 처리가 끝났을 때 처리하게 되는 명령어의 주소)는 스택에 저장한다. 스택 포인터는 저장되고 난 후에 하나 감소한다. 이 명령어는 모든 Chip에 적용되는 것은 아니다. 각 Chip에 따른 설명서를 참조하라.

■  Register 데이터 이동 내역:
(i)
PC ← k
Devices with 16bit PC, 128K bytes Program memory maximum.
(ii)
PC ← k
Devices with 22 bit PC, 8M bytes Program memory maximum.
형식, Operand 값의 범위, Program Counter Stack:
(i) CALL k 0 ≤ k < 64K
PC ← k STACK ← PC+2 SP ← SP-2, (2 bytes, 16 bit)
(ii) CALL k 0 ≤ k < 4M
PC ← k STACK ← PC+2 SP ← SP-3 (3 bytes, 22 bit) 32-bit 기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
MOV R16,R0 ; Copy R0 to R16
CALL check ; Call subroutine

...
check: CPI R16,$42 ; Check if R16 has a special value
BREQ ERROR ; Branch if equal
RET ; Return from subroutine
...
ERROR: RJMP ERROR ; Infinite loop
■ 길이 : 2(4 bytes)
■ 소요 클럭 수: 4,
Devices with 16bit PC 5,
Devices with 22 bit PC 소요 클럭 수 XMEGA: 3,
Devices with 16bit PC 4,
Devices with 22 bit PC


CBI

– Clear Bit in I/O Register

■ 동작 개요:
I/O Register 의 특정 비트를 0으로 Clear한다. 이 명령어는 하위 32 개 I/O Register 에 적용된다. I/ORegister 주소 0-31까지 이다.

■  Register 데이터 이동 내역:
(i) I/O(A, b) ← 0
형식, Operand 값의 범위, Program Counter:
(i) CBI A, b
0 ≤ A ≤ 31
0 ≤ b ≤ 7
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CBI $12, 7 ; Clear bit 7 in Port D


■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: 1


CBR

– Clear bit in Register

■ 동작 개요:
이 명령어는 Register Rd의 특정 비트를 0으로 바꾸어 준다. Register Rd의 내용과 상수 마스크 K의 역수와 AND 연산을 한다. 결과를 Register Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd • ($FF - K)
형식, Operand 값의 범위, Program Counter:
(i) CBR Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:
(비교참조 - ANDI with K complemented)

■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
CBR R16,$F0 ; Clear upper nibble of R16
CBR R18, 1 ; Clear bit 0 in R18
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLC

– Clear Carry Flag

■ 동작 개요:
SREG의 C Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) C ← 0
형식, Operand 값의 범위, Program Counter:
(i) CLC
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: 0 Carry Flag 지워짐

■ 프로그램 예:
ADD R0,R0 ; Add R0 to itself
CLC ; Clear Carry Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLH

– Clear Half Carry Flag

■ 동작 개요:
SREG의 H Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) H ← 0
형식, Operand 값의 범위, Program Counter:
(i) CLH
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
H: 0 Half Carry Flag 지워짐

■ 프로그램 예:
CLH ; Clear the Half Carry Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLI

– Clear Global Interrupt Flag

■ 동작 개요:
SREG의 I Flag를 0으로 Clear한다. 인터럽트 즉시 불능화 된다. CLI명령어가 실행되면 더 이상 인터럽트는 걸리지 않는다. CLI 동시에 걸려도 처리되지 않는다.

■  Register 데이터 이동 내역:
(i) I ← 0
형식, Operand 값의 범위, Program Counter:
(i) CLI
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
I: 0 Global Interrupt Flag 지워짐

■ 프로그램 예:
in temp, SREG ; Store SREG value (temp must be defined by user)
CLI ; Disable Interrupt during timed sequence
SBI EECR, EEMWE ; Start EEPROM write
SBI EECR, EEWE
OUT SREG, temp ; Restore SREG value (I-Flag)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLN

– Clear Negative Flag

■ 동작 개요:
SREG의 N Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) N ← 0

■ Syntax
: Operands: Program Counter:
(i) CLN
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
N: 0 Negative Flag 지워짐

■ 프로그램 예:
ADD R2, R3 ; Add  R3 to R2
CLN ; Clear Negative Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLR

– Clear Register

■ 동작 개요:
Register 에 0을 넣는다. 이 명령은 한 Register 에 들어 있는 데이터 자신의 데이터와 Exclusive- OR연산을 실행하여 그 결과를 그 자리에 저장한다. 모든 bit가 0dl 된다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd ⊕ Rd

■ Syntax
: Operands: Program Counter:
(i) CLR Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
(비교참조 - EOR Rd,Rd)

■ Status Register 변화:
S: 0 지워짐
V: 0 지워짐
N: 0 지워짐
Z: 1 SET R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
CLR R18 ; clear R18
loop: INC R18 ; increase R18
...
CPI R18,$50 ; Compare R18 to $50
BRNE loop
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLS

– Clear Signed Flag

■ 동작 개요:
SREG의 S Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) S ← 0

■ Syntax
: Operands: Program Counter:
(i) CLS
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: 0 Signed Flag 지워짐

■ 프로그램 예:
ADD R2, R3 ; Add  R3 to R2
CLS ; Clear Signed Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLT

– Clear T Flag

■ 동작 개요:
SREG의 T Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) T ← 0

■ Syntax
: Operands: Program Counter:
(i) CLT
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
T: 0 T Flag 지워짐

■ 프로그램 예:
CLT ; Clear T Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLV

– Clear Overflow Flag

■ 동작 개요:
SREG의 V Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) V ← 0

■ Syntax
: Operands: Program Counter:
(i) CLV
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
V: 0 Overflow Flag 지워짐

■ 프로그램 예:
ADD R2, R3 ; Add  R3 to R2
CLV ; Clear Overflow Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CLZ

– Clear Zero Flag

■ 동작 개요:
SREG의 Z Flag를 0으로 Clear한다.

■  Register 데이터 이동 내역:
(i) Z ← 0

■ Syntax
: Operands: Program Counter:
(i) CLZ
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
Z: 0 Zero Flag 지워짐

■ 프로그램 예:
ADD R2, R3 ; Add  R3 to R2
CLZ ; Clear zero
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


COM

– One’s Complement

■ 동작 개요:
Register Rd 의 내용에 1의 보수를 취한다.

■  Register 데이터 이동 내역:
(i) Rd ← $FF - Rd

■ Syntax
: Operands: Program Counter:
(i) COM Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V 부호 테스트.
V: 0 지워짐.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6• R5• R4 • R3 • R2• R1 •R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: 1 'SET' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
COM R4 ; Take one’s complement of R4
BREQ zero ; Branch if zero
...
zero:
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CP

– Compare

■ 동작 개요:
이 명령은 두 Register Rd 와 Rr을 비교한다. 아무 Register 내용도 변하지 않는다. 모든 조건 분기 명령이 이 명령어 뒤에 올 수 있다.

■  Register 데이터 이동 내역:
(i) Rd - Rr

■ Syntax
: Operands: Program Counter:
(i) CP Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
H: Rd3 •R R3+ R R3 • R3 + R3• Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7• Rr7 •R7+ Rd7 •Rr7 •R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4 • R3 • R2 • R1 •R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 •Rr7+ Rr7• R7 +R7• Rd7 SET if the absolute value of the contents of Rr is larger than the absolute value of Rd; 다른 모든 경우에는 'Clear' 시킴. R은 Register 데이터 이동 후의 결과.

■ 프로그램 예:
CP R4,R19 ; Compare R4 with R19
BRNE noteq ; Branch if R4 <> R19
...
noteq: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CPC

– Compare with Carry

■ 동작 개요:
이 명령은 두 Register Rd 와 Rr을 비교할 때 전번에 만들어 진 Carry 도 감안한다. 아무 Register 내용도 변하지 않는다. 모든 조건 분기 명령이 이 명령어 뒤에 올 수 있다.

■  Register 데이터 이동 내역:
(i) Rd - Rr - C
형식, Operand 값의 범위, Program Counter:
(i) CPC Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
0000 01rd dddd RrRr

■ Status Register 변화:
H: Rd3 •R R3+ R R3 • R3 + R3 •Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7 •Rr7• R7+ Rd7• Rr7 •R7 계산결과가 2의 보수 Overflow가 있으면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6• R5• R4 • R3 • R2 • R1• R0 •Z 결과가 0이면 이전 값이 변동 없음; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 •Rr7+ Rr7• R7 +R7 •Rd7 SET if the absolute value of the contents of Rr plus previous Carry is larger than the absolute value of Rd; 다른 모든 경우에는 'Clear' 시킴. R은 Register 데이터 이동 후의 결과.

■ 프로그램 예:
; Compare  R3:R2 with R1:R0
CP R2,R0 ; Compare low byte
CPC  R3,R1 ; Compare high byte
BRNE noteq ; Branch if not equal
...
noteq: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CPI

– Compare with Immediate

■ 동작 개요:
이 명령은 Register Rd 와 상수를 비교한다. Register 내용은 변하지 않는다. 모든 조건 분기 명령이 이 명령어 뒤에 올 수 있다.

■  Register 데이터 이동 내역:
(i) Rd - K

■ Syntax
: Operands: Program Counter:
(i) CPI Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
H: Rd3 •K3+ K3• R3+ R3 •Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7 •K7 •R7 +Rd7 •K7 •R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6• R5 •R4• R3• R2 • R1 •R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 •K7 +K7 •R7+ R7 •Rd7 K의 절대값이 Rd의 절대값보다 클 때 'SET' 됨; 다른 모든 경우에는 'Clear' 시킴. R은 Register 데이터 이동 후의 결과.

■ 프로그램 예:
CPI R19, 3 ; Compare R19 with 3
BRNE ERROR ; Branch if R19<>3
...
ERROR: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


CPSE

– Compare Skip if Equal

■ 동작 개요:
이 명령은 두 Register Rd 와 Rr을 비교한다. 아무 Register 내용도 변하지 않는다. Rd = Rr이면 다음 명령어는 실행하지 않고 건너 뛴다..

■  Register 데이터 이동 내역:
(i) If Rd = Rr then PC ← PC + 2 (or 3)
else PC ← PC + 1

■ Syntax
: Operands: Program Counter: CPSE Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1, Condition false - no skip
PC ← PC + 2, Skip a one word instruction
PC ← PC + 3, Skip a two word instruction

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
INC R4 ; Increase R4
CPSE R4,R0 ; Compare R4 to R0
NEG R4 ; Only executed if R4<>R0
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시) (no skip)
2 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 words


DEC

– Decrement

■ 동작 개요:
Register Rd 의 내용에서 하나를 뺀 다음 그 결과를 Register Rd에 저장한다. 이 연산으로 SREG의 CFlag는 영향을 받지 않는다. 다중 정밀도 계산에서 루프 카운터로 사용할 수 있다. 부호 없는 숫자에 대하여 연산할 때, BREQ 와 BRNE 만 일관성 있게 분기 한다. 부호 있는 숫자에 대한 연산일 경우 모든 부호 있는 분기가 가능하다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd - 1

■ Syntax
: Operands: Program Counter:
(i) DEC Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register 와 불리언 값 변화:
S: N ⊕ V 부호 테스트.
V: R7 •R6 •R5 •R4• R3• R2 • R1• R0 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴. Two’s complement overflow occurs if AND only if Rd was $80 before the Register 데이터 이동 내역.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6• R5 •R4• R3• R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
LDI R17,$10 ; Load constant in R17
loop: ADD R1,R2 ; Add R2 to R1
DEC R17 ; Decrement R17
BRNE loop ; Branch if R17<>0
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1

DES

– Data Encryption Standard

■ 동작 개요:
이 모듈은 AVR CPU의 확장 명령어 'SET'인데 DES 연산을 실행한다. 64-bit 데이터 블럭(평문이나 비밀문) 이 CPU Register 파일, Register s R0-R7에 저장한다. 여기서 데이터의 LSB는 R0의 LSB에 두고 데이터의 MSB는 R7의 MSB에 저장한다. 총l 64-bit key (parity bit 포함)은 Register R8- R15에 저장한다. 키의 LSB는 R8의 LSB에 두고 키의 MSB는 R15의 MSB에 저장한다. DES 명령은 한 라운드의 DES algorithm을 실행한다. 총 16 라운드를 실행해야 완전한 DES 비밀문이나 평문을 얻을 수 있다. 각 DES 명령어 실행의 중간 결과를 Register 파일 (R0- R15)에 저장한다. 명령어의 오퍼랚드 (K)는 어느 라운드를 실행하는 지를 결정한다. Half Carry flag (H)는 암호화인지 복호화 인지를 결정한다. DES algorithm은 "Specifications for the Data Encryption Standard" (Federal Information Processing Standards Publication 46)에 설명되어 있다. 이 실행과정에서 중간결과를 표준안과는 다르다. 왜냐하면 초기 퍼뮤테이션과 역 초기 퍼뮤테이션이 각 과정에 실행되기 때문이다. 이것은 최종 비밀문이나 평문에 영향을 미치지 않고 처리시간을 절약해 준다.

■  Register 데이터 이동 내역:
(i) If H = 0 then Encrypt round (R7-R0,R15-R8, K) If H = 1 then Decrypt round (R7-R0,R15-R8, K)

■ Syntax
: Operands: Program Counter:
(i) DES K 0x00≤K≤ 0x0F
PC ← PC + 1

■ 16-bit 기계어 형식:
■ 프로그램 예:
DES 0x00
DES 0x01
…
DES 0x0E
DES 0x0F
■ 길이: 1
■ 소요 클럭 수: 1 (2(1)) 참고사항
: DES 명령어가 비 DES 명령어가 계속되면 추가 사이클이 들어간이다.

EICALL

– Extended Indirect Call to Subroutine

■ 동작 개요:
Z (16 bit) Pointer Register 와 입출력 공간의 EIND Register 가 가리키는 간접 서브루틴 호출이다. 이 명령어는 전체 프로그램 메모리 공간 (4M words) 속 어딘가에 들어 있는 서브루틴을 호출한다. EICALL을 실행하는 동안 스택 포인터는 사후 증가된다. . 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) PC(15:0) ← Z(15:0)
PC(21:16) ← EIND

■ Syntax
: Operands: Program Counter: Stack:
(i) EICALL
STACK ← PC + 1 SP ← SP - 3 (3 bytes, 22 bit)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
LDI R16,$05 ; SET up EIND AND Z-pointer
OUT EIND,R16
LDI  R30,$00
LDI  R31,$10
EICALL ; Call to $051000


■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 4 (only implemented in
Devices with 22 bit PC) 소요 클럭 수 XMEGA: 3 (only implemented in
Devices with 22 bit PC)

EIJMP

– Extended Indirect Jump

■ 동작 개요:
Z (16 bit) Pointer Register 와 입출력 공간의 EIND Register 가 가리키는 주소로 간접 점프하는 명령어이다. 이 명령어는 전체 프로그램 메모리 공간 (4M words) 속 어딘가로 간접 점프한다. EICALL을 실행하는 동안 스택 포인터는 사후 증가된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) PC(15:0) ← Z(15:0)
PC(21:16) ← EIND

■ Syntax
: Operands: Program Counter: Stack:
(i) EIJMP
Not Affected

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
LDI R16,$05 ; SET up EIND AND Z-pointer
OUT EIND,R16
LDI  R30,$00
LDI  R31,$10
EIJMP ; Jump to $051000
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2

ELPM

– Extended Load Program Memory

■ 동작 개요:
Z-Register 와 I/O 공간의 RAMPZ Register 에 의하여 지정되는 한 바이트를 load하여 Register Rd에 두는 명령어이다. 이 명령어는 100% 공간 효율을 가지는 상수 초기화와 상수 데이터 페치를 가능하게 한다. 프로그램 메모리는 16-bit 길이로 되어 있으나 Z-pointer 는 한 바이트 주소이다. 따라서 Z-pointer의 LSB는 하위 바이트(ZLSB = 0)를 선택하거나 상위 바이트 (ZLSB = 1)를 선택한다. 이 명령어는 프로그램 메모리 공간전체를 주소 공간으로 잡는다. Z-pointer Register 는 연산결과 변치 않거나 하나 증가할 수 있다. RAMPZ 와 Z-pointer Register 를 이어 붙인 24비트 전체에 증가를 적용한다. Self-Programming 능력이 있는 Chip에서는 ELPM 명령어를 퓨즈를 읽거나 Lock 비트 값을 읽는데 사용한다. Chip의 동작에 관한 자세한 내용은 Chip에 딸린 문서를 보아야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. . ELPM R30, Z+ ELPM R31, Z+

■  Register 데이터 이동 내역:
Comment:
(i) R0 ← (RAMPZ:Z) RAMPZ:
Z: Unchanged, R0 implied destination Register
(ii) Rd ← (RAMPZ:Z) RAMPZ:
Z: Unchanged
(iii) Rd ← (RAMPZ:Z) (RAMPZ:Z) ← (RAMPZ:Z) + 1 RAMPZ:
Z: Post incremented

■ Syntax
: Operands: Program Counter:
(i) ELPM None, R0 implied
PC ← PC + 1
(ii) ELPM Rd, Z
0 ≤ d ≤ 31
PC ← PC + 1
(iii) ELPM Rd, Z+
0 ≤ d ≤ 31
PC ← PC + 1

■  기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
LDI ZL, byte3(Table_1<<1) ; Initialize Z-pointer
OUT RAMPZ, ZL
LDI ZH, byte2(Table_1<<1)
LDI ZL, byte1(Table_1<<1)
ELPM R16, Z+ ; Load constant from Program
; memory pointed to by RAMPZ:Z (Z
is  R31: R30)
...
Table_1:
.DW  0x3738 ; 0x38 is addressed when ZLSB = 0
; 0x37 is addressed when ZLSB = 1
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 3

ELPM

– Extended Load Program Memory

■ 동작 개요:
Z-Register 와 I/O 공간의 RAMPZ Register 에 의하여 지정되는 한 바이트를 load하여 Register Rd에 두는 명령어이다. 이 명령어는 100% 공간 효율을 가지는 상수 초기화와 상수 데이터 페치를 가능하게 한다. 프로그램 메모리는 16-bit 길이로 되어 있으나 Z-pointer 는 한 바이트 주소이다. 따라서 Zpointer의 LSB는 하위 바이트(ZLSB = 0)를 선택하거나 상위 바이트 (ZLSB = 1)를 선택한다. 이 명령어는 프로그램 메모리 공간전체를 주소 공간으로 잡는다. Z-pointer Register 는 연산결과 변치 않거나 하나 증가할 수 있다. RAMPZ 와 Z-pointer Register 를 이어 붙인 24비트 전체에 증가를 적용한다. Self-Programming 능력이 있는 Chip에서는 ELPM 명령어를 퓨즈를 읽거나 Lock 비트 값을 읽는데 사용한다. Chip의 동작에 관한 자세한 내용은 Chip에 딸린 문서를 보아야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. : ELPM R30, Z+ ELPM R31, Z+

■  Register 데이터 이동 내역:
Comment:
(i) R0 ← (RAMPZ:Z) RAMPZ:
Z: Unchanged, R0 implied destination Register
(ii) Rd ← (RAMPZ:Z) RAMPZ:
Z: Unchanged
(iii) Rd ← (RAMPZ:Z) (RAMPZ:Z) ← (RAMPZ:Z) + 1 RAMPZ:
Z: Post incremented

■ Syntax
: Operands: Program Counter:
(i) ELPM None, R0 implied
PC ← PC + 1
(ii) ELPM Rd, Z
0 ≤ d ≤ 31
PC ← PC + 1
(iii) ELPM Rd, Z+
0 ≤ d ≤ 31
PC ← PC + 1

■  기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
LDI ZL, byte3(Table_1<<1) ; Initialize Z-pointer
OUT RAMPZ, ZL
LDI ZH, byte2(Table_1<<1)
LDI ZL, byte1(Table_1<<1)
ELPM R16, Z+ ; Load constant from Program
; memory pointed to by RAMPZ:Z (Z is
 R31: R30)
...
Table_1:
.DW  0x3738 ; 0x38 is addressed when ZLSB = 0
; 0x37 is addressed when ZLSB = 1
...
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 3


EOR

– Exclusive OR

■ 동작 개요:
Register Rd 와 Register Rr 의 내용에 Exclusive-OR 연산하여 그 결과를 Register Rd 에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd ⊕ Rr

■ Syntax
: Operands: Program Counter:
(i) EOR Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6 •R5 •R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
EOR R4,R4 ; Clear R4
EOR R0,R22 ; Bitwise exclusive or between R0 AND R22
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1

FMUL

– Fractional Multiply Unsigned

■ 동작 개요:
이 명령어는 8-bit × 8-bit → 16-bit 부호 있는 곱셈과 결과를 한 비트 좌측으로 이동시킨다. (N.Q) 소수점 왼쪽에 N bit를 오른쪽에 Q bit를 가진 소수라고 하자. (N1.Q1) 과 (N2.Q2) 의
형식을 가진 두 수의 곱은 ((N1+N2).(Q1+Q2)) 형식이 된다. 싞호처리에서 형식 (1.7) 이 입력으로 널리 사용되며 출력은 (2.14) 형식의 곱이 된다. 곱의 상위 바이트가 일력과 같은
형식을 가지려면 좌측으로 이동이 필요하다. 좌로 이동이 요구된다. FMUL 명령어는 MUL과 같은 소요 클럭 수를 가지는 쉬프트 연산과 관렦된다 (1.7) 형식이 가장 널리 부호 있는 수와 같이 사용되는 형식이다. FMUL 은 부호 없는 수의 곱셈이다. 이 명령어는 (1.15)형식의 16bit 입력을 가지고 (1.31)형식의 결과를 내는 부호 있는 곱셈을 실행할 때 부분 곱을 계산하는데 유용하다. FMUL 연산결과를 (1.15) 형식의 수로 해석할 경우 2의 보수 Overflow가 발생할 가능성이 있다. 쉬프트 전에 곱셈에서 MSB를 Carry에서 찾아낼 수도 있게 된다. 다음 예를 보기 바란다. 곱하여지는 수 Rd 와 곱하는 수 Rr 는 부호 없는 소수들이다. 여기서 소수점은 bit 6 과 bit 7 사이에 있다. 그 결과 16-bit 부호 없는 소수의 곱은 소수점이 잠정적으로 bit 14 와 bit 15 사이에 있게 된다. 이들은 R1 (high byte) 과 R0 (low byte)에 저장 되는 것이다. 0x80 (-1) 과 0x80 (-1)을 곱할 때, 곱에 대한 쉬프트의 결과를 0x8000 (-1)이 된다. 즉 2의 보수 Overflow가 발생한 것이다. 이런 경우는 소프트웨어로 체크하여 처리해야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) R1:R0 ← Rd × Rr (unsigned (1.15) ← unsigned (1.7) × unsigned (1.7))

■ Syntax
: Operands: Program Counter:
(i) FMUL Rd,Rr 16 ≤ d ≤ 23, 16≤ r ≤ 23
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: R16 SET if bit 15 of the result before left shift is SET; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 R1,R0 와 같아짐.

■ 프로그램 예:
;* 동작 개요
;*Signed fractional multiply of two 16-bit numbers with 32-bit result.
;* USAGE
;* R19:R18:R17:R16 = ( R23:R22 * R21:R20 ) << 1
;---------------------------------------------------------------
fmuls16x16_32:
CLR		 R2
FMULS	 R23,R21;((signed)ah * (signed)bh) << 1
MOVW	 R19:R18,R1:R0
FMUL	 R22,R20;(al * bl) << 1
ADC		 R18,R2
movwR	17:R16,R1:R0
FMULSU	 R23,R20;((signed)ah * bl) << 1
SBC	   R19,R2
ADD    R17,R0
ADC    R18,R1
ADC    R19,R2
FMULSU	 R21,R22;((signed)bh * al) << 1
SBC    R19,R2
ADD    R17,R0
ADC    R18,R1
ADC    R19,R2
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2

FMULS

– Fractional Multiply Signed

■ 동작 개요:
이 명령어는 8-bit × 8-bit → 16-bit 부호 있는 곱셈과 결과를 한 비트 좌측으로 이동시킨다. (N.Q) 소수점 왼쪽에 N bit를 오른쪽에 Q bit를 가진 소수라고 하자. (N1.Q1) 과 (N2.Q2) 의
형식을 가진 두 수의 곱은 ((N1+N2).(Q1+Q2)) 형식이 된다. 싞호처리에서 형식 (1.7) 이 입력으로 널리 사용되며 출력은 (2.14) 형식의 곱이 된다. 곱의 상위 바이트가 입력과 같은
형식을 가지려면 좌측으로 이동이 필요하다. FMUL 명령어는 MUL과 같은 소요 클럭 수를 가지는 쉬프트 연산과 관렦된다 FMUL 연산결과를 (1.15) 형식의 수로 해석할 경우 2의 보수 Overflow가 발생할 가능성이 있다. 쉬프트 전에 곱셈에서 MSB를 Carry에서 찾아낼 수도 있게 된다. 다음 예를 보기 바란다. 곱하여지는 수 Rd 와 곱하는 수 Rr 는 부호 없는 소수들이다. 여기서 소수점은 bit 6 과 bit 7 사이에 있다. 그 결과 16-bit 부호 없는 소수의 곱은 소수점이 잠정적으로 bit 14 와 bit 15 사이에 있게 된다. 이들은 R1 (high byte) 과 R0 (low byte)에 저장 되는 것이다. 0x80 (-1) 과 0x80 (-1)을 곱할 때, 곱에 대한 쉬프트의 결과를 0x8000 (-1)이 된다. 즉 2의 보수 Overflow가 발생한 것이다. 이런 경우는 소프트웨어로 체크하여 처리해야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. .

■  Register 데이터 이동 내역:
(i) R1:R0 ← Rd × Rr (signed (1.15) ← signed (1.7) × signed (1.7))

■ Syntax
: Operands: Program Counter:
(i) FMULS Rd,Rr 16 ≤ d ≤ 23, 16≤ r ≤ 23
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: R16 SET if bit 15 of the result before left shift is SET; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 R1,R0 와 같아짐.

■ 프로그램 예:
FMULS R23,R22 ; Multiply signed R23 AND R22 in (1.7) format, 
; result in (1.15) format
MOVW R23:R22,R1:R0 ; Copy result back in R23:R22
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2

FMULSU

– Fractional Multiply Signed with Unsigned

■ 동작 개요:
이 명령어는 8-bit × 8-bit → 16-bit 부호 있는 곱셈과 결과를 한 비트 좌측으로 이동시킨다. (N.Q) 소수점 왼쪽에 N bit를 오른쪽에 Q bit를 가진 소수라고 하자. (N1.Q1) 과 (N2.Q2) 의
형식을 가진 두 수의 곱은 ((N1+N2).(Q1+Q2)) 형식이 된다. 싞호처리에서 형식 (1.7) 이 입력으로 널리 사용되며 출력은 (2.14) 형식의 곱이 된다. 곱의 상위 바이트가 입력과 같은
형식을 가지려면 좌측으로 이동이 필요하다. FMULSU 명령어는 MUL과 같은 소요 클럭 수를 가지는 쉬프트 연산과 관렦된다 (1.7) 형식이 가장 널리 부호 있는 수와 같이 사용되는 형식이다. FMULSU는 부호 없는 수와 부호 있는 수 입력의 곱셈이다. 이 명령어는 (1.15)형식의 16bit 입력을 가지고 (1.31)형식의 결과를 내는 부호 있는 곱셈을 실행할 때 부분 곱을 계산하는데 유용하다. FMULSU 연산결과를 (1.15) 형식의 수로 해석할 경우 2의 보수 Overflow가 발생할 가능성이 있다. 쉬프트 전에 곱셈에서 MSB를 Carry에서 찾아낼 수도 있게 된다. 다음 예를 보기 바란다. 곱하여지는 수 Rd 와 곱하는 수 Rr 는 부호 없는 소수들이다. 여기서 소수점은 bit 6 과 bit 7 사이에 있다. 그 결과 16-bit 부호 없는 소수의 곱은 소수점이 잠정적으로 bit 14 와 bit 15 사이에 있게 된다. 이들은 R1 (high byte) 과 R0 (low byte)에 저장 되는 것이다. 0x80 (-1) 과 0x80 (-1)을 곱할 때, 곱에 대한 쉬프트의 결과를 0x8000 (-1)이 된다. 즉 2의 보수 Overflow가 발생한 것이다. 이런 경우는 소프트웨어로 체크하여 처리해야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) R1:R0 ← Rd × Rr (signed (1.15) ← signed (1.7) × unsigned (1.7))

■ Syntax
: Operands: Program Counter:
(i) FMULSU Rd,Rr 16 ≤ d ≤ 23, 16≤ r ≤ 23
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: R16 좌로 이동 전 bit 15 가 1 이면 'SET' 시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 R1,R0 와 같아짐.

■ 프로그램 예:
;---------------------------------------------------------------
;* 동작 개요
;*Signed fractional multiply of two 16-bit numbers with 32-bit result.
;* USAGE
;* R19:R18:R17:R16 = ( R23:R22 * R21:R20 ) << 1
;---------------------------------------------------------------
fmuls16x16_32:
clR R2
fmuls R23,R21;((signed)ah * (signed)bh) << 1
movw R19:R18,R1:R0
fmul R22,R20;(al * bl) << 1
adc R18,R2
movw R17:R16,R1:R0
fmulsu R23,R20;((signed)ah * bl) << 1
sbc R19,R2
add R17,R0
adc R18,R1
adc R19,R2
FMULSU R21,R22;((signed)bh * al) << 1
sbc R19,R2
add R17,R0
adc R18,R1
adc R19,R2
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2


ICALL

– Indirect Call to Subroutine

■ 동작 개요:
4M (길이)의 프로그램 메모리 어딘 가에 있을 서브루틴을 호출한다. 리턴 주소(서브루틴 처리가 끝나면 다시 실행해야 할 명령어의 주소) 는 스택에 보관한다. 스택 포인터는 CALL 처리과정에서 하나 증가된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) PC(15:0) ← Z(15:0)
Device with 16 bit PC, 128K bytes Program memory maximum.
(ii) PC(15:0) ← Z(15:0)
Device with 22 bit PC, 8M bytes Program memory maximum.
PC(21:16) ← 0

■ Syntax
: Operands: Program Counter: Stack:
(i) ICALL
STACK ← PC + 1 SP ← SP - 2 (2 bytes, 16 bit)
(ii) ICALL
STACK ← PC + 1 SP ← SP - 3 (3 bytes, 22 bit)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
MOV  R30,R0 ; SET offset to call table
ICALL ; Call routine pointed to by Z


■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 3,
Devices with 16bit PC 4,
Devices with 22 bit PC 소요 클럭 수 XMEGA: 2,
Devices with 16 bit PC 3,
Devices with 22 bit PC


IJMP

– Indirect Jump

■ 동작 개요:
Z (16 bit) Pointer Register 가 가리키는 간접 점프 명령어이다. 이 명령어는 프로그램 메모리의 하위 64K 길이 (128Kbytes) 부분 안에서 점프를 허용한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i)
PC ← Z(15:0)
Device with 16 bit PC, 128K bytes Program memory maximum.
(ii) PC(15:0) ← Z(15:0)
Device with 22 bit PC, 8M bytes Program memory maximum.
PC(21:16) ← 0

■ Syntax
: Operands: Program Counter: Stack:
(i), (ii) IJMP
Not Affected

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
MOV  R30,R0 ; SET offset to jump table
IJMP ; Jump to routine pointed to by Z
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2


IN

– Load an I/O Location to Register

■ 동작 개요:
I/O 공간 (Ports, Timers, Configuration Register 등) 의 데이터를 Register Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← I/O(A)

■ Syntax
: Operands: Program Counter:
(i) IN Rd, A
0 ≤ d ≤ 31, 0 ≤ A ≤ 63
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
in R25,$16 ; Read Port B
CPI R25,4  ; Compare read value to constant
BREQ exit ; Branch if R25=4
...
exit: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


INC

– Increment

■ 동작 개요:
Register Rd를서 하나를 더한 다음 그 결과를 Register Rd에 저장한다. 이 연산으로 SREG의 CFlag는 영향을 받지 않는다. 다중 정밀도 계산에서 루프 카운터로 사용할 수 있다. 부호 없는 숫자에 대하여 연산할 때, BREQ 와 BRNE 만 일관성 있게 분기 한다. 부호 있는 숫자에 대한 연산일 경우 모든 부호 있는 분기가 가능하다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd + 1

■ Syntax
: Operands: Program Counter:
(i) INC Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register and 불리언 값 변화:
S: N ⊕ V 부호 테스트.
V: R7 •R6 •R5 •R4 • R3• R2 • R1 •R0 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴. 계산 전에 Rd 가 $7F 일 때 만 2의 보수 Overflow 발생 .
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7 •R6 •R5 •R4• R3 • R2• R1• R0 결과 값이 $00이면 SET 되고 그렇지 않으면 Clear됨 R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
CLR R22 ; clear R22
loop: INC R22 ; increment R22
...
CPI R22,$4F ; Compare R22 to $4f
BRNE loop ; Branch if not equal
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1

JMP

– Jump

■ 동작 개요:
4M 길이의 프로그램 메모리 공간 안의 주소로 점프를 실행하는 명령어이다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i)
PC ← k

■ Syntax
: Operands: Program Counter: Stack:
(i) JMP k 0 ≤ k < 4M
PC ← k Unchanged 32-bit 기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
MOV R1,R0 ; Copy R0 to R1
JMP farplc ; Unconditional jump
...
farplc: NOP ; Jump destination (do nothing)
■ 길이: 2 (4 bytes)
■ 소요 클럭 수: 3

LD

– Load Indirect from Data Space to Register using Index X

■ 동작 개요:
간접 주소지정 방식으로 데이터 공간에서 한 바이트를 Register 에 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 데이터의 위치는 Register 파일에 들어 있는 X (16 bit) 포인터 Register 가 지정한다. 메모리 접근은 현 64K의 데이터 세그먼트에 국한된다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPX를 변경해야 한다. 이 연산으로 X-포인터 Register 는 변경되지 않거나 또는 사전 증가 또는 사후 감소될 수 있다. 이런 기능들은 특별히 어레이, 테이블을 접근하거나 X 포인터를 스택 포인터로 사용하는데 유용하다. 데이터 공간의 크기가 256 바이트 보다 크지 않으면 X 포인터의 하위 바이트 만 변경된다. 그런 경우 상위 바이트는 이 명령어에서 사용되지 않으므로 다른 용도로 사용할 수 있다. 입출력 지역의 RAMPX Register 는 64K 이상의 데이터 공간이나 64K 이상의 프로그램 메모리를 가진 Chip에서 변경되고 전체 24비트 주소가 증가 또는 감소된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. LD R26,X+ LD R27,X+ LD R26,-X LD R27,-X Using the X-pointer:

■  Register 데이터 이동 내역:
Comment:
(i) Rd ← (X) X: Unchanged
(ii) Rd ← (X) X ← X + 1 X: Post incremented
(iii) X ← X - 1 Rd ← (X) X: Pre decremented

■ Syntax
: Operands: Program Counter:
(i) LD Rd,X
0 ≤ d ≤ 31
PC ← PC + 1
(ii) LD Rd,X+
0 ≤ d ≤ 31
PC ← PC + 1
(iii) LD Rd,-X
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
(i) 1001 000d dddd 1100
(ii) 1001 000d dddd 1101
(iii) 1001 000d dddd 1110

■ Status Register 변화:
■ 프로그램 예:
CLR R27 ; Clear X high byte
LDI R26,$60 ; SET X low byte to $60
LD R0,X+ ; Load R0 with data space loc. $60(X post INC)
LD R1,X ; Load R1 with data space loc. $61
LDI R26,$63 ; SET X low byte to $63
LD R2,X ; Load R2 with data space loc. $63
LD  R3, –X ; Load  R3 with data space loc. $62(X pre DEC)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA:
(i) 1(1)
(ii) 1(1)
(iii) 2(1) 참고사항
: 1. IF the LD instruction is accessing internal SRAM, one extra cycle is inserted.

LD (LDD)

– Load Indirect from Data Space to Register using Index Y

■ 동작 개요:
간접 주소 지정방식으로 변위를 반영하거나 또는 변위 없이 데이터 공간에서 한 바이트의 데이터를 Register 에 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 데이터의 위치는 Register 파일에 들어 있는 Y (16 bit) 포인터 Register 가 지정한다. 메모리 접근은 현 64K의 데이터 세그먼트에 국한된다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPY를 변경해야 한다. 이 연산으로 Y-포인터 Register 는 변경되지 않거나 또는 사전 증가 또는 사후 감소될 수 있다. 이런 기능들은 특별히 어레이, 테이블을 접근하거나 Y 포인터를 스택 포인터로 사용하는데 유용하다. 데이터 공간의 크기가 256 바이트 보다 크지 않으면 Y 포인터의 하위 바이트 만 변경된다. 그런 경우 상위 바이트는 이 명령어에서 사용되지 않으므로 다른 용도로 사용할 수 있다. 입출력 지역의 RAMPY Register 는 64K 이상의 데이터 공간이나 64K 이상의 프로그램 메모리를 가진 Chip에서 변경되고 전체 24비트 주소가 증가 또는 감소된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. . LD R28,Y+ LD R29,Y+ LD R28,-Y LD R29,-Y Using the Y-pointer:

■  Register 데이터 이동 내역:
Comment:
(i) Rd ← (Y) Y: Unchanged
(ii) Rd ← (Y) Y ← Y + 1 Y: Post incremented
(iii) Y ← Y - 1 Rd ← (Y) Y: Pre decremented
(iv) Rd ← (Y+q) Y: Unchanged, q: Displacement

■ Syntax
: Operands: Program Counter:
(i) LD Rd, Y
0 ≤ d ≤ 31
PC ← PC + 1
(ii) LD Rd,Y+
0 ≤ d ≤ 31
PC ← PC + 1
(iii) LD Rd,-Y
0 ≤ d ≤ 31
PC ← PC + 1
(iv) LDD Rd,Y+q
0 ≤ d ≤ 31, 0 ≤ q ≤ 63
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CLR R29 ; Clear Y high byte
LDI R28,$60 ; SET Y low byte to $60
LD R0,Y+ ; Load R0 with data space loc. $60(Y post INC)
LD R1,Y ; Load R1 with data space loc. $61
LDI R28,$63 ; SET Y low byte to $63
LD R2,Y ; Load R2 with data space loc. $63
LD  R3,-Y ; Load  R3 with data space loc. $62(Y pre DEC)
LDD R4,Y+2 ; Load R4 with data space loc. $64
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: (i) 1(1)
(ii) 1(1)
(iii) 2(1)
(iv) 2(1) 참고사항
: 1. IF the LD instruction is accessing internal SRAM, one extra cycle is inserted.

LD (LDD)

– Load Indirect from Data Space to Register using Index Z

■ 동작 개요:
변위를 반영하거나 또는 변위 없이 간접 주소지정 방식으로 데이터 공간에서 한 바이트의 데이터를 Register 에 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 데이터의 위치는 Register 파일에 들어 있는 Z (16 bit) 포인터 Register 가 지정한다. 메모리 접근은 현 64K의 데이터 세그먼트에 국한된다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPZ를 변경해야 한다. 이 연산으로 Z-포인터 Register 는 변경되지 않거나 또는 사전 증가 또는 사후 감소될 수 있다. 이런 기능들은 특별히 어레이, 테이블을 접근하거나 Z 포인터를 스택 포인터로 사용하는데 유용하다. 데이터 공간의 크기가 256 바이트 보다 크지 않으면 Z 포인터의 하위 바이트 만 변경된다. 그런 경우 상위 바이트는 이 명령어에서 사용되지 않으므로 다른 용도로 사용할 수 있다. 입출력 지역의 RAMPZ Register 는 64K 이상의 데이터 공간이나 64K 이상의 프로그램 메모리를 가진 Chip에서 변경되고 전체 24비트 주소가 증가 또는 감소된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. LD R30, Z+ LD R31, Z+ LD R30, -Z LD R31, -Z Using the Z-pointer:

■  Register 데이터 이동 내역:
Comment:
(i) Rd ← (Z)
Z: Unchanged
(ii) Rd ← (Z) Z ← Z + 1
Z: Post increment
(iii) Z ← Z -1 Rd ← (Z)
Z: Pre decrement
(iv) Rd ← (Z+q)
Z: Unchanged, q: Displacement

■ Syntax
: Operands: Program Counter:
(i) LD Rd, Z
0 ≤ d ≤ 31
PC ← PC + 1
(ii) LD Rd, Z+
0 ≤ d ≤ 31
PC ← PC + 1
(iii) LD Rd, -Z
0 ≤ d ≤ 31
PC ← PC + 1
(iv) LDD Rd, Z+q
0 ≤ d ≤ 31, 0 ≤ q ≤ 63
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CLR  R31 ; Clear Z high byte
LDI  R30,$60 ; SET Z low byte to $60
LD R0,Z+ ; Load R0 with data space loc. $60(Z post INC)
LD R1,Z ; Load R1 with data space loc. $61
LDI  R30,$63 ; SET Z low byte to $63
LD R2,Z ; Load R2 with data space loc. $63
LD  R3,-Z ; Load  R3 with data space loc. $62(Z pre DEC)
LDD R4,Z+2 ; Load R4 with data space loc. $64
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: (i) 1(1)
(ii) 1(1)
(iii) 2(1)
(iv) 2(1) 참고사항
: 1. IF the LD instruction is accessing internal SRAM, one extra cycle is inserted.


LDI

– Load Immediate

■ 동작 개요:
명령어에 포함된 8비트 상수를 Register R16 부터 Register R31까지 직접 저장.

■  Register 데이터 이동 내역:
(i) Rd ← K

■ Syntax
: Operands: Program Counter:
(i) LDI Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CLR  R31 ; Clear Z high byte
LDI  R30,$F0 ; SET Z low byte to $F0
LPM ; Load constant from Program
; memory pointed to by Z
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


LDS

– Load Direct from Data Space

■ 동작 개요:
데이터 공간에서 한 바이트의 데이터를 Register 에 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 16 bit 주소가 필요하다. 메모리 접근은 현 64Kbytes 데이터 세그먼트에 국한된다. 64Kbytes 이상의 메모리를 접근하려면 RAMPDRegister 를 사용한다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPD를 변경해야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) Rd ← (k)

■ Syntax
: Operands: Program Counter:
(i) LDS Rd,K
0 ≤ d ≤ 31, 0 ≤ k ≤ 65535
PC ← PC + 2 32-bit 기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
LDS R2,$FF00 ; Load R2 with the contents of data space location $FF00
ADD R2,R1 ; Add R1 to R2
STS $FF00 R2 ; Write back
■ 길이: 2 (4 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: 2(1) 참고사항
: 1. IF the LDS instruction is accessing internal SRAM, one extra cycle is inserted.

LPM

– Load Program Memory

■ 동작 개요:
Z-Register 가 지정하는 한 바이트를 Register Rd에 담는다. 이 명령어는 공간을 효과적으로 활용하는 상수 초기화나 상수 데이터 페치에 사용된다. 프로그램 메모리는 16bit의 길이를 갖지만 Z-포인터는 바이트 단위 주소를 지정한다. 따라서 Z-pointer의 LSB는 하위 바이트나 (ZLSB = 0) 상위 바이트를 (ZLSB = 1) 선택한다. 이 명령어는 첫 64K bytes (32K 길이) 의 프로그램 메모리의 주소를 지정한다. Z-pointer Register 는 이 연산 후에 변경되지 않거나 증가 될 수 있다. 이 증가는 RAMPZ Register 에는 해당 없다. 자체 프로그램 기능이 있는 Chip의 경우 LPM 명령은 Fuse 와 Lock bit 값을 읽는데 사용된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. LPM R30, Z+ LPM R31, Z+

■  Register 데이터 이동 내역:
Comment:
(i) R0 ← (Z)
Z: Unchanged, R0 implied destination Register
(ii) Rd ← (Z)
Z: Unchanged
(iii) Rd ← (Z) Z ← Z + 1
Z: Post incremented

■ Syntax
: Operands: Program Counter:
(i) LPM None, R0 implied
PC ← PC + 1
(ii) LPM Rd, Z
0 ≤ d ≤ 31
PC ← PC + 1
(iii) LPM Rd, Z+
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
LDI ZH, High(Table_1<<1) ; Initialize Z-pointer
LDI ZL, Low (Table_1<<1)
LPM R16, Z ; Load constant from Program
; Memory pointed to by Z ( R31: R30)
...
Table_1:
.DW  0x5876 ; 0x76 is addresses when ZLSB = 0
; 0x58 is addresses when ZLSB = 1
...
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 3


LSL

– Logical Shift Left

■ 동작 개요:
Rd 의 모든 bit를 한자리씩 왼쪽으로 이동시킨다. . Bit 0 은 0 값이 들어오고 Bit 7 은 SREG의 Carry 에 들어 간이다. 이 연산은 부호 있는 수나 부호 없는 수를 두 배로 만든다.

■  Register 데이터 이동 내역:
(i)

■ Syntax
: Operands: Program Counter:
(i) LSL Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
(비교참조 - ADD Rd,Rd)

■ Status Register 변화:
H: Rd3
S: N ⊕ V, 부호 테스트.
V: N ⊕ C (For N AND C after the shift)
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 SET if, before the shift, the MSB of Rd was SET; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
ADD R0,R4 ; Add R4 to R0
LSL R0 ; Multiply R0 by 2
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


LSR

– Logical Shift Right

■ 동작 개요:
Rd 의 모든 bit를 한자리씩 왼쪽으로 이동시킨다. . Bit 7 은 0 값이 들어오고 Bit 0 은 SREG의 Carry 에 들어 간이다. 이 연산은 부호 있는 수나 부호 없는 수를 반으로 나눈다. C Flag는 반올림에 사용된다.

■  Register 데이터 이동 내역:
■ Syntax
: Operands: Program Counter:
(i) LSR Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: N ⊕ C (For N AND C after the shift)
N: 0
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd0 SET if, before the shift, the LSB of Rd was SET; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
ADD R0,R4 ; Add R4 to R0
LSR R0 ; Divide R0 by 2
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


MOV

– Copy Register

■ 동작 개요:
이 명령어는 한 Register 의 내용을 다른 Register 에 복사한다. Source Register Rr 은 변하지 않는다. Register Rd 는 Rr을 복사한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rr

■ Syntax
: Operands: Program Counter:
(i) MOV Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
MOV R16,R0 ; Copy R0 to R16
CALL check ; Call subroutine
...
check: CPI R16,$11 ; Compare R16 to $11
...
RET ; Return from subroutine
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1

MOVW

– Copy Register Word

■ 동작 개요:
Dl 명령어는 한 Register 쌍의 내용을 다른 Register 쌍에 복사한다. Source Register 쌍 Rr+1:Rr은 변하지 않는다. 다른 Register 쌍 Rd+1:Rd 은 Rr + 1:Rr을 복사한다. 이 명령어는 모든 Chip에 적용되지는 않는다. 각 Chip 별 설명서를 참조하라.

■  Register 데이터 이동 내역:
(i) Rd+1:Rd ← Rr+1:Rr

■ Syntax
: Operands: Program Counter:
(i) MOVW Rd+1:Rd,Rr+1Rr
d ∈ {0, 2, ..., 30}, r ∈ {0, 2, ..., 30}
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
MOVW R17:16,R1:R0 ; Copy R1:R0 to R17:R16
CALL check ; Call subroutine
...
check: CPI R16,$11 ; Compare R16 to $11
...
CPI R17,$32 ; Compare R17 to $32
...
RET ; Return from subroutine
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1

MUL

– Multiply Unsigned

■ 동작 개요:
이 명령어는 8-bit × 8-bit → 16-bit 부호 없는 곱셈을 한다. 곱하여 지는 변수 Register Rd 와 곱하는 변수 Register Rr 은 부호 없는 수를 담고 있다. 16- bit 부호 없는 곱은 R1 (high byte) 과 R0 (low byte)에 저장한다. 만약 곱하여 지는 수와 곱하는 수를 R0 또는 R1에서 가져오면 이들 Register 의 내용은 곱셈 후에 곱의 일부가 된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) R1:R0 ← Rd × Rr (unsigned ← unsigned × unsigned)
형식, Operand 값의 범위, Program Counter:
(i) MUL Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: R15 계산 결과의 비트 15가 'SET'되어 있으면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 R1,R0 와 같아짐.

■ 프로그램 예:
MUL R5,R4 ; Multiply unsigned R5 AND R4
MOVW R4,R0 ; Copy result back in R5:R4
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2

MULS

– Multiply Signed

■ 동작 개요:
이 명령어는 8-bit × 8-bit → 16-bit 부호 있는 곱셈을 한다. 곱하여 지는 변수 Register Rd 와 곱하는 변수 Register Rr 은 부호 있는 수를 담고 있다. 16- bit 부호 있는 곱은 R1 (high byte) 과 R0 (low byte)에 저장한다. 만약 곱하여 지는 수와 곱하는 수를 R0 또는 R1에서 가져오면 이들 Register 의 내용은 곱셈 후에 곱의 일부가 된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) R1:R0 ← Rd × Rr (signed ← signed × signed)

■ Syntax
: Operands: Program Counter:
(i) MULS Rd,Rr
16 ≤ d ≤ 31[ AL ... Z ]
16 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: R15 계산 결과의 비트 15가 'SET'되어 있으면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 R1,R0 와 같아짐.

■ 프로그램 예:
MULS R21,R20 ; Multiply signed R21 AND R20
MOVW R20,R0 ; Copy result back in R21:R20
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2

MULSU

– Multiply Signed with Unsigned

■ 동작 개요:
이 명령어는 8-bit × 8-bit → 16-bit 부호 있는 수와 부호 없는 수의 곱셈을 한다. 곱하여 지는 변수 Register Rd 와 곱하는 변수 Register Rr 은 부호 없는 수를 담고 있다. 곱하여 지는 수는 부호가 있고 곱하는 수는 부호가 없다. 16-bit 부호 있는 곱은 R1 (high byte) 과 R0 (low byte)에 저장한다. 만약 곱하여 지는 수와 곱하는 수를 R0 또는 R1에서 가져오면 이들 Register 의 내용은 곱셈 후에 곱의 일부가 된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) R1:R0 ← Rd × Rr (signed ← signed × unsigned)

■ Syntax
: Operands: Program Counter:
(i) MULSU Rd,Rr 16 ≤ d ≤ 23, 16 ≤ r ≤ 23
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: R15 계산 결과의 비트 15가 'SET'되어 있으면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
Z: R15 • R14 • R13 • R12 • R11 • R10 •R9 •R8 •R7• R6• R5• R4• R3• R2 • R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 계산 후 R1,R0 와 같아짐.

■ 프로그램 예:
;---------------------------------------------------------------
;* 동작 개요
;*Signed multiply of two 16-bit numbers with 32-bit result.
;* USAGE
;* R19:R18:R17:R16 = R23:R22 * R21:R20
;---------------------------------------------------------------
muls16x16_32:
CLR	 R2
MULS	 R23,R21; (signed)ah * (signed)bh
MOVW	 R19:R18,R1:R0
MUL		 R22,R20; al * bl
MOVW	 R17:R16,R1:R0
MULSU	 R23,R20; (signed)ah * bl
SBC	 R19,R2
ADD	 R17,R0
ADC	 R18,R1
ADC	 R19,R2
MULSU	 R21,R22; (signed)bh * al
SBC	 R19,R2
ADD	 R17,R0
ADC	 R18,R1
ADC	 R19,R2
RET
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2;******************************************************************************


NEG

– Two’s Complement

■ 동작 개요:
Register Rd 의 내용을 2 의 보수 형식으로 부호를 바꾸는 것이다. 값 $80 은 변치 않는다.

■  Register 데이터 이동 내역:
(i) Rd ← $00 - Rd

■ Syntax
: Operands: Program Counter:
(i) NEG Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
H: R3 + Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V 부호 테스트.
V: R7• R6 •R5• R4• R3 • R2• R1• R0 SET if there is a two’s complement overflow from the implied subtraction from zero; 다른 모든 경우에는 'Clear' 시킴. A two’s complement overflow will occur if AND only if the contents of the Register after Register 데이터 이동 내역 (Result) is $80.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: R7 + R6 + R5 + R4 + R3 + R2 + R1 + R0 SET if there is a boRrow in the implied subtraction from zero; 다른 모든 경우에는 'Clear' 시킴. The C Flag will be SET in all cases except when the contents of Register after Register 데이터 이동 내역 is $00. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
SUB R11,R0 ; Subtract R0 from R11
BRPL positive ; Branch if result positive
NEG R11 ; Take two’s complement of R11
positive: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


NOP

– No Operation

■ 동작 개요:
아무런 실행 내역 없이 한 사이클의 시간을 보내는 명령어이다.

■  Register 데이터 이동 내역:
(i) No

■ Syntax
: Operands: Program Counter:
(i) NOP
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CLR R16 ; Clear R16
SER R17 ; SET R17
OUT $18,R16 ; Write zeros to Port B
NOP 
OUT $18,R17 ; Write ones to Port B
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


OR

– Logical OR

■ 동작 개요:
Register Rd 와 Register Rr를 OR 연산을 한 다음 그 결과를 Register Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd v Rr

■ Syntax
: Operands: Program Counter:
(i) OR Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
or R15,R16 ; Do bitwise or between Register s
BST R15, 6 ; Store bit 6 of R15 in T Flag
BRTS ok ; Branch if T Flag SET
...
ok: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


ORI

– Logical OR with Immediate

■ 동작 개요:
Register Rd 와 상수에 대하여 OR 연산을 한 다음 그 결과를 Register Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd v K

■ Syntax
: Operands: Program Counter:
(i) ORI Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
ORI R16,$F0 ; SET high nibble of R16
ORI R17, 1 ; SET bit 0 of R17
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


OUT

– Store Register to I/O Location

■ 동작 개요:
Register Rr 의 데이터를 I/O 공간 (Ports, Timers, Configuration Register 등.)에 저장한다.

■  Register 데이터 이동 내역:
(i) I/O(A) ← Rr

■ Syntax
: Operands: Program Counter:
(i) OUT A,Rr 0 ≤ r ≤ 31, 0 ≤ A ≤ 63
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CLR R16 ; Clear R16
SER R17 ; SET R17
OUT $18,R16 ; Write zeros to Port B
NOP 
OUT $18,R17 ; Write ones to Port B
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


POP

– POP Register from Stack

■ 동작 개요:
이 명령어는 스택에 들어 있는 데이터 한 바이트를 꺼내어 Register Rd에 저장한다. 스택 포인트는 꺼내기 전에 미리 하나 증가한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) Rd ← STACK

■ Syntax
: Operands: Program Counter: Stack:
(i) POP Rd
0 ≤ d ≤ 31
PC ← PC + 1 SP ← SP + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CALL routine ; Call subroutine
...
routine: PUSH R14 ; Save R14 on the Stack
PUSH R13 ; Save R13 on the Stack
...
POP R13 ; Restore R13
POP R14 ; Restore R14
RET ; Return from subroutine
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2


PUSH

– PUSH Register on Stack

■ 동작 개요:
이 명령어는 레제스터 Rr에 들어 있는 데이터 한 바이트를 스택에 저장한다. 스택 포인트는 저장한 후에 하나 감소한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) STACK ← Rr

■ Syntax
: Operands: Program Counter: Stack:
(i) PUSH Rr 0 ≤ r ≤ 31
PC ← PC + 1 SP ← SP - 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CALL routine ; Call subroutine
...
routine: PUSH R14 ; Save R14 on the Stack
PUSH R13 ; Save R13 on the Stack
...
POP R13 ; Restore R13
POP R14 ; Restore R14
RET ; Return from subroutine
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: 1


RCALL

– Relative Call to Subroutine

■ 동작 개요:
Relative call to an address within PC - 2K + 1 AND PC + 2K (길이). The return address (the instruction after the RCALL) is stored onto the Stack. See also CALL. For AVR Microcontroller with Program memory not exceeding 4K 길이 (8K bytes) this instruction can address the entire memory from every address location. The Stack Pointer uses a post-decrement scheme during RCALL.

■  Register 데이터 이동 내역:
(i)
PC ← PC + k + 1
Devices with 16 bit PC, 128K bytes Program memory maximum.
(ii)
PC ← PC + k + 1
Devices with 22 bit PC, 8M bytes Program memory maximum.

■ Syntax
: Operands: Program Counter: Stack:
(i) RCALL k
-2K ≤ k < 2K
PC ← PC + k + 1 STACK ← PC + 1 SP ← SP - 2 (2 bytes, 16 bit)
(ii) RCALL k
-2K ≤ k < 2K
PC ← PC + k + 1 STACK ← PC + 1 SP ← SP - 3 (3 bytes, 22 bit)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
RCALL routine ; Call subroutine
...
routine: PUSH R14 ; Save R14 on the Stack
...
POP R14 ; Restore R14
RET ; Return from subroutine
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 3,
Devices with 16 bit PC 4,
Devices with 22 bit PC 소요 클럭 수 XMEGA: 2,
Devices with 16 bit PC 3,
Devices with 22 bit PC


RET

– Return from Subroutine

■ 동작 개요:
서브루틴으로 부터 빠져 나오는 명령어이다. 귀한 주소는 스택으로  부터 찾아 온다. 스택 포인터는 미리 하나 증가한다.

■  Register 데이터 이동 내역:
(i) PC(15:0) ← STACK
Devices with 16 bit PC, 128K bytes Program memory maximum.
(ii) PC(21:0) ← STACK
Devices with 22 bit PC, 8M bytes Program memory maximum.

■ Syntax
: Operands: Program Counter: Stack:
(i) RET
SP←SP + 2, (2bytes, 16 bit)
(ii) RET
SP←SP + 3, (3bytes, 22 bit)

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CALL routine ; Call subroutine
...
routine: PUSH R14 ; Save R14 on the Stack
...
POP R14 ; Restore R14
RET ; Return from subroutine
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 4
Devices with 16-bit PC 5

22-bit PC


RETI

– Return from Interrupt

■ 동작 개요:
인터럽트로 부터 빠져 나오는 명령어이다. 리턴주소는 스택으로 부터 찾아오고, SREG의 Global Interrupt Flag (I)가 1로 된다.. Status Register 의 내용은 인터럽트가 걸려도 자동적으로 저장되거나 인터럽트에서 빠져 나올 떄도 자동적으로 복원되지 않는다. 응용 프로그램에서 MSREGM의 저장과 복원을 별도로 해주어야 한다. 스택포인터는 RETI가 실행될 때 미리 하나 감소한다.

■  Register 데이터 이동 내역:
(i) PC(15:0) ← STACK

Devices with 16 bit PC, 128K bytes Program memory maximum.
(ii) PC(21:0) ← STACK

Devices with 22 bit PC, 8M bytes Program memory maximum.

■ Syntax
: Operands: Program Counter: Stack
(i) RETI
None
SP ← SP + 2 (2 bytes, 16 bit)
(ii) RETI

SP ← SP + 3 (3 bytes, 22 bit)

■ 16-bit 기계어 형식:
■ Status Register 변화:
I: 1 The I Flag is SET.

■ 프로그램 예:
...
extint: PUSH R0 ; Save R0 on the Stack
...
POP R0 ; Restore R0
RETI ; Return AND enable Interrupt
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 4
Devices with 16-bit PC 5

22-bit PC


RJMP

– Relative Jump

■ 동작 개요:

PC - 2K +1  부터 PC + 2K 사이의 주소로 상대적인 점프를 실행하는 명령어이다. 프로그램 메모리 공간이 4K를 초과하지 않는 AVR Microcontroller에서 전체 주소공간이 점프대상 주소가 된다.

■  Register 데이터 이동 내역:
(i)
PC ← PC + k + 1

■ Syntax
: Operands: Program Counter: Stack
(i) RJMP k
-2K ≤ k < 2K
PC ← PC + k + 1 Unchanged

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CPI R16,$42 ; Compare R16 to $42
BRNE ERROR ; Branch if R16 <> $42
RJMP ok ; Unconditional branch
ERROR: ADD R16,R17 ; Add R17 to R16
INC R16 ; Increment R16
ok: NOP ; Destination for RJMP (do nothing)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2


ROL

– Rotate Left trough Carry

■ 동작 개요:
Rd 의 모든 bit를 한자리씩 왼쪽으로 이동시킨다. C Flag는 Bit 0 에 들어오고 Bit 7 은 SREG의 Carry 에 들어 간이다. 이 연산은 부호 있는 수나 부호 없는 수를 두 배로 만든다.

■  Register 데이터 이동 내역:
■ Syntax
: Operands: Program Counter:
(i) ROL Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
(비교참조 - ADC Rd,Rd)

■ Status Register 변화:
H: Rd3
S: N ⊕ V, 부호 테스트.
V: N ⊕ C (For N AND C after the shift)
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 SET if, before the shift, the MSB of Rd was SET; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
LSL R18 ; Multiply R19:R18 by two
ROL R19 ; R19:R18 is a signed or unsigned two-byte
integer
BRCS oneenc ; Branch if Carry SET
...
oneenc: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


ROR

– Rotate Right through Carry

■ 동작 개요:
Rd 의 모든 bit를 한자리씩 오른쪽으로 이동시킨다. C Flag는 Bit 7 에 들어오고 Bit 0 는 SREG의 Carry 에 들어 간이다. 이 연산은 ASR 과 결합하여 부호 있는 수나 부호 없는 수를 둘로 나눈다. Carry는 반올림에 사용된다.

■  Register 데이터 이동 내역:
■ Syntax
: Operands: Program Counter:
(i) ROR Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: N ⊕ C (For N AND C after the shift)
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd0 SET if, before the shift, the LSB of Rd was SET; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
LSR R19 ; Divide R19:R18 by two
ROR R18 ; R19:R18 is an unsigned two-byte integer
BRCC zeroenc1 ; Branch if Carry 지워짐
ASR R17 ; Divide R17:R16 by two
ROR R16 ; R17:R16 is a signed two-byte integer
BRCC zeroenc2 ; Branch if Carry 지워짐
...
zeroenc1: 
...
zeroenc1: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SBC

– Subtract with Carry

■ 동작 개요:
두 Register 간의 뺄셈을 할 때 Carry Flag 비트도 함께 빼는 계산이다. 결과를 Rd Register 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd - Rr - C

■ Syntax
: Operands: Program Counter:
(i) SBC Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register and 불리언 값 변화:
H: Rd3• R R3 + R R3• R3 + R3 •Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7 •Rr7• R7 +Rd7 •Rr7 •R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0• Z 계산 값이 0이면 이전 값이 변동없음; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 •Rr7+ Rr7 •R7 +R7 •Rd7 SET if the absolute value of the contents of Rr plus previous Carry is larger than the absolute value of the Rd; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
; Subtract R1:R0 from  R3:R2
SUB R2,R0 ; Subtract low byte
SBC  R3,R1 ; Subtract with Carry high byte
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SBCI

– Subtract Immediate with Carry

■ 동작 개요:
Register 값에서 상수를 뺄 때 Carry Flag 비트도 함께 빼는 계산이다. 결과를 Rd Register 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd - K - C

■ Syntax
: Operands: Program Counter:
(i) SBCI Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register and 불리언 값 변화:
H: Rd3• K3 + K3• R3 + R3 •Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7 •K7• R7 +Rd7 •K7 •R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0• Z 계산 값이 0이면 이전 값이 변동없음; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7 •K7+ K7 • R7 +R7 •Rd7 상수의 절대값과 전 Carry의 합이 Rd의 절대값보다 크면 'SET' 됨; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
; Subtract $4F23 from R17:R16
SUBI R16,$23 ; Subtract low byte
SBCI R17,$4F ; Subtract with Carry high byte
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SBI

– SET Bit in I/O Register

■ 동작 개요:
I/O Register 의 특정 bit에 1 을 저장하는 것이다. 이 명령어는 하위 32 개 I/O Register 에 실행된다. I/O 주소 는 0-31 이다.

■  Register 데이터 이동 내역:
(i) I/O(A, b) ← 1

■ Syntax
: Operands: Program Counter:
(i) SBI A, b
0 ≤ A ≤ 31
0 ≤ b ≤ 7
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
OUT $1E,R0 ; Write EEPROM address
SBI $1C, 0 ; SET read bit in EECR
in R1,$1D ; Read EEPROM data
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: 1


SBIC

– Skip if Bit in I/O Register is Cleared

■ 동작 개요:
입출력 Register 의 한 비트를 테스트 하여 그 비트가 0 이면 다음 명령어를 실행하지 않고 건너 뛴다. 이 명령어는 하위 32 개 I/O Register 에 실행된다. I/O 주소 는 0-31 이다.

■  Register 데이터 이동 내역:
(i) If I/O(A, b) = 0 then PC ← PC + 2 (or 3)
else PC ← PC + 1

■ Syntax
: Operands: Program Counter:
(i) SBIC A, b
0 ≤ A ≤ 31
0 ≤ b ≤ 7
PC ← PC + 1, Condition false - no skip
PC ← PC + 2, Skip a one word instruction
PC ← PC + 3, Skip a two word instruction

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
e2wait: SBIC $1C, 1 ; Skip next inst. if EEWE 지워짐
RJMP e2wait ; EEPROM write not finished
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시) (no skip)
2 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 길이 소요 클럭 수 XMEGA:
2 (조건 불일치 시) (no skip) 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 4 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 길이


SBIS

– Skip if Bit in I/O Register is SET

■ 동작 개요:
입출력 Register 의 한 비트를 테스트 하여 그 비트가 1 이면 다음 명령어를 실행하지 않고 건너 뛴다. 이 명령어는 하위 32 개 I/O Register 에 실행된다. I/O 주소 는 0-31 이다.

■  Register 데이터 이동 내역:
(i) If I/O(A, b) = 1 then PC ← PC + 2 (or 3)
else PC ← PC + 1

■ Syntax
: Operands: Program Counter:
(i) SBIS A, b
0 ≤ A ≤ 31
0 ≤ b ≤ 7
PC ← PC + 1, Condition false - no skip
PC ← PC + 2, Skip a one word instruction
PC ← PC + 3, Skip a two word instruction

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
waitset: SBIS $10, 0 ; Skip next inst. if bit 0 in Port D SET
RJMP waitset ; Bit not SET
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시) (no skip)
2 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 길이 소요 클럭 수 XMEGA:
2 (조건 불일치 시) (no skip) 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 4 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 길이


SBIW

– Subtract Immediate from Word

■ 동작 개요:
Register 쌍의 값에서 상수(0-63)를 빼고 그 결과를 Register 쌍에 저장한다. 이 연산은 상위 네 쌍의 Register 에 실향된다. 이 연산은 포인터 Register 에 대한 연산으로 적합하다. 이 연산은 모든 Chip에 다 적용되는 것은 아니다. Chip마다 부수되는 문서를 참조하라. .

■  Register 데이터 이동 내역:
(i) Rd+1:Rd ← Rd+1:Rd - K

■ Syntax
: Operands: Program Counter:
(i) SBIW Rd+1:Rd,K
d ∈ {24, 26, 28, 30}
0 ≤ K ≤ 63

PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: RdH7 • R15 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R15 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R15• R14 • R13 • R12 • R11• R10• R9• R8• R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: R15• RdH7 K의 절대값이 Rd의 절대값 보다 크면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴. R (Result)은 R오와 같아짐: (RdH7-RdH0 = R15-R8,RdL7-RdL0=R7-R0).

■ 프로그램 예:
SBIW R25:R24, 1 ; Subtract 1 from R25:R24
SBIW YH:YL, 63 ; Subtract 63 from the Y-pointer( R29:R28)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2


SBR

– SET bit in Register

■ 동작 개요:
Register Rd의 특정 비트를 1로 만든다. Register Rd 와 상수 mask K 간에 ORI 연산을 실행한다. 그 결과를 Register Rd에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd v K

■ Syntax
: Operands: Program Counter:
(i) BR Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
SBR R16, 3 ; SET bit 0 AND 1 in R16
SBR R17,$F0 ; SET 4 MSB in R17
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SBRC

– Skip if Bit in Register is Cleared

■ 동작 개요:
Register 의 한 비트를 테스트 하여 그 비트가 0 이면 다음 명령어를 실행하지 않고 건너 뛴다.

■  Register 데이터 이동 내역:
(i) If Rr(b) = 0 then PC ← PC + 2 (or 3)
else PC ← PC + 1

■ Syntax
: Operands: Program Counter:
(i) SBRC Rr
b 0 ≤ r ≤ 31
0 ≤ b ≤ 7
PC ← PC + 1, Condition false - no skip
PC ← PC + 2, Skip a one word instruction
PC ← PC + 3, Skip a two word instruction

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
SUB R0,R1 ; Subtract R1 from R0
SBRC R0, 7 ; Skip if bit 7 in R0 지워짐
SUB R0,R1 ; Only executed if bit 7 in R0 not 지워짐
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시) (no skip)
2 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 words


SBRS

– Skip if Bit in Register is SET

■ 동작 개요:
Register 의 한 비트를 테스트 하여 그 비트가 1 이면 다음 명령어를 실행하지 않고 건너 뛴다.

■  Register 데이터 이동 내역:
(i) If Rr(b) = 1 then PC ← PC + 2 (or 3)
else PC ← PC + 1

■ Syntax
: Operands: Program Counter:
(i) SBRS Rr
b 0 ≤ r ≤ 31
0 ≤ b ≤ 7
PC ← PC + 1, Condition false - no skip
PC ← PC + 2, Skip a one word instruction
PC ← PC + 3, Skip a two word instruction

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
SUB R0,R1 ; Subtract R1 from R0
SBRS R0, 7 ; Skip if bit 7 in R0 SET
NEG R0 ; Only executed if bit 7 in R0 not SET
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1 (조건 불일치 시) (no skip)
2 (조건 일치 시)
(skip is executed) and the instruction skipped is 1 word 3 (조건 일치 시)
(skip is executed) and the instruction skipped is 2 words


SEC

– SET Carry Flag

■ 동작 개요:
SREG의 C Flag를 1로 세트한다.

■  Register 데이터 이동 내역:
(i) C ← 1

■ Syntax
: Operands: Program Counter:
(i) SEC
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
C: 1 Carry Flag SET

■ 프로그램 예:
SEC ; SET Carry Flag
ADC R0,R1 ; R0=R0+ R1+1
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SEH

– SET Half Carry Flag

■ 동작 개요:
SREG의 H Flag를 1로 세트한다.

■  Register 데이터 이동 내역:
(i) H ← 1

■ Syntax
: Operands: Program Counter:
(i) SEH
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
H: 1 Half Carry Flag SET

■ 프로그램 예:
SEH ; SET Half Carry Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SEI

– SET Global Interrupt Flag

■ 동작 개요:
SREG의 I Flag를 1로 세트한다. Dl 명령어 바로 다음 명령은 기다리고 있는 인터럽트가 있더라도 곧 바로 실행된다.

■  Register 데이터 이동 내역:
(i) I ← 1

■ Syntax
: Operands: Program Counter:
(i) SEI
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
I: 1 Global Interrupt Flag SET

■ 프로그램 예:
SEI ; SET global inteRrupt enable
SLEEP ; enter SLEEP, waiting for inteRrupt
; note: will enter SLEEP before any pending inteRrupt(s)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SEN

– SET Negative Flag

■ 동작 개요:
SREG의 N Flag를 1로 세트한다.

■  Register 데이터 이동 내역:
(i) N ← 1

■ Syntax
: Operands: Program Counter:
(i) SEN
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
N: 1 Negative Flag SET

■ 프로그램 예:
ADD R2,R19 ; Add R19 to R2
SEN ; SET Negative Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SER

– SET all bit in Register

■ 동작 개요:
$FF 를 Register Rd에 직접 집어 넣는다.

■  Register 데이터 이동 내역:
(i) Rd ← $FF

■ Syntax
: Operands: Program Counter:
(i) SER Rd
16 ≤ d ≤ 31[ AL ... Z ]
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
CLR R16 ; Clear R16
SER R17 ; SET R17
OUT $18,R16 ; Write zeros to Port B
NOP ; Delay (do nothing)
OUT $18,R17 ; Write ones to Port B
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SES

– SET Signed Flag

■ 동작 개요:
SREG의 S Flag를 1로 세트한다.

■  Register 데이터 이동 내역:
(i) S ← 1

■ Syntax
: Operands: Program Counter:
(i) SES
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
S: 1 Signed Flag SET

■ 프로그램 예:
ADD R2,R19 ; Add R19 to R2
SES ; SET Negative Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SET

– SET T Flag

■ 동작 개요:
SREG의 T Flag를 1로 세트한다.

■  Register 데이터 이동 내역:
(i) T ← 1

■ Syntax
: Operands: Program Counter:
(i) SET
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
T: 1 T Flag SET

■ 프로그램 예:
SET ; SET T Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SEV

– SET Overflow Flag

■ 동작 개요:
SREG의 V Flag를 1로 Set한다.

■  Register 데이터 이동 내역:
(i) V ← 1

■ Syntax
: Operands: Program Counter:
(i) SEV
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
V: 1 Overflow Flag 'SET' 됨

■ 프로그램 예:
ADD R2,R19 ; Add R19 to R2
SEV ; SET Overflow Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SEZ

– SET Zero Flag

■ 동작 개요:
SREG의 Z Flag를 1로 세트한다.

■  Register 데이터 이동 내역:
(i) Z ← 1

■ Syntax
: Operands: Program Counter:
(i) SEZ
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
Z: 1 Zero Flag SET

■ 프로그램 예:
ADD R2,R19 ; Add R19 to R2
SEZ ; SET Zero Flag
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SLEEP



■ 동작 개요:
이 명령어는 MCU 컨트롤 Register 가 정의한 수면 모드로 들어 가도록 한다.

■  Register 데이터 이동 내역:
자세한 SLEEP 모드 사용법에 관하여 소자 별 설명서를 참조하기 바란다.

■ Syntax
: Operands: Program Counter: SLEEP
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
MOV R0,R11 ; Copy R11 to R0
LDI R16, (1<<SE) ; Enable SLEEP mode
OUT MCUCR,R16
SLEEP ; Put MCU in SLEEP mode
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1

SPM

– Store Program Memory

■ 동작 개요:
SPM 명령어는 세가지 용도로 사용된다: 프로그램 메모리 안에서 한 페이지를 지울 때, 이미 지워진 곳에 새로운 페이지를 쓸 때, 그리고 Boot Loader Lock bit를 'SET' 시킬 때이다. 어떤 Chip에서는 프로그램메모리에 한번에 한 바이트씩 만 슬 수 있다. 다른 메모리에서는 임시 버퍼를 채우고 난 후에 프로그램 메모리에 페이지 단위로 쓸 수 있다. 이 모든 경우에 프로그램 메모리는 페이지 단위로 지워야 한다. 프로그램 메모리를 지울 때 RAMPZ 와 Z-Register 가 페이지 또는 워드 주소로 사용되고 R1:R0 Register 쌍이 데이터로 사용된다(1). Boot Loader Lock bit를 'SET' 할 때는 R1:R0 Register 쌍이 데이터로 사용된다. 이 명령어는 프로그램 메모리 전체에 적용된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. 참고사항
: 1. R1 은 명령어의 상위 바이트를 결정하고 R0 는 명령어의 하위 바이트를 결정한다.

■  Register 데이터 이동 내역:
Comment:
(i) (RAMPZ:Z) ← $ffff Erase Program memory page
(ii) (RAMPZ:Z) ← R1:R0 Write Program memory word
(iii) (RAMPZ:Z) ← R1:R0 Write temporary page buffer
(iv) (RAMPZ:Z) ← TEMP Write temporary page buffer to Program memory (v) BLbit ← R1:R0 SET Boot Loader Lock bit

■ Syntax
: Operands: Program Counter:
(i)-(v) SPM Z+
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
; This program shows SPM write of one page for 

page write ;- the routine writes one page of data from RAM to Flash ; the first data location in RAM is pointed to by the Y-pointer ; the first data location in Flash is pointed to by the Z-pointer ;- ERROR handling is not included ;- the routine must be placed inside the boot space ; (at least the do_spm SUB routine) ;- Register s used: R0,R1, temp1, temp2, looplo, loophi, spmcrval ; (temp1, temp2, looplo, loophi, spmcrval must be defined by the user) ; storing AND restoring of Register s is not included in the routine ; Register usage can be optimized at the expense of code size .EQU PAGESIZEB = PAGESIZE*2 ; PAGESIZEB is page size in BYTES, not Words .ORG SMALLBOOTSTART write_page: ; Page Erase LD ispmcrval, (1<<PGERS) + (1<<SPMEN) CALL do_spm ; Transfer Data from RAM to Flash Page Buffer LDI looplo, Low (PAGESIZEB) ; Init loop variable LDI loophi, High(PAGESIZEB) ; Not required for PAGESIZEB<=256 wrloop: LD R0, Y+ LD R1, Y+ LD ispmcrval, (1<<SPMEN) CALL do_spm ADIW ZH:ZL, 2 SBIW loophi:looplo, 2 ; Use SUBI for PAGESIZEB<=256 BRNE wrloop ; execute page write SUBI ZL, Low (PAGESIZEB) ; Restore pointer SBCI ZH, High(PAGESIZEB) ; Not required for PAGESIZEB<=256 LDI spmcrval, (1<<PGWRT) + (1<<SPMEN) CALL do_spm ; read back AND check, optional LDI looplo, Low (PAGESIZEB) ; Init loop variable LDI loophi, High(PAGESIZEB) ; Not required for PAGESIZEB<=256 SUBI YL, Low (PAGESIZEB) ; Restore pointer SBCI YH, High(PAGESIZEB) RdLoop: LPM R0, Z+ LD R1, Y+ CPSE R0,R1 JMP ERROR SBIW loophi:looplo, 2 ; Use SUBI for PAGESIZEB<=256 BRNE RdLoop RET do_spm: ; Input: SPMCRval determines SPM action ; Disable Interrupt if enabled, store status IN temp2, SREG CLI ; Check for previous SPM Complete wAIT: IN temp1, SPMCR SBRC temp1, SPMEN RJMP wait ; SPM Timed Sequence OUT SPMCR, spmcrval SPM ; Restore SREG (to enable Interrupt if originally enabled) OUT SREG, TEMP2 RET
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: Register 데이터 이동 내역에 따라 달라짐

SPM #2

– Store Program Memory

■ 동작 개요:
SPM 명령어는 두 가지 용도로 사용된다: 프로그램 메모리 안에서 한 페이지를 지울 때, 이미 지워진 곳에 새로운 페이지를 쓸 때이다. 임시 버퍼를 채우고 난 후에 프로그램 메모리에 페이지 단위로 쓸 수 있다. 이 모든 경우에 프로그램 메모리는 페이지 단위로 지워야 한다. 프로그램 메모리를 지울 때 RAMPZ 와 Z-Register 가 페이지 또는 워드 주소로 사용되고 R1:R0 Register 쌍이 데이터로 사용된다(1). 이 명령어는 프로그램 메모리 전체에 적용된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. 참고사항
: 1. R1 은 명령어의 상위 바이트를 결정하고 R0 는 명령어의 하위 바이트를 결정한다.

■  Register 데이터 이동 내역:
Comment:
(i) (RAMPZ:Z) ← $ffff Erase Program memory page
(ii) (RAMPZ:Z) ← R1:R0 Load Page Buffer
(iii) (RAMPZ:Z) ← BUFFER Write Page Buffer to Program memory
(iv) (RAMPZ:Z) ← $fff Z ← Z + 2 Erase Program memory page, Z post incremented (v) (RAMPZ:Z) ← R1:R0 Z ← Z + 2 Load Page Buffer, Z post incremented (vi) (RAMPZ:Z) ←BUFFER Z ← Z + 2 Write Page Buffer to Program memory, Z post incremented

■ Syntax
: Operands: Program Counter:
(i)-(iii) SPM
PC ← PC + 1
(iv)-(vi) SPM Z+
PC ← PC + 1

■ 16-bit 기계어 형식:
■ Status Register 변화:
■ 프로그램 예:
TBD
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: Register 데이터 이동 내역에 따라 변동

ST

– Store Indirect from Register to Data Space using Index X

■ 동작 개요:
간접 주소지정 방식으로 Register 에서 한 바이트의 데이터를 데이터 공간으로 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 데이터의 위치는 Register 파일에 들어 있는 X (16 bit) 포인터 Register 가 지정한다. 메모리 접근은 현 64K의 데이터 세그먼트에 국한된다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPX를 변경해야 한다. 이 연산으로 X-포인터 Register 는 변경되지 않거나 또는 사전 증가 또는 사후 감소될 수 있다. 이런 기능들은 특별히 어레이, 테이블을 접근하거나 X 포인터를 스택 포인터로 사용하는데 유용하다. 데이터 공간의 크기가 256 바이트 보다 크지 않으면 X 포인터의 하위 바이트 만 변경된다. 그런 경우 상위 바이트는 이 명령어에서 사용되지 않으므로 다른 용도로 사용할 수 있다. 입출력 지역의 RAMPX Register 는 64K 이상의 데이터 공간이나 64K 이상의 프로그램 메모리를 가진 Chip에서 변경되고 전체 24비트 주소가 증가 또는 감소된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. ST X+,R26 ST X+,R27 ST -X,R26 ST -X,R27 Using the X-pointer:

■  Register 데이터 이동 내역:
Comment:
(i) (X) ← Rr X: Unchanged
(ii) (X) ← Rr X ← X+1 X: Post incremented
(iii) X ← X - 1 (X) ← Rr X: Pre decremented

■ Syntax
: Operands: Program Counter:
(i) ST X,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(ii) ST X+,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(iii) ST -X,Rr 0 ≤ r ≤ 31
PC ← PC + 1 16-bit 기계어 형식 :
(i) 1001 001r RrRr 1100
(ii) 1001 001r RrRr 1101
(iii) 1001 001r RrRr 1110

■ Status Register 변화:
■ 프로그램 예:
CLR R27 ; Clear X high byte
LDI R26,$60 ; SET X low byte to $60
ST X+,R0 ; Store R0 in data space loc. $60(X post INC)
ST X,R1 ; Store R1 in data space loc. $61
LDI R26,$63 ; SET X low byte to $63
ST X,R2 ; Store R2 in data space loc. $63
ST -X, R3 ; Store  R3 in data space loc. $62(X pre DEC)
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: (i) 1
(ii) 1
(iii) 2

ST (STD)

– Store Indirect from Register to Data Space using Index Y

■ 동작 개요:
간접 주소지정 방식으로 변위를 반영하거나 하지 않고 Register 에서 한 바이트의 데이터를 데이터 공간으로 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 데이터의 위치는 Register 파일에 들어 있는 Y (16 bit) 포인터 Register 가 지정한다. 메모리 접근은 현 64K의 데이터 세그먼트에 국한된다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPY를 변경해야 한다. 이 연산으로 Y-포인터 Register 는 변경되지 않거나 또는 사전 증가 또는 사후 감소될 수 있다. 이런 기능들은 특별히 어레이, 테이블을 접근하거나 Y 포인터를 스택 포인터로 사용하는데 유용하다. 데이터 공간의 크기가 256 바이트 보다 크지 않으면 Y 포인터의 하위 바이트 만 변경된다. 그런 경우 상위 바이트는 이 명령어에서 사용되지 않으므로 다른 용도로 사용할 수 있다. 입출력 지역의 RAMPY Register 는 64K 이상의 데이터 공간이나 64K 이상의 프로그램 메모리를 가진 Chip에서 변경되고 전체 24비트 주소가 증가 또는 감소된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. : ST Y+,R28 ST Y+,R29 ST -Y,R28 ST -Y,R29 Using the Y-pointer:

■  Register 데이터 이동 내역:
Comment:
(i) (Y) ← Rr Y: Unchanged
(ii) (Y) ← Rr Y ← Y+1 Y: Post incremented
(iii) Y ← Y - 1 (Y) ← Rr Y: Pre decremented
(iv) (Y+q) ← Rr Y: Unchanged, q: Displacement

■ Syntax
: Operands: Program Counter:
(i) ST Y,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(ii) ST Y+,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(iii) ST -Y,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(iv) STD Y+q,Rr 0 ≤ r ≤ 31, 0 ≤ q ≤ 63
PC ← PC + 1

■ 16-bit 기계어 형식:
(i) 1000 001r RrRr 1000
(ii) 1001 001r RrRr 1001
(iii) 1001 001r RrRr 1010
(iv) 10q0 qq1r RrRr 1qqq

■ Status Register 변화:
■ 프로그램 예:
CLR R29 ; Clear Y high byte
LDI R28,$60 ; SET Y low byte to $60
ST Y+,R0 ; Store R0 in data space loc. $60(Y post INC)
ST Y,R1 ; Store R1 in data space loc. $61
LDI R28,$63 ; SET Y low byte to $63
ST Y,R2 ; Store R2 in data space loc. $63
ST -Y, R3 ; Store  R3 in data space loc. $62(Y pre DEC)
STD Y+2,R4 ; Store R4 in data space loc. $64
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: (i) 1
(ii) 1
(iii) 2
(iv) 2

ST (STD)

– Store Indirect from Register to Data Space using Index Z

■ 동작 개요:
간접 주소지정 방식으로 변위를 반영하거나 하지 않고 Register 에서 한 바이트의 데이터를 데이터 공간으로 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 데이터의 위치는 Register 파일에 들어 있는 Z (16 bit) 포인터 Register 가 지정한다. 메모리 접근은 현 64K의 데이터 세그먼트에 국한된다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPZ를 변경해야 한다. 이 연산으로 Z-포인터 Register 는 변경되지 않거나 또는 사전 증가 또는 사후 감소될 수 있다. 이런 기능들은 특별히 어레이, 테이블을 접근하거나 Z 포인터를 스택 포인터로 사용하는데 유용하다. 데이터 공간의 크기가 256 바이트 보다 크지 않으면 Z 포인터의 하위 바이트 만 변경된다. 그런 경우 상위 바이트는 이 명령어에서 사용되지 않으므로 다른 용도로 사용할 수 있다. 입출력 지역의 RAMPZ Register 는 64K 이상의 데이터 공간이나 64K 이상의 프로그램 메모리를 가진 Chip에서 변경되고 전체 24비트 주소가 증가 또는 감소된다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라. ST Z+, R30 ST Z+, R31 ST -Z, R30 ST -Z, R31 Using the Z-pointer:

■  Register 데이터 이동 내역:
Comment:
(i) (Z) ←Rr
Z: Unchanged
(ii) (Z) ← Rr Z ← Z+1
Z: Post incremented
(iii) Z ← Z - 1 (Z) ← Rr
Z: Pre decremented
(iv) (Z+q) ← Rr
Z: Unchanged, q: Displacement

■ Syntax
: Operands: Program Counter:
(i) ST Z,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(ii) ST Z+,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(iii) ST -Z,Rr 0 ≤ r ≤ 31
PC ← PC + 1
(iv) STD Z+q,Rr 0 ≤ r ≤ 31, 0 ≤ q ≤ 63
PC ← PC + 1 16-bit 기계어 형식 :

■ Status Register 변화:
■ 프로그램 예:
CLR  R31 ; Clear Z high byte
LDI  R30,$60 ; SET Z low byte to $60
ST Z+,R0 ; Store R0 in data space loc. $60(Z post INC)
ST Z,R1 ; Store R1 in data space loc. $61
LDI  R30,$63 ; SET Z low byte to $63
ST Z,R2 ; Store R2 in data space loc. $63
ST -Z, R3 ; Store  R3 in data space loc. $62(Z pre DEC)
STD Z+2,R4 ; Store R4 in data space loc. $64
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 2 소요 클럭 수 XMEGA: (i) 1
(ii) 1
(iii) 2
(iv) 2


STS

– Store Direct to Data Space

■ 동작 개요:
직접 주소지정 방식으로 Register 에서 한 바이트의 데이터를 데이터 공간으로 옮겨 담는 명령어이다. SRAM이 들어 있는 Chip의 경우 데이터 공간은 Register 파일, 입출력 메모리, 내부 SRAM (경우에 따라서는 외부 SRAM도 포함) 으로 이루어 진다. SRAM이 없는 Chip의 경우 데이터 공간은 Register 파일 만으로 구성된다. EEPROM 은 별도의 주소 공간을 가진다. 16 bit 주소가 필요하다. 메모리 접근은 현 64Kbytes 데이터 세그먼트에 국한된다. 64Kbytes 이상의 메모리를 접근하려면 RAMPDRegister 를 사용한다. 64K 보다 큰 데이터 공간을 가진 Chip에서 다른 데이터 세그먼트를 접근하려면 입출력에서 Register RAMPD를 변경해야 한다. 이 명령은 모든 Chip에 적용되는 것은 아니다. Chip 별 문서를 참고하라.

■  Register 데이터 이동 내역:
(i) (k) ← Rr
형식, Operand 값의 범위, Program Counter:
(i) STS k,Rr 0 ≤ r ≤ 31, 0 ≤ k ≤ 65535
PC ← PC + 2 32-bit 기계어 형식:

■ Status Register 변화:
■ 프로그램 예:
LDS R2,$FF00 ; Load R2 with the contents of data space location $FF00
ADD R2,R1 ; Add R1 to R2
STS $FF00 R2 ; Write back
■ 길이: 2 (4 bytes)
■ 소요 클럭 수: 2


SUB

– Subtract without Carry

■ 동작 개요:
두 Register 의 내용의 차를 목적지 Register 에 저장한다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd - Rr
형식, Operand 값의 범위, Program Counter:
(i) SUB Rd,Rr
0 ≤ d ≤ 31, 0 ≤ r ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register 와 불리언 값 변화:
H: Rd3• R R3 +R R3 • R3 + R3• Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7• Rr7 •R7 +Rd7 •Rr7• R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7• Rr7 +Rr7 •R7 +R7• Rd7 Rr 의 절대값이 Rd의 절대값 보다 크면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
SUB R13,R12 ; Subtract R12 from R13
BRNE noteq ; Branch if R12<> R13
...
noteq: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SUBI

– Subtract Immediate

■ 동작 개요:
Register Rd에서 상수를 뺀 다음 Register Rd에 저장한다. 이 명령어는 Register R16  부터 R31까지 실행된다. 이것은 X, Y, Z 포인터에 대한 연산으로 적합하다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd - K
형식, Operand 값의 범위, Program Counter:
(i) SUBI Rd,K
16 ≤ d ≤ 31[ AL ... Z ]
0 ≤ K ≤ 255
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register 와 불리언 값 변화:
H: Rd3• K3+K3 • R3 + R3 •Rd3 비트 3에 보로우가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴
S: N ⊕ V, 부호 테스트.
V: Rd7• K7 •R7 +Rd7• K7 •R7 계산결과 2의 보수 Overflow가 발생하면 'SET'됨; 다른 모든 경우에는 'Clear' 시킴.
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
C: Rd7• K7 +K7 •R7 +R7• Rd7 K 의 절대 값이 Rd의 절대값 보다 크면 1을 저장; 다른 모든 경우에는 'Clear' 시킴. R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
SUBI R22,$11 ; Subtract $11 from R22
BRNE noteq ; Branch if R22<>$11
...
noteq: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


SWAP

– SWAP Nibbles

■ 동작 개요:
Register 안에서 하위 4 비트와 상위 4 비트를 맞바꾼다..

■  Register 데이터 이동 내역:
(i) R(7:4) ← Rd(3:0),R(3:0) ← Rd(7:4)
형식, Operand 값의 범위, Program Counter:
(i) SWAP Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register 와 불리언 값 변화: R (계산결과 값)은 Register 데이터 이동 후 Rd와 같아짐.

■ 프로그램 예:
INC R1 ; Increment R1
SWAP R1 ; SWAP high AND low nibble of R1
INC R1 ; Increment high nibble of R1
SWAP R1 ; SWAP back
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


TST

– Test for Zero or Minus

■ 동작 개요:
Register 내용이 0이나 음수인지 검사한다. Register 가 자신의 데이터와 AND 연산을 실행한다. Register 내용은 변하지 않는다.

■  Register 데이터 이동 내역:
(i) Rd ← Rd • Rd
형식, Operand 값의 범위, Program Counter:
(i) TST Rd
0 ≤ d ≤ 31
PC ← PC + 1

■ 16-bit 기계어 형식:
(비교참조 - AND Rd,Rd) Status Register 와 불리언 값 변화:
S: N ⊕ V, 부호 테스트.
V: 0 지워짐
N: R7 계산결과 MSB가 “1”이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴.
Z: R7• R6 •R5• R4• R3 • R2• R1• R0 연산결과가 0이면 'SET'시킴; 다른 모든 경우에는 'Clear' 시킴. R (Result) 은 Rd에 들어 간이다.

■ 프로그램 예:
TST R0 ; Test R0
BREQ z ero ; Branch if R0=0
...
zero: 
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


WDR

– Watchdog Reset

■ 동작 개요:
워치독 타이머를 'Reset' 시킨다. 이 명령어는 WD Prescaler에 의하여 제한된 시간 안에 실행되어야 한다. Watchdog Timer 하드웨어 사양을 참고하기 바람.

■  Register 데이터 이동 내역:
(i) WD timer restart.
형식, Operand 값의 범위, Program Counter:
(i) WDR
PC ← PC + 1

■ 16-bit 기계어 형식:

■ Status Register 와 불리언 값 변화:

■ 프로그램 예:
WDR ; Reset watchdog timer
■ 길이: 1 (2 bytes)
■ 소요 클럭 수: 1


Assembler Instructions of AVR128

Instruction Mnemonics

Arithmetic and Logic Instructions

Mnemonic Operands Description Operation Flags Cycles
ADD Rd,Rr Add without Carry Rd = Rd + Rr Z,C,N,V,H,S 1
ADC Rd,Rr Add with Carry Rd = Rd + Rr + C Z,C,N,V,H,S 1

ADIW

Rd, K

Add Immediate To Word

Rd+1: Rd,K

Z,C,N,V,S

2

SUB

Rd,Rr

Subtract without Carry

Rd = Rd - Rr

Z,C,N,V,H,S

1

SUBI Rd,K8 Subtract Immediate Rd = Rd - K8 Z,C,N,V,H,S 1
SBC Rd,Rr Subtract with Carry Rd = Rd - Rr - C Z,C,N,V,H,S 1
SBCI Rd,K8 Subtract with Carry Immedtiate Rd = Rd - K8 - C Z,C,N,V,H,S 1
AND Rd,Rr Logical AND Rd = Rd ?Rr Z,N,V,S 1
ANDI Rd,K8 Logical AND with Immediate Rd = Rd ?K8 Z,N,V,S 1
OR Rd,Rr Logical OR Rd = Rd V Rr Z,N,V,S 1
ORI Rd,K8 Logical OR with Immediate Rd = Rd V K8 Z,N,V,S 1
EOR Rd,Rr Logical Exclusive OR Rd = Rd EOR Rr Z,N,V,S 1
COM Rd One's Complement Rd = $FF - Rd Z,C,N,V,S 1
NEG Rd Two's Complement Rd = $00 - Rd Z,C,N,V,H,S 1
SBR Rd,K8 Set Bit(s) in Register Rd = Rd V K8 Z,C,N,V,S 1
CBR Rd,K8 Clear Bit(s) in Register Rd = Rd ?($FF - K8) Z,C,N,V,S 1
INC Rd Increment Register Rd = Rd + 1 Z,N,V,S 1
DEC Rd Decrement Register Rd = Rd -1 Z,N,V,S 1
TST Rd Test for Zero or Negative Rd = Rd ?Rd Z,C,N,V,S 1
CLR Rd Clear Register Rd = 0 Z,N,V,S 1
SER Rd Set Register Rd = $FF None 1
SBIW Rdl,K6 Subtract Immediate from Word Rdh: Rdl = Rdh: Rdl - K 6 Z,C,N,V,S 2
MUL Rd,Rr Multiply Unsigned R1: R0 = Rd * Rr Z,C 2
MULS Rd,Rr Multiply Signed R1: R0 = Rd * Rr Z,C 2
MULSU Rd,Rr Multiply Signed with Unsigned R1: R0 = Rd * Rr Z,C 2
FMUL Rd,Rr Fractional Multiply Unsigned R1: R0 = (Rd * Rr) << 1 Z,C 2
FMULS Rd,Rr Fractional Multiply Signed R1: R0 = (Rd *Rr) << 1 Z,C 2
FMULSU Rd,Rr Fractional Multiply Signed with Unsigned R1: R0 = (Rd * Rr) << 1 Z,C 2

Branch Instructions

Mnemonic Operands Description Operation Flags Cycles
RJMP k Relative Jump PC = PC + k +1 None 2
IJMP None Indirect Jump to (Z) PC = Z None 2
EIJMP None Extended Indirect Jump (Z) STACK = PC+1, PC(15:0) = Z, PC(21:16) = EIND None 2
JMP k Jump PC = k None 3
RCALL k Relative Call Subroutine STACK = PC+1, PC = PC + k + 1 None 3/4*
ICALL None Indirect Call to (Z) STACK = PC+1, PC = Z None 3/4*
EICALL None Extended Indirect Call to (Z) STACK = PC+1, PC(15:0) = Z, PC(21:16) =EIND None 4*
CALL k Call Subroutine STACK = PC+2, PC = k None 4/5*
RET None Subroutine Return PC = STACK None 4/5*
RETI None Interrupt Return PC = STACK I 4/5*
CPSE Rd,Rr Compare, Skip if equal if (Rd ==Rr) PC = PC 2 or 3 None 1/2/3
CP Rd,Rr Compare Rd -Rr Z,C,N,V,H,S 1
CPC Rd,Rr Compare with Carry Rd - Rr - C Z,C,N,V,H,S 1
CPI Rd,K8 Compare with Immediate Rd - K Z,C,N,V,H,S 1
SBRC Rr,b Skip if bit in register cleared if(Rr(b)==0) PC = PC + 2 or 3 None 1/2/3
SBRS Rr,b Skip if bit in register set if(Rr(b)==1) PC = PC + 2 or 3 None 1/2/3
SBIC P,b Skip if bit in I/O register cleared if(I/O(P,b)==0) PC = PC + 2 or 3 None 1/2/3
SBIS P,b Skip if bit in I/O register set if(I/O(P,b)==1) PC = PC + 2 or 3 None 1/2/3
BRBC s,k Branch if Status flag cleared if(SREG(s)==0) PC = PC + k + 1 None 1/2
BRBS s,k Branch if Status flag set if(SREG(s)==1) PC = PC + k + 1 None 1/2
BREQ k Branch if equal if(Z==1) PC = PC + k + 1 None 1/2
BRNE k Branch if not equal if(Z==0) PC = PC + k + 1 None 1/2
BRCS k Branch if carry set if(C==1) PC = PC + k + 1 None 1/2
BRCC k Branch if carry cleared if(C==0) PC = PC + k + 1 None 1/2
BRSH k Branch if same or higher if(C==0) PC = PC + k + 1 None 1/2
BRLO k Branch if lower if(C==1) PC = PC + k + 1 None 1/2
BRMI k Branch if minus if(N==1) PC = PC + k + 1 None 1/2
BRPL k Branch if plus if(N==0) PC = PC + k + 1 None 1/2
BRGE k Branch if greater than or equal (signed) if(S==0) PC = PC + k + 1 None 1/2
BRLT k Branch if less than (signed) if(S==1) PC = PC + k + 1 None 1/2
BRHS k Branch if half carry flag set if(H==1) PC = PC + k + 1 None 1/2
BRHC k Branch if half carry flag cleared if(H==0) PC = PC + k + 1 None 1/2
BRTS k Branch if T flag set if(T==1) PC = PC + k + 1 None 1/2
BRTC k Branch if T flag cleared if(T==0) PC = PC + k + 1 None 1/2
BRVS k Branch if overflow flag set if(V==1) PC = PC + k + 1 None 1/2
BRVC k Branch if overflow flag cleared if(V==0) PC = PC + k + 1 None 1/2
BRIE k Branch if interrupt enabled if(I==1) PC = PC + k + 1 None 1/2
BRID k Branch if interrupt disabled if(I==0) PC = PC + k + 1 None 1/2
* Cycle times for data memory accesses assume internal memory accesses, and are not valid for accesses through the external RAM interface. For the instructions CALL, ICALL, EICALL, RCALL, RET and RETI, add three cycles plus two cycles for each wait state in

up to 16 bit PC (128KB program memory). For

more than 128KB program memory, add five cycles plus three cycles for each wait state.

Data Transfer Instructions

Mnemonic Operands Description Operation Flags Cycles
MOV Rd,Rr Copy register Rd = Rr None 1
MOVW Rd,Rr Copy register pair Rd+1: Rd = Rr+1: Rr, r,d even None 1
LDI Rd,K8 Load Immediate Rd = K None 1
LDS Rd,k Load Direct Rd = (k) None 2*
LD Rd,X Load Indirect Rd = (X) None 2*
LD Rd,X+ Load Indirect and Post-Increment Rd = (X), X=X+1 None 2*
LD Rd,-X Load Indirect and Pre-Decrement X=X-1, Rd = (X) None 2*
LD Rd,Y Load Indirect Rd = (Y) None 2*
LD Rd,Y+ Load Indirect and Post-Increment Rd = (Y), Y=Y+1 None 2*
LD Rd,-Y Load Indirect and Pre-Decrement Y=Y-1, Rd = (Y) None 2*
LDD Rd,Y+q Load Indirect with displacement Rd = (Y+q) None 2*
LD Rd,Z Load Indirect Rd = (Z) None 2*
LD Rd,Z+ Load Indirect and Post-Increment Rd = (Z), Z=Z+1 None 2*
LD Rd,-Z Load Indirect and Pre-Decrement Z=Z-1, Rd = (Z) None 2*
LDD Rd,Z+q Load Indirect with displacement Rd = (Z+q) None 2*
STS k,Rr Store Direct (k) = Rr None 2*
ST X,Rr Store Indirect (X) = Rr None 2*
ST X+,Rr Store Indirect and Post-Increment (X) = Rr, X=X+1 None 2*
ST -X,Rr Store Indirect and Pre-Decrement X=X-1, (X)=Rr None 2*
ST Y,Rr Store Indirect (Y) = Rr None 2*
ST Y+,Rr Store Indirect and Post-Increment (Y) = Rr, Y=Y+1 None 2
ST -Y,Rr Store Indirect and Pre-Decrement Y=Y-1, (Y) = Rr None 2
ST Y+q,Rr Store Indirect with displacement (Y+q) = Rr None 2
ST Z,Rr Store Indirect (Z) = Rr None 2
ST Z+,Rr Store Indirect and Post-Increment (Z) = Rr, Z=Z+1 None 2
ST -Z,Rr Store Indirect and Pre-Decrement Z=Z-1, (Z) = Rr None 2
ST Z+q,Rr Store Indirect with displacement (Z+q) = Rr None 2
LPM None Load Program Memory R0 = (Z) None 3
LPM Rd,Z Load Program Memory Rd = (Z) None 3
LPM Rd,Z+ Load Program Memory and Post-Increment Rd = (Z), Z=Z+1 None 3
ELPM None Extended Load Program Memory R0 = (RAMPZ:Z) None 3
ELPM Rd,Z Extended Load Program Memory Rd = (RAMPZ:Z) None 3
ELPM Rd,Z+ Extended Load Program Memory and Post Increment Rd = (RAMPZ:Z), Z = Z+1 None 3
SPM None Store Program Memory (Z) = R1: R0 None -
ESPM None Extended Store Program Memory (RAMPZ:Z) = R1: R0 None -
IN Rd,P In Port Rd = P None 1
OUT P,Rr Out Port P = Rr None 1
PUSH Rr Push register on Stack STACK = Rr None 2
POP Rd Pop register from Stack Rd = STACK None 2
* Cycle times for data memory accesses assume internal memory accesses and are not valid for accesses through the external RAM interface. For the LD, ST, LDD, STD, LDS, STS, PUSH and POP instructions, add one cycle plus one cycle for each wait state.

Bit and Bit-test Instructions

Mnemonic Operands Description Operation Flags Cycles
LSL Rd Logical shift left Rd(n+1)=Rd(n), Rd(0)=0, C=Rd(7) Z,C,N,V,H,S 1
LSR Rd Logical shift right Rd(n)=Rd(n+1), Rd(7)=0, C=Rd(0) Z,C,N,V,S 1
ROL Rd Rotate left through carry Rd(0)=C, Rd(n+1)=Rd(n), C=Rd(7) Z,C,N,V,H,S 1
ROR Rd Rotate right through carry Rd(7)=C, Rd(n)=Rd(n+1), C=Rd(0) Z,C,N,V,S 1
ASR Rd Arithmetic shift right Rd(n)=Rd(n+1), n=0,...,6 Z,C,N,V,S 1
SWAP Rd Swap nibbles Rd(3..0) = Rd(7..4), Rd(7..4) = Rd(3..0) None 1
BSET s Set flag SREG(s) = 1 SREG(s) 1
BCLR s Clear flag SREG(s) = 0 SREG(s) 1
SBI P,b Set bit in I/O register I/O(P,b) = 1 None 2
CBI P,b Clear bit in I/O register I/O(P,b) = 0 None 2
BST Rr,b Bit store from register to T T = Rr(b) T 1
BLD Rd,b Bit load from register to T Rd(b) = T None 1
SEC None Set carry flag C =1 C 1
CLC None Clear carry flag C = 0 C 1
SEN None Set negative flag N = 1 N 1
CLN None Clear negative flag N = 0 N 1
SEZ None Set zero flag Z = 1 Z 1
CLZ None Clear zero flag Z = 0 Z 1
SEI None Set interrupt flag I = 1 I 1
CLI None Clear interrupt flag I = 0 I 1
SES None Set signed flag S = 1 S 1
CLN None Clear signed flag S = 0 S 1
SEV None Set overflow flag V = 1 V 1
CLV None Clear overflow flag V = 0 V 1
SET None Set T-flag T = 1 T 1
CLT None Clear T-flag T = 0 T 1
SEH None Set half carry flag H = 1 H 1
CLH None Clear half carry flag H = 0 H 1
NOP None No operation None None 1
SLEEP None Sleep See instruction manual None 1
WDR None Watchdog Reset See instruction manual None 1
BREAK None Execution Break See instruction manual None 1

어셈블러는 대소문자를 구별하지 않는다.
The operands have the following forms:

Rd: Destination (and source) register in the register file
Rr: Source register in the register file
b: Constant (0-7), can be a constant expression
s: Constant (0-7), can be a constant expression
P: Constant (0-31/63), can be a constant expression
K6; Constant (0-63), can be a constant expression
K8: Constant (0-255), can be a constant expression
k: Constant, value range depending on instruction. Can be a constant expression
q: Constant (0-63), can be a constant expression
Rdl: R24, R26, R28, R30. For ADIW and SBIW instructions
X,Y,Z: Indirect address registers (X=R27: R26, Y=R29: R28, Z= R31: R30)