1

Microcontroller Fundamentals &

Programming

Logical Instructions

2

Logic Instructions

Consist AND, OR, EOR (XOR) and COM instructions.

Contents of accumulator operated logically, bit by bit, with corresponding bit in the memory.

The result after logic instruction will be placed back in accumulator.

C flag will not change. Only N and Z flags will change according to the result.

3

Logic Instructions – Block Diagram

Accumulator

Result back to accumulator Memory

0 0 1 1 1 1 0 0

0 0 0 0 1 1 1

1

AND, OR, EOR operation

CCRN Z

N & Z flags change

4

ANDA , ANDB

AND operation is used to clear or mask off any bit to “0” with other bits unchanged.

Example: To clear bit 0 to bit 3 of ACCA

LDAA #$5A $5A = 0101 1010

ANDA #$F0 ; $F0 = 1111 0000 AND Operation

; $50 = 0101 0000 Results go to ACCA

Result: ACCA = $50 ; Flag bits : N = “0” , Z = “0”

AND Instructions

5

ORAA , ORAB

OR operation is used to set any bit to “1” with other bits unchanged.

Example: To set bit 0 and 7 of ACCB

LDAB #$1A ; $1A = 0001 1010

ORAB #$81 ; $81 = 1000 0001 OR Operation

; $9B = 1001 1011 Results to ACCB

Result: ACCB = $9B ; Flag bits : N = “1” , Z = “0”

OR Instructions

6

EORA , EORB (Exclusive OR)

EOR operation is used to invert any bits from a “1” to “0” and vice versa in accumulators A or B.

Example: Invert Bit-0 ~ 3 of ACCB

LDAB #$5A ; $5A = 0101 1010

EORB #$0F ; $0F = 0000 1111 EOR Operation

; $55 = 0101 0101 Results to ACCB

Result: ACCB =$55 ; Flag bits : N = “0” , Z = “0”

EOR Instructions

7

Complement InstructionsExample:

COMA, COMB, COM

Instruction will invert all the 8-bit contents in accumulator A or B or memory location.

N and Z flag bits will change according to the result.

C flag will set to “1”.

8

MNEMONICS COMMENTS

CLRA ; ACCA = $00

COMA ; ACCA = $FF

LDAB #$F0 ; ACCB = $F0

COMB ; ACCB = $0F

CLR $8000 ; contents of memory location

; ($8000) = $00

COM $8000 ; contents of memory location

; ($8000) = $FF.

Example: Complement Instructions

9

Example:

BITA , BITB

An 8-bit logical test instructions.

Bit instructions operate similar to AND operation.

After executing Bit instructions :

• no result will be saved.

• only the flags in CCR are updated.

• N and Z flag bits will change according to the result.

• V flag will automatically set to “0”.

Bit Instructions

10

Example: Bit Instructions

LDAA $1000 ; the 8-bit data in memory location

; ($1000) = %1100 0000

BITA #%00110011 ; %11000000 AND with ; %00110011 ; Results = (%00000000) ; N = “0” , Z = “1”

BNE READKEY ; result not equal zero ; branch to READKEY routine.

Let value in memory ($1000) = %1100 0000

11

Bit Instructions

Instructions Addressing modes

Comments

BITA #$35 IMM ACCA AND with $35

BITB #%00001100 IMM ACCB AND with $0C

BITB $90 DIR ACCB AND with data in memory $90

BITA $8000 EXT ACCA AND with data in memory ($8000)

BITA $10,X IND,X ACCA AND with data in memory ($10 + X)

12

Example:

BCLR, BSET

Bit clear instructions will clear any 8-bit directly

in memory location.

Bit set instructions will set any 8-bit directly in

memory location.

N and Z flag bits will change according to the

result.

V flag will set to “0”.

Bit Clear and Bit Set Instructions

13

Instructions Addressing Comments Modes

LDX #$2000 IMM IX = $2000

BCLR $10,$30 DIR bit 4,5 of memory ($10) are cleared to “0”.

BSET $20,$0C DIR bit 2,3 of memory ($20) are set to “1”

BCLR $10,X,$30 IND,X bit 4,5 of memory ($10+X)

are cleared to “0”.

Example: Bit Clear and Bit Set Instructions

14

Instructions Addressing Comments Modes

LDX #$2000 IMM IX = $2000

BCLR $10,%00110000 DIR bit 4,5 of memory ($10) are cleared to “0”.

BSET $20,%00001100 DIR bit 2,3 of memory ($20) are set to “1”

BCLR $10,X,%00110000 IND,X bit 4,5 of memory ($10+X)

are cleared to “0”.

Example: Bit Clear and Bit Set Instructions

15

Shift & Rotate Instructions Consist of Logical Shift , Arithmetic Shift

and Rotate instructions.

Move 8-bit values in accumulator or memory, including the C-flag, by 1-bit to the left or right.

N, Z and C flags in CCR will change according to result.

Types of addressing modes : INH, EXT, INDX & INDY.

16

Example: Shift Left : LSL , LSLA , LSLB

Logical Shift Left:

shift 8-bit value 1 place to the left. Bit-7 is shifted into C-bit .a “0” is placed into bit-0.

Shifting binary number 1 bit to the left each time will multiply the original number by 2.

“0”B7 B6 B5 B4 B3 B2 B1

B0C

Memory orAccumulator

Logical Shift Left Instructions

17

Example: Logical Shift Left instructionsMnemonics C-flag ACCA Decimal

Value

LDAA #$22 0 0010 0010 3410

LSLA 0 0100 0100 6810

LSLA 0 1000 1000 13610

LSLA 1 0001 0000 1610

LSLA 0 0010 0000 3210

18

Example: Shift Right : LSR , LSRA , LSRB

Logical Shift Right:

• shift the 8-bit value 1 place to the right. •Bit-0 is shifted into C-bit •a “0” is placed into bit-7.

Shifting binary number 1 bit to the right

each time will divide the original number by

2.

B7 B6 B5 B4 B3 B2 B1 B0

C“0”

Memory orAccumulator

Logical Shift Right Instructions

19

Example: Logical Shift Right instructionsMnemonics ACCA C-flag Decimal Value

LDAA #$24 0010 0100 0 3610

LSRA 0001 0010 0 1810

LSRA 0000 1001 0 0910

LSRA 0000 0100 1 0410

LSRA 0000 0010 0 0210

20

Arithmetic Shift Left Instructions

Arithmetic Shift Left:

- Operation same as Logical shift left .

Example:

Shift Left : ASL , ASLA , ASLB , ASLD

“0”B7 B6 B5 B4 B3 B2 B1

B0C

Memory orAccumulator

21

Example: Arithmetic Shift Left instructions

Mnemonics Accumulator A

LDAA #$32 0 0 1 1 0 0 1 0

ASLA 0 1 1 0 0 1 0 0

Mnemonics Accumulator A

LDAA #$32 0 0 1 1 0 0 1 0

LSLA 0 1 1 0 0 1 0 0

Arithmetic Shift Left is same as Logical Shift Left .

22

Arithmetic Shift Right Instructions

Arithmetic Shift Right: shift 8-bit data (accumulator or memory) 1 place to the right.

Bit-0 data is shifted into C-bit.

The sign bit or bit-7 remains unchanged.

Example:

Shift Right : ASR , ASRA , ASRB

B7 B6 B5 B4 B3 B2 B1 B0

C

Memory orAccumulator

23

Example: Arithmetic Shift Right instructions

Mnemonics Accumulator B C-flag

LDAB #$C2 1 1 0 0 0 0 1 0 0

ASRB 1 1 1 0 0 0 0 1 0

ASRB

1 1 1 1 0 0 0 0 1

ASRB 1 1 1 1 1 0 0 0 0

24

Rotate Left Instructions

Rotate Left :

shift 8-bit value (accumulator or memory) 1 place to the left.

Bit-7 is shifted into C-bit and

C-bit is placed into bit-0.

Example:

Rotate Left : ROL , ROLA , ROLB

B7 B6 B5 B4 B3 B2 B1 B0

C

25

Example: Rotate Left instructions

Mnemonics C-flag Accumulator A

LDAA #$F0 0 1 1 1 1 0 0 0 0

ROLA 1 1 1 1 0 0 0 0 0

ROLA 1 1 1 0 0 0 0 0 1

ROLA 1 1 0 0 0 0 0 1 1

26

Rotate Right Instructions

Rotate Right :

shift 8-bit value (accumulator or memory) 1 place to the right.

Bit-0 is shifted into C-bit and

C-bit is placed into bit-7.

C

B7 B6 B5 B4 B3 B2 B1 B0

Example:

Rotate Right : ROR , RORA , RORB

27

Example: Rotate Right instructions

Mnemonics Accumulator B C-flag

LDAB #$0F 0 0 0 0 1 1 1 1 0

RORB 0 0 0 0 0 1 1 1 1

RORB 1 0 0 0 0 0 1 1 1

RORB 1 1 0 0 0 0 0 1 1

28

Thank You