8051 Instructions

and
Timing Diagram
MODULE II
Instruction types
The instructions of 8051 Microcontroller can be classified into five different groups. These
groups are like below
◦ Data Transfer Group
◦ Arithmetic Group
◦ Logical Group
◦ Program Branch Group
◦ Bit Processing Group (Boolean Variable Manipulation)
Like 8085, some instruction has two operands. The first operand is the Destination, and the
second operator is Source.
Notations
In the following examples, you will get some notations. The notations
are like this −
Rn = Any register from R0 to R7
Ri = Either R0 or R1
d8 = Any 8-bit immediate data (00H to FFH)
d16 = 16-bit immediate data
a8 = 8-bit address
bit = 8-bit address of bit which is bit addressable
rel = 8-bit signed displacement. The range is -128 to 127. It is relative to the first
byte of the instruction.
Data Transfer
Cont..
Stack
• Stack-oriented data transfer
– Only one operand (direct addressing)
– SP is other operand – register indirect - implied
• Direct addressing mode must be used in Push and Pop
mov sp, #0x40 ; Initialize SP
push 0x55 ; SP  SP+1, M[SP]  M[55]
; M[41]  M[55]
pop b ; b  M[55]
Note: can only specify RAM or SFRs (direct mode) to push or pop. Therefore,
to push/pop the accumulator, must use acc, not a
Stack (push,pop)
• Therefore
Push a ;is invalid
Push r0 ;is invalid
Push r1 ;is invalid
push acc ;is correct
Push psw ;is correct
Push b ;is correct
Push 13h
Push 0
Push 1
Pop 7
Pop 8
Push 0e0h ;acc
Pop 0f0h ;b
Exchange Instructions
Arithmetic Instructions
• Add
• Subtract
• Increment
• Decrement
• Multiply
• Divide
• Decimal adjust
Arithmetic Instructions
Mnemonic Description
ADD A, byte add A to byte, put result in A
ADDC A, byte add with carry
SUBB A, byte subtract with borrow
INC A increment A
INC byte increment byte in memory
INC DPTR increment data pointer
DEC A decrement accumulator
DEC byte decrement byte
MUL AB multiply accumulator by b register
DIV AB divide accumulator by b register
DA A decimal adjust the accumulator
ADD Instructions
add a, byte ; a  a + byte
addc a, byte ; a  a + byte + CY
These instructions affect 3 bits in PSW:
C = 1 if the result of add is greater than FF
AC = 1 if there is a carry-out of bit 3
OV = 1 if there is a carry-out of bit 6th to 7th, but not from bit 7th
Instructions that Affect PSW bits
ADD Examples
• is the value of the
What
mov a, #3Fh CY, AC, OV flags after the
add a, #D3h second instruction is
executed?
0011 1111 CY= 1
1101 0011
0001 0010 AC = 1
OV = 1
SUBB A, byte
Subtract
subtract with borrow

Example:
SUBB A, #0x4F ;A  A – 4F – C
Notice that
There is no subtraction WITHOUT borrow.
Therefore, if a subtraction without borrow is desired,
it is necessary to clear the C flag.
Example:
Clr c
SUBB A, #0x4F ;A  A – 4F
Increment and Decrement
INC A increment A
INC byte increment byte in memory
INC DPTR increment data pointer
DEC A decrement accumulator
DEC byte decrement byte

• The increment and decrement instructions do NOT affect the C flag.

• Notice we can only INCREMENT the data pointer, not decrement.
Example: Increment 16-bit Word
• Assume 16-bit word in R3:R2

mov a, r2
add a, #1 ; use add rather than increment to affect C
mov r2, a
mov a, r3
addc a, #0 ; add C to most significant byte
mov r3, a
Multiply
When multiplying two 8-bit numbers, the size of the maximum
product is 16-bits

FF x FF = FE01
(255 x 255 = 65025)
MUL AB ; BA  A * B
Note : B gets the High byte
A gets the Low byte
Division
• Integer Division
DIV AB ; divide A by B

A  Quotient(A/B)
B  Remainder(A/B)

OV - used to indicate a divide by zero condition.

C – set to zero
Decimal Adjust
DA a ; decimal adjust a
Used to facilitate BCD addition.
Adds “6” to either high or low nibble after an addition
to create a valid BCD number.

Example:
mov a, #23h
mov b, #29h
add a, b ; a  23h + 29h = 4Ch (wanted 52)
DA a ; a  a + 6 = 52
Logic Instructions
❑ Bitwise logic operations
❖ (AND, OR, XOR, NOT)
❑ Clear
❑ Rotate
❑ Swap

Logic instructions do NOT affect the flags in PSW

Bitwise Logic
ANL ➔ AND
ORL ➔ OR
XRL ➔ XOR
CPL ➔ Complement
CLR ( Set all bits to 0)
CLR A
CLR byte (direct mode)
CLR Ri (register mode)
CLR @Ri (register indirect mode)
Other Logic Instructions
CLR - clear
RL – Rotate left
RLC – Rotate left through carry
RR – Rotate right
RRC – Rotate right through carry
SWAP – swap accumulator nibbles
Rotate
• Rotate instructions operate only on a
RL a
Mov a,#0xF0 ; a 11110000
RR a ; a 11100001

RR a
Mov a,#0xF0 ; a 11110000
RR a ; a 01111000
Rotate through Carry
C
RRC a
mov a, #0A9h ; a  A9 (10101001)
add a, #14h ; a  BD (10111101), C0
rrc a ; a  01011110, C1

RLC a C

mov a, #3ch ; a  3ch(00111100)

setb c ; c  1
rlc a ; a  01111001, C1
Rotate and Multiplication/Division
• Note that a shift left is the same as multiplying by
2, shift right is divide by 2

mov a, #3 ; A 00000011 (3)

clr C ; C 0
rlc a ; A 00000110 (6)
rlc a ; A 00001100 (12)
rrc a ; A 00000110 (6)
Swap
SWAP a

mov a, #72h ; a  72h

swap a ; a  27h
Bit Logic Operations
• Some logic operations can be used with single bit operands

ANL C, bit
ORL C, bit
CLR C
CLR bit
CPL C
CPL bit
SETB C
SETB bit

• “bit” can be any of the bit-addressable RAM locations or SFRs.

Program Flow Control
• Unconditional jumps (“go to”)

• Conditional jumps

• Call and return

Unconditional Jumps
• SJMP <rel addr> ; Short jump,
relative address is 8-bit 2’s complement number, so
jump can be up to 127 locations forward, or 128
locations back.

• LJMP <address 16> ; Long jump

• AJMP <address 11> ; Absolute jump to

anywhere within 2K block of program memory

• JMP @A + DPTR ; Long indexed jump

Infinite Loops

Start: mov C, p3.7

mov p1.6, C
sjmp Start
Microcontroller application programs are almost always infinite loops!
Conditional jumps
Mnemonic Description
JZ <rel addr> Jump if a = 0
JNZ <rel addr> Jump if a != 0
JC <rel addr> Jump if C = 1
JNC <rel addr> Jump if C != 1
JB <bit>, <rel addr> Jump if bit = 1
JNB <bit>,<rel addr> Jump if bit != 1
JBC <bir>, <rel addr> Jump if bit =1, &clear bit

CJNE A, direct, <rel addr> Compare A and memory, jump if

not equal
Example: Conditional Jumps
if (a = 0) is true
send a 0 to LED
else
send a 1 to LED

jz led_off
Setb P1.6
sjmp skipover
led_off: clr P1.6
mov A, P0
skipover:
More Conditional Jumps
Mnemonic Description
CJNE A, #data <rel addr> Compare A and data, jump if not
equal
CJNE Rn, #data <rel addr> Compare Rn and data, jump if not
equal
CJNE @Rn, #data <rel addr> Compare Rn and memory, jump if
not equal
DJNZ Rn, <rel addr> Decrement Rn and then jump if not
zero

DJNZ direct, <rel addr> Decrement memory and then jump if

not zero
Iterative Loops
For A = 0 to 4 do For A = 4 to 0 do
{…} {…}

clr a mov R0, #4

loop: ... loop: ...
... ...
inc a djnz R0, loop
cjne a, #4, loop
Call and Return

• Call is similar to a jump, but

– Call pushes PC on stack before branching

acall <address ll> ; stack  PC

; PC  address 11 bit

lcall <address 16> ; stack  PC

; PC  address 16 bit
Return

• Return is also similar to a jump, but

– Return instruction pops PC from stack to get
address to jump to

ret ; PC  stack
Timing Diagrams
1 byte instruction (1 machine cycle)
2 byte instruction (1 machine cycle)
1 byte instruction (2 machine cycle)
Timing for MOVX instruction
TIMING DIAGRAM examples
END OF SLIDES