이 블로그는 임베디드 컴퓨터를 이용한 장치(시스템) 개발과 원격제어에 필요한 지식을 공유 하기 위한 블로그 입니다.
실제 개발과 프로그램 예를 위하여 Microchip 사의 ATmega128를 사용한 보드와 Arduino Mega 보드(ATmega2560), Raspberry Pi, Raspberry Pi Pico, WiFi 모듈을 사용 합니다.

avr-asm-instructions

AVR ASM Instructions
  AVR ASM Instructions

  • AVR ASM Instructions

      • AVR ASM Instructions의 종류가 너무 많기 때문에 이 페이지에서는 자주 사용하는 Instructions 만 설명한다. 전체 Instructions은 아래 참고문헌을 참고 바람.

      참고자료: "AVR Instruction Set Manual.pdf"

    • Data Transfer Instructions
      • Register 와 Register 사이의 Data Transfer
        • MOV: Rd Rg에 Rr Rg를 복사한다.
          • Syntax: MOV Rd, Rr
          • Operation: Rd ← Rr
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • MOV Instruction 사용 예:

            • mov r16,r0 ; Copy r0 to r16

        • MOVW: Rd와 Rd+1 Rg에 Rr와 Rr+1 Rg를 복사(Word 단위)한다.
          • Syntax: MOVW Rd, Rr
          • Operation: Rd+1:Rd ← Rr+1:Rr
          • Operands: d ∈ {0,2,...,30}, r ∈ {0,2,...,30}, Word(2 Byte)를 복사하기 때문에 Rd, Rr은 짝수번 Rg만 사용할 수 있다.
          • MOVW Instruction 사용 예:

            • movw 16, r0 ; Copy r1:r0 to r17:r16


      • Register에 Data를 Load하는 명령
        • LDI: Rd Rg에 8 bit 상수를 직접 복사한다. 상수는 Instruction에 포함되어 있다.
          • Syntax: LDI Rd, K
          • Operation: Rd ← K
          • Operands: 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
          • LDI Instruction 사용 예:

            • ldi r16, 0x0f ; Set r16 to 0x0f

        • LDS: Rd Rg에 Data Space로 부터 직접 Data를 Load 한다.

          • 주: Data Space는 Register File, I/O memory, 내부 SRAM(외부 SRAM이 있는 경우 외부 SRAM 포함)을 포함한다.

          • Syntax: LDS Rd, k
          • Operation: Rd ← (k), k 번지(Data Space)의 Data를 Rd에 Load 한다.
          • Operands: 0 ≤ d ≤ 31, 0 ≤ k ≤ 65535
          • LDS Instruction 사용 예:

            • lds r16, 0x0100 ; r16에 Data space 0x0100 번지의 값을 Load 한다.

        • LD: Rd Rg에 src에서 지정한 Index Rg를 사용(Indirect addressing: 간접 번지 지정)하여 Data Space로 부터 Data를 Load 한다.
          • Syntax: LD Rd, src
          • Operation: Rd ← src, src는 X, X+, -X, Y, Y+, -Y, Z, Z+, -Z를 Index Rg로 사용할 수 있다. X+는 Post-Increment, -X는 Pre-Decrement 동작을 의미한다.
          • Operands: 0 ≤ d ≤ 31, src를 Index Rg로 사용된다.
          • LD Instruction 사용 예:

            • ldi r27, 0x01 ; Set X high byte to 0x01

            ldi r26, 0x00 ; Set X low byte to 0x00

            ld r16, X+ ; Load r16 with data space loc. 0x0100(X post inc)

            ld r17, X ; Load r17 with data space loc. 0x0101

          • Index Rg를 이용한 Indirect addressing의 장점:
            • 1 Word(16 Bits) Instruction으로 64K Data Space를 Addressing 할 수 있다. AVR은 대부분의 Instruction을 1 Word(일부 2 Word Instruction도 사용하지만 2 Word은 실행시 2번 Fetch 하여야함)로 설계한다.
            • Post-Increment 또는 Pre-Decrement를 이용하여 연속적으로 배열된(Array) Data를 효과적으로 Access 할 수 있다. Post-Increment, Pre-Decrement 동작은 Up/Down counter를 사용하여 Hardware로 구현되기 때문에 빠르고 효과적으로 실행된다.
        • LDD: Rd Rg에 src에서 지정한 Index Rg(Y, Z)에 Displacement(q)를 더한 Data Space 번지로 부터 Data를 Load 한다.
          • Syntax: LDD Rd, src+q
          • Operation: Rd ← (src+q), src은 Y 또는 Z Rg
          • Operands: 0 ≤ d ≤ 31, 0 ≤ q ≤ 63
          • LDD Instruction 사용 예:

            • ldi r29, 0x01 ; Set Y high byte to 0x01

            ldi r28, 0x00 ; Set Y low byte to 0x00

            ldd r16, Y+0x10 ; r16에 Data space 0x0110 번지의 값을 Load 한다.

        • POP: Stack으로 부터 Rd Rg에 Data를 Pop(Load) 한다.
          • Syntax: POP Rd
          • Operation: Rd ← (SP), SP ← SP + 1, SP는 Stack Pointer
          • Operands: 0 ≤ d ≤ 31
          • POP Instruction 사용 예:

            • push r16 ; Save r16 on the Stack

            pop r17 ; Restore r17

            주: push, pop Instruction을 사용하기전에 Stack pointer 가 설정되어 있어야 한다.

        • IN: I/O Space(Ports, Timers, Configuration Registers, etc.)으로 부터 Rd Rg에 Data를 Load 한다.
          • Syntax: IN Rd, A
          • Operation: Rd ← I/O(A)
          • Operands: 0 ≤ d ≤ 31, 0 ≤ A ≤ 63
          • IN Instruction 사용 예:

            • in r16,0x16 ; r16에 Port B 값을 Load 한다.

            주: 일부 확장된 AVR Microcontrollers는 I/O addressing을 위해 opcode에 준비된 64개 주소 내에서 지원할 수 있는 것보다 더 많은 주변 장치가 있다. 이 경우 64 - 255 번지에 확장된 I/O Port는 I/O addressing이 아닌 Data addressing을 사용(LDS 명령 사용)하여야 한다.

      • Data Space에 Register의 Data를 Store하는 명령
        • STS: 주어진 Data Space(Direct addressing)에 Rd Rg의 Data를 직접 Store 한다.

          • 주: Data Space는 Register File, I/O memory, 내부 SRAM(외부 SRAM이 있는 경우 외부 SRAM 포함)을 포함한다.

          • Syntax: STS k, Rr
          • Operation: (k) ← Rr, k 번지(Data Space)에 Rr를 Store 한다.
          • Operands: 16 Bit 명령인 경우 16 ≤ r ≤ 31, 0 ≤ k ≤ 127, 32 Bit 명령인 경우 0 ≤ r ≤ 31, 0 ≤ k ≤ 65535
          • STS Instruction 사용 예:

            • lds r16, 0x0100 ; r16에 Data space 0x0100 번지의 값을 Load 한다.

            lds r17, 0x0101 ; r17에 Data space 0x0101 번지의 값을 Load 한다.

            add r16,r17 ; add r17 to r16

            sts 0x0102, r16 ; Data space 0x0102 번지에 r16을 Store 한다.

            주: 연속한 번지를 사용하는 경우 여기서 사용한 Direct addressing 보다 Index Rg를 사용한 Indirect addressing이 효과적 이다.

        • ST: Index Rg를 사용하여 지정된 Data Space 번지(간접 번지 지정)에 Rr Rg의 Data를 Store 한다.
          • Syntax: ST dest, Rr
          • Operation: (dest) ← Rr, dest는 X, X+, -X, Y, Y+, -Y, Z, Z+, -Z를 Index Rg로 사용할 수 있다. X+는 Post-Increment, -X는 Pre-Decrement 동작을 의미한다.
          • Operands: 0 ≤ r ≤ 31, dest는 Index Rg
          • ST Instruction 사용 예:

            • ldi r27, 0x01 ; Set X high byte to 0x01

            ldi r26, 0x00 ; Set X low byte to 0x00

            ldi r16, 0x01 ; r16에 1을 Load 한다.

            st X+, r16 ; 0x0100 번지에 r16(1)을 저장하고 X Rg를 1 증가 시킨다.

            inc r16 ; r16 Rg를 1 증가 시킨다.

            st X, r16 ; 0x0101 번지에 r16(2)을 저장한다.

        • STD: dest에서 지정한 Index Rg(Y, Z)에 Displacement(q)를 더한 Data Space 번지에 Rr Rg를 Store 한다.
          • Syntax: STD dest+q, Rr
          • Operation: (dest+q) ← Rr, dest는 Y 또는 Z Rg를 사용할 수 있다.
          • Operands: 0 ≤ r ≤ 31, 0 ≤ q ≤ 63
          • STD Instruction 사용 예:

            • ldi r29, 0x01 ; Set Y high byte to 0x01

            ldi r28, 0x00 ; Set Y low byte to 0x00

            ldi r16, 0x01 ; r16에 1을 Load 한다.

            std Y+0x10,r16 ; Data space 0x0110 번지에 r16을 Store 한다.

        • PUSH: Rr Rg를 Stack에 Push(Store) 한다.
          • Syntax: PUSH Rr
          • Operation: (SP) ← Rr, SP ← SP - 1, SP는 Stack Pointer
          • Operands: 0 ≤ r ≤ 31
          • PUSH Instruction 사용 예:

            • push r16 ; Save r16 on the Stack

            주: push Instruction을 사용하기전에 Stack pointer 가 설정되어 있어야 한다.

        • OUT: Rr Rg 값을 I/O Space(Ports, Timers, Configuration Registers, etc.)에 Store 한다.
          • Syntax: OUT A, Rr
          • Operation: I/O(A) ← Rr
          • Operands: 0 ≤ r ≤ 31, 0 ≤ A ≤ 63
          • OUT Instruction 사용 예:

            • ldi r16, 0x01 ; r16에 1을 Load 한다.

            out 0x18,r16 ; r16 값을 Port B에 Store 한다.

            주: 일부 확장된 AVR Microcontrollers는 I/O addressing을 위해 opcode에 준비된 64개 주소 내에서 지원할 수 있는 것보다 더 많은 주변 장치가 있다. 이 경우 64 - 255 번지에 확장된 I/O Port는 I/O addressing이 아닌 Data addressing을 사용(LDS 명령 사용)하여야 한다.

      • Register 와 Program Memory 사이의 Data Transfer
        • LPM: Rd Rg에 Program Memory로 부터 Data를 Load 한다.
          • Syntax: LPM Rd, Z
          • Operation: Rd ← (Z)
          • Operands: 0 ≤ d ≤ 31
          • LPM Instruction 사용 예:

            • ldi ZH, high(Table_1<<1) ; Z-pointer를 초기화, Word address를 Byte address로 변환

            ldi ZL, low(Table_1<<1)

            lpm r16, Z ; Index Rg Z를 사용하여 Program memory로 부터 r16에 Data를 Load 한다.

            Table_1: .dw 0x000f ; Z Rg의 LSB가 0 인 경우 0x0f, Z Rg의 LSB가 1 인 경우 0x00가 Load 됨

            주: Program memory는 16 bit Words 구조이기 때문에 8 bit Byte Data를 Load 하기 위하여는 Word address를 Byte address로 변환(Byte address = Word address x 2) 하여 사용하여야 한다.

          주: Program Memory는 Flash Memory 이기 때문에 Program Memory에 Data를 Store 하는 SPM 명령을 실행하면 Flash Memory를 Erase 하고 다시 Flash Memory에 Write 하는 동작이 연속으로 실행된다. SPM 명령은 자주 사용하는 명령이 아니기 때문에 여기서는 생략한다.


    • Arithmetic and Logic Instructions
      • Arithmetic Instructions
        • ADD/SUB: Add without Carry, Subtract without Carry
          • Syntax: ADD Rd, Rr / SUB Rd, Rr
          • Operation: Rd ← Rd + Rr, Rd ← Rd - Rr
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: Z,C,N,V,S,H
          • ADD/SUB Instruction 사용 예:

            • ldi r16, 6

            ldi r17, 4

            add r16, r17

            sub r16, r17

        • ADC/SBC: Add with Carry, Subtract with Carry
          • Syntax: ADC Rd, Rr / SBC Rd, Rr
          • Operation: Rd ← Rd + Rr + C, Rd ← Rd - Rr - C
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: Z,C,N,V,S,H
          • ADC/SBC Instruction 사용 예:

            • ldi r16, 6

            ldi r17, 4

            adc r16, r17

            sbc r16, r17

        • ADIW/SBIW:Add Immediate to Word, Subtract Immediate from Word
          • Syntax: ADIW Rd, K / SBIW Rd, K
          • Operation: Rd+1:Rd ← Rd+1:Rd + K, Rd+1:Rd ← Rd+1:Rd - K
          • Operands: d ∈ {24,26,28,30}, 0 ≤ K ≤ 63
          • Flags: Z,C,N,V,S
          • ADIW/SBIW Instruction 사용 예:

            • adiw Z,63 ; Add 63 to the Z-pointer(r31:r30)

            sbiw Y,63 ; Subtract 63 from the Y-pointer(r29:r28)

        • INC/DEC: Increment, Decrement
          • Syntax: INC Rd / DEC Rd
          • Operation: Rd ← Rd + 1, Rd ← Rd - 1
          • Operands: 0 ≤ d ≤ 31
          • Flags: Z,N,V,S
          • INC/DEC Instruction 사용 예:

            • inc r16 ; increment r16

            dec r16 ; Decrement r16

        • MUL: Multiply Unsigned
          • Syntax: MUL Rd,Rr
          • Operation: R1:R0 ← Rd × Rr (unsigned ← unsigned × unsigned)
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: Z,C
          • MUL Instruction 사용 예:

            • mul r16,r17 ; Multiply unsigned r16 and r17

            movw r16,r0 ; Copy result back in r17:r16

        • MULS: Multiply Signed
          • Syntax: MULS Rd,Rr
          • Operation: R1:R0 ← Rd × Rr (signed ← signed × signed)
          • Operands: 16 ≤ d ≤ 31, 16 ≤ r ≤ 31
          • Flags: Z,C
          • MULS Instruction 사용 예:

            • muls r16,r17 ; Multiply signed r16 and r17

            movw r16,r0 ; Copy result back in r17:r16

        • MULSU: Multiply Signed with Unsigned
          • Syntax: MULSU Rd,Rr
          • Operation: R1:R0 ← Rd × Rr (signed ← signed × unsigned)
          • Operands: 16 ≤ d ≤ 23, 16 ≤ r ≤ 23
          • Flags: Z,C
          • MULSU Instruction 사용 예:

            • mulsu r16,r17 ; Multiply signed r16 and unsigned r17

            movw r16,r0 ; Copy result back in r17:r16


      • Logic Instructions
        • AND/OR: Logical AND / Logical OR
          • Syntax: AND Rd, Rr, OR Rd, Rr
          • Operation: Rd ← Rd • Rr, Rd ← Rd v Rr
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: Z,N,V,S
          • AND/OR Instruction 사용 예:

            • ldi r16, 6

            ldi r17, 4

            and r16,r17 ; Bitwise and between registers, result in r16

            or r16,r17 ; Bitwise or between registers, result in r16

        • ANDI/ORI: Logical AND with Immediate, Logical OR with Immediate
          • Syntax: ANDI Rd, K / ORI Rd,K
          • Operation: Rd ← Rd • K, Rd ← Rd v K
          • Operands: 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
          • Flags: Z,N,V,S
          • ANDI/ORI Instruction 사용 예:

            • andi r16, 0x0F ; Clear upper nibble of r16

            ori r16,$F0 ; Set high nibble of r16

        • EOR: Exclusive OR
          • Syntax: EOR Rd, Rr
          • Operation: Rd ← Rd ⊕ Rr
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: Z,N,V,S
          • EOR Instruction 사용 예:

            • eor r16,r16 ; Clear r16

            eor r16,r17 ; Bitwise exclusive or between r16 and r17

        • COM/NEG: One’s Complement, Two’s Complement
          • Syntax: COM Rd / NEG Rd
          • Operation: Rd ← 0xFF - Rd / Rd ← 0x00 - Rd
          • Operands: 0 ≤ d ≤ 31
          • Flags: Z,C,N,V,S / Z,C,N,V,S,H
          • COM/NEG Instruction 사용 예:

            • com r16 ; Take one’s complement of r16

            neg r16 ; Take two’s complement of r16

        • SBR/CBR: Set Bits in Register, Clear Bits in Register
          • Syntax: SBR Rd,K / CBR Rd,K
          • Operation: Rd ← Rd v K / Rd ← Rd • ($FF - K) ; K는 Constant mask
          • Operands: 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
          • Flags: Z,N,V,S
          • SBR/CBR Instruction 사용 예:

            • sbr r16,$F0 ; Set 4 MSB in r16

            cbr r16,$F0 ; Clear upper nibble of r16

        • SER/CLR: Set all Bits in Register, Clear Register
          • Syntax: SER Rd / CLR Rd
          • Operation: Rd ← $FF / Rd ← Rd ⊕ Rd
          • Operands: 16 ≤ d ≤ 31 / 0 ≤ d ≤ 31
          • Flags: None / Z,N,V,S
          • SER/CLR Instruction 사용 예:

            • ser r16 ; Set r16

            clr r16 ; clear r16

        • TST: Test for Zero or Minus
          • Syntax: TST Rd
          • Operation: Rd ← Rd • Rd
          • Operands: 0 ≤ d ≤ 31
          • Flags: Z,N,V,S
          • TST Instruction 사용 예:

            • tst r16 ; Test r16


    • Branch Instructions
      • Unconditional Branch instruction
        • JMP : Jump
          • Syntax: JMP k
          • Operation: PC ← k
          • Operands: 0 ≤ k < 4M
          • JMP Instruction 사용 예:

            • jmp loop ; Unconditional jump

            ...

            loop: nop ; Jump destination(do nothing)

        • IJMP : Indirect Jump
          • Syntax: IJMP
          • Operation: PC ← Z(15:0)
          • Operands: None
          • IJMP Instruction 사용 예:

            • ldi ZH,high(jumptable)

            ldi ZL,low(jumptable)

            ijmp ; Jump to routine pointed to by r31:r30

            ...

            jumptable: nop ; Jump destination(do nothing)

        • RJMP : Relative Jump
          • Syntax: RJMP k
          • Operation: PC ← PC + k + 1
          • Operands: (k -2K) ≤ k < 2K
          • RJMP Instruction 사용 예:

            • rjmp loop ; Unconditional branch

            ...

            loop: nop ; Jump destination(do nothing)


      • Conditional Branch instruction
        • BRcond : Branch on condition
          • Syntax: BRcond k ; cond에는 아래 Branch condition을 사용한다.
            • Branch condition(cond): EQ, NE , CS, CC, SH, LO, MI, PL, GE, LT, HS, HC, TS, TC,VS, VC, IE, ID
            • Branch condition 설명 예: EQ - Branch if Equal, NE - Branch if Not Equal, 기타 Condition은 참고자료: "AVR Instruction Set Manual.pdf"를 참고 요.
          • Operation: If (cond == true) then PC ← PC + k + 1, else PC ← PC + 1
          • Operands: -64 ≤ k ≤ +63
          • BRcond Instruction 사용 예:

            • cp r16,r17 ; Compare registers r16 and r17

            breq equal ; Branch if registers equal

            ...

            equal: nop ; Branch destination (do nothing)

      • Call Subroutine and Subroutine Return instruction
        • CALL : Long Call to a Subroutine
          • Syntax: CALL k
          • Operation: PC ← k, STACK ← PC+2, SP ← SP-2, (2 bytes, 16 bits)
          • Operands: 0 ≤ k < 64K
          • CALL Instruction 사용 예:

            • mov r16,r0 ; Copy r0 to r16

            call check ; Call subroutine

            ...

            check: cpi r16,$42 ; Check if r16 has a special value

            ...

            ret ; Return from subroutine

            ...

        • ICALL : Indirect Call to Subroutine
          • Syntax: ICALL
          • Operation: PC(15:0) ← Z(15:0), STACK ← PC + 1 SP ← SP - 2 (2 bytes, 16 bits)
          • Operands: None
          • ICALL Instruction 사용 예:

            • ldi ZH,high(subfun)

            ldi ZL,low(subfun)

            icall ; Call routine pointed to by r31:r30

            ...

            subfun: nop ; Jump destination(do nothing)

            ...

            ret ; Return from subroutine

        • RCALL : Relative Call to Subroutine
          • Syntax: RCALL k
          • Operation: PC ← PC + k + 1, STACK ← PC + 1, SP ← SP - 2 (2 bytes, 16 bits)
          • Operands: -2K ≤ k < 2K
          • RCALL Instruction 사용 예:

            • rcall routine ; Call subroutine

            ...

            routine:

            ...

            ret ; Return from subroutine

        • RET : Return from Subroutine
          • Syntax: RET
          • Operation: PC(15:0) ← STACK, SP ← SP + 2, (2 bytes, 16 bits)
          • Operands: None
          • RET Instruction 사용 예:

            • call routine ; Call subroutine

            ...

            routine:

            ...

            ret ; Return from subroutine

        • RETI : Return from Interrupt
          • Syntax: RETI
          • Operation: PC(15:0) ← STACK, SP ← SP + 2 (2 bytes, 16 bits)
          • Operands: None
          • Flags: I
          • RETI Instruction 사용 예:

            • ...

            extint: ; Interrupt이 발생할 때 Interrupt vector table를 참조하여 실행된다.

            ...

            reti ; Return and enable interrupts

      • Compare instruction
        • CP/CPC : Compare, Compare with Carry
          • Syntax: CP Rd, Rr / CPC Rd,Rr
          • Operation: Rd - Rr / Rd - Rr - C
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: Z,C,N,V,S,H
          • CP Instruction 사용 예:

            • cp r16,r17 ; Compare r16 with r17

            brne noteq ; Branch if r16 <> r17

            ...

            noteq: nop ; Branch destination (do nothing)

        • CPI : Compare with Immediate
          • Syntax: CPI Rd,K
          • Operation: Rd - K
          • Operands: 16 ≤ d ≤ 31, 0 ≤ K ≤ 255
          • Flags: Z,C,N,V,S,H
          • CPI Instruction 사용 예:

            • cpi r16,3 ; Compare r19 with 3

            brne noteq ; Branch if r16 <> 3

            ...

            noteq: nop ; Branch destination (do nothing)

        • CPSE : Compare Skip if Equal
          • Syntax: CPSE Rd,Rr
          • Operation: If Rd = Rr then PC ← PC + 2 (or 3) else PC ← PC + 1
          • Operands: 0 ≤ d ≤ 31, 0 ≤ r ≤ 31
          • Flags: None
          • CPSE Instruction 사용 예:

            • cpse r16,r17 ; Compare r16 to r17

            ...

            nop ; Continue (do nothing)

        • SBRC/SBRS : Skip if Bit in Register Cleared, Skip if Bit in Register Set
          • Syntax: SBRC Rr,b / SBRS Rr,b
          • Operation: If Rr(b) = 0 then PC ← PC + 2 (or 3) else PC ← PC + 1 / If Rr(b) = 1 then PC ← PC + 2 (or 3) else PC ← PC + 1
          • Operands: 0 ≤ r ≤ 31, 0 ≤ b ≤ 7
          • Flags: None
          • SBRC Instruction 사용 예:

            • sbrc r16,7 ; Skip if bit 7 in r16 cleared

            ...

            nop ; Continue (do nothing)

        • SBIC/SBIS : Skip if Bit in I/O Register is Cleared, Skip if Bit in I/O Register is Set
          • Syntax: SBIC A,b / SBIS A,b
          • Operation: If I/O(A,b) = 0 then PC ← PC + 2 (or 3) else PC ← PC + 1 / If I/O(A,b) = 1 then PC ← PC + 2 (or 3) else PC ← PC + 1
          • Operands: 0 ≤ A ≤ 31, 0 ≤ b ≤ 7
          • Flags: None
          • SBIC Instruction 사용 예:

            • e2wait: sbic $1C,1 ; Skip next inst. if EEWE cleared

            rjmp e2wait ; EEPROM write not finished

            nop ; Continue (do nothing)

    • Bit operation Instructions
      • Bit Operation Instructions
        • LSL/LSR : Logical Shift Left, Logical Shift Right
          • Syntax: LSL Rd / LSR Rd
          • Operation: C ← b7, b7 ← b6, ... , b1 ← b0, b0 ← 0 / 0 → b7, b7 → b6, ... , b1 → b0, b0 → C
          • Operands: 0 ≤ d ≤ 31
          • Flags: Z,C,N,V,H / Z,C,N,V
          • LSL/LSR Instruction 사용 예:

            • lsl r16 ; Multiply r16 by 2

            lsr r16 ; Divide r16 by 2

        • ROL/ROR : Rotate Left trough Carry, Rotate Right through Carry
          • Syntax: ROL Rd / ROR Rd
          • Operation: C ← b7, b7 ← b6, ... , b1 ← b0, b0 ← C / C → b7, b7 → b6, ... , b1 → b0, b0 → C
          • Operands: 0 ≤ d ≤ 31
          • Flags:Z,C,N,V,H / Z,C,N,V
          • ROL/ROR Instruction 사용 예:

            • lsl r16 ; Multiply r17:r16 by two

            rol r17 ; r17:r16 is a signed or unsigned two-byte integer

            ...

            lsr r17 ; Divide r17:r16 by two

            ror r16 ; r17:r16 is an unsigned two-byte integer

        • ASR : Arithmetic Shift Right
          • Syntax: ASR Rd
          • Operation: b7 → b7, b7 → b6, ... , b1 → b0, b0 → C
          • Operands: 0 ≤ d ≤ 31
          • Flags: Z,C,N,V
          • ASR Instruction 사용 예:

            • asr r17 ; Divide r17:r16 by two

            ror r16 ; r17:r16 is a signed two-byte integer

        • SWAP : Swap Nibbles
          • Syntax: SWAP Rd
          • Operation: R(7:4) ← Rd(3:0), R(3:0) ← Rd(7:4)
          • Operands: 0 ≤ d ≤ 31
          • Flags: None
          • SWAP Instruction 사용 예:

            • swap r16 ; Swap high and low nibble of r16

        • SBI/CBI : Set Bit in I/O Register, Clear Bit in I/O Register
          • Syntax: SBI A,b / CBI A,b
          • Operation: I/O(A,b) ← 1 / I/O(A,b) ← 0
          • Operands: 0 ≤ A ≤ 31, 0 ≤ b ≤ 7
          • Flags: None
          • SBI/CBI Instruction 사용 예:

            • sbi $1C,0 ; Set read bit in EECR

            cbi $12,7 ; Clear bit 7 in Port D

        • BST/BLD : Bit Store from Bit in Register to T Flag in SREG, Bit Load from the T Flag in SREG to a Bit in Register
          • Syntax: BST Rd,b / BLD Rd,b
          • Operation: T ← Rd(b) / Rd(b) ← T
          • Operands: 0 ≤ d ≤ 31, 0 ≤ b ≤ 7
          • Flags: T
          • BST/BLD Instruction 사용 예:

            • bst r16,2 ; Store bit 2 of r16 in T Flag

            bld r16,4 ; Load T Flag into bit 4 of r16

        • BSET/BCLR : Bit Set in SREG, Bit Clear in SREG
          • Syntax: BSET s / BCLR s
          • Operation: SREG(s) ← 1 / SREG(s) ← 0
          • Operands: 0 ≤ s ≤ 7
          • Flags: SREG(s)
          • BSET/BCLR Instruction 사용 예:

            • bset 7 ; Enable interrupt

            bclr 7 ; Disable interrupts

        • SEC/CLC : Set Carry Flag, Clear Carry Flag
          • Syntax: SEC / CLC
          • Operation: C ← 1 / C ← 0
          • Operands: None
          • Flags: C
          • SEC/CLC Instruction 사용 예:

            • sec ; Set Carry Flag

            clc ; Clear Carry Flag

        • SEN/CLN : Set Negative Flag, Clear Negative Flag
          • Syntax: SEN / CLN
          • Operation: N ← 1 / N ← 0
          • Operands: None
          • Flags: N
          • SEN/CLN Instruction 사용 예:

            • sen ; Set Negative Flag

            cln ; Clear Negative Flag

        • SEZ/CLZ : Set Zero Flag, Clear Zero Flag
          • Syntax: SEZ / CLZ
          • Operation: C ← 1 / C ← 0
          • Operands: None
          • Flags: Z
          • SEZ/CLZ Instruction 사용 예:

            • sez ; Set Zero Flag

            clz ; Clear zero

        • SEI/CLI : Set Global Interrupt Flag, Clear Global Interrupt Flag
          • Syntax: SEI / CLI
          • Operation: I ← 1 / I ← 0
          • Operands: None
          • Flags: I
          • SEI/CLI Instruction 사용 예:

            • sei ; set global interrupt enable

            cli ; Disable interrupts during timed sequence

        • SES/CLS : Set Signed Flag, Clear Signed Flag
          • Syntax: SES / CLS
          • Operation: S ← 1 / S ← 0
          • Operands: None
          • Flags: S
          • SES/CLS Instruction 사용 예:

            • ses ; Set Negative Flag

            cls ; Clear Signed Flag

        • SEV/CLV : Set Overflow Flag, Clear Overflow Flag
          • Syntax: SEV / CLV
          • Operation: V ← 1 / V ← 0
          • Operands: None
          • Flags: V
          • SEV/CLV Instruction 사용 예:

            • sev ; Set Overflow Flag

            clv ; Clear Overflow Flag

        • SET/CLT : Set T Flag, Clear T Flag
          • Syntax: SET / CLT
          • Operation: T ← 1 / T ← 0
          • Operands: None
          • Flags: T
          • SET/CLT Instruction 사용 예:

            • set ; Set T Flag

            clt ; Clear T Flag

        • SEH/CLH : Set Half Carry Flag, Clear Half Carry Flag
          • Syntax: SEH / CLH
          • Operation: H ← 1 / H ← 0
          • Operands: None
          • Flags: H
          • SEH/CLH Instruction 사용 예:

            • seh ; Set Half Carry Flag

            clh ; Clear the Half Carry Flag


      • Bit-test Instructions
        • Bit-test Instructions은 Branch Instructions을 참고 바람.
    • MCU Control Instructions
      • MCU Control Instructions
        • BREAK : Break

            • BREAK Instructions는 On-chip Debug system에서 사용되며 일반적으로 애플리케이션 소프트웨어에서는 사용되지 않는다. BREAK 명령이 실행되면 AVR CPU는 정지 모드로 설정된다. 이를 통해 On-chip Debugger가 내부 리소스에 액세스할 수 있다.

          • Syntax: BREAK
          • Operation: On-chip Debug system break.
          • Operands: None
          • Flags: None
        • NOP : No Operation

            • 이 Instruction은 한 사이클 동안 아무동작도 실행하지 않는다.

          • Syntax: NOP
          • Operation: No Operation
          • Operands: None
          • Flags: None
          • NOP Instruction 사용 예:

            • nop ; Wait (do nothing)

        • SLEEP : Sleep

            • 이 Instruction은 MCU 제어 레지스터에 의해 정의된 절전 모드로 회로를 설정한다.

          • Syntax: SLEEP
          • Operation: None
          • Operands: None
          • Flags: None
          • SLEEP Instruction 사용 예:

            • sleep ; Put MCU in sleep mode

        • WDR : Watchdog Reset

            • 이 Instruction은 Watchdog Timer를 재 설정한다. 이 명령은 WD prescaler에서 지정한 제한된 시간 내에 실행되어야 한다. Watchdog Timer 하드웨어 사양을 참조바람.

          • Syntax: WDR
          • Operation: WD timer restart.
          • Operands: None
          • Flags: None
          • WDR Instruction 사용 예:

            • wdr ; Reset watchdog timer


  • AVR ASM Instructions 관련 페이지 보기
    • 홈
    피드 구독하기: 글 (Atom)