Expt. No.

1 Multi byte Addition

Aim:
To write an Assembly Language Program for multi byte addition and execute the same using 8051
microcontroller kit

Component Required:
1. 8051 Microcontroller Kit - 1
2. Power Supply & Connecting wires - As required

Procedure:
● Switch ON the Power supply
● Follow the General procedures to operate the 8051 microcontroller kit
● Enter the corresponding opcodes of the instruction in the program
● Execute the program
● Verify the outputs from the microcontroller kit with manual calculations

Manual Calculation:
Let us take two 16 bit (2 byte) numbers and add it manually.

83A0 - 1000 0011 1010 0000

3F95 - 0011 1111 1001 0101
______________________
0 1100 0011 0011 0101
C 3 3 5
Program:
Address Label Mnemonics Opcode Comments

CLRC Good practice to clear the

carry flag before any
arithmetic operations

MOV A, # A0H Add the two LSB numbers

and store the result in A
ADD A, # 95H register itself

MOV DPTR, # 8450 H Make to point the DPTR to

external RAM at 8450
address location

MOVX @DPTR, A Move the A (i.e.) added

result to 8450 memory
location

INC DPTR Make the DPTR to point the

next location for storing the
MSB added result

MOV A, #83 H Add the two MSB numbers

and store the result in A
ADDC A, 3FH register itself

MOVX DPTR, A Move the MSB result in

DPTR pointed memory
locations

MOV R0, # 00H Assume to store CARRY

Flag value in R0 register

JNC LOOP Jump if no carry to LOOP

INC R0 Set the carry flag if carry

occurs

LOOP MOV A, R0 Move the carry contents

from RO to A register

INC DPTR Make to point the DPTR to

next location to store
CARRY Value

MOVX@ DPTR, A Move the CARRY value,

which is in Accumulator to
DPTR pointed memory
location

HERE SJMP HERE Make a endless loop

Actual Output:

Addend 83 A0

Adder 3F 95

Added Result

Output Address 8452 ( Carry ) 8451 H ( MSB ) 8450 H ( LSB )

Result:
The Multi byte addition program was entered in 8051 Microcontroller kit and output was verified with
manual calculations.
Expt. No.2 Multiplication & Division

Aim:
To write an Assembly Language Program for multiplication and division and execute the same using an
8051 microcontroller kit.

Component Required:
1. 8051 Microcontroller Kit - 1
2. Power Supply & Connecting wires - As required

Procedure:
● Switch ON the Power supply
● Follow the General procedures to operate the 8051 microcontroller kit
● Enter the corresponding opcodes of the instruction in the program
● Execute the program
● Verify the outputs from the microcontroller kit with manual calculations

Manual Calculation:
Let us take two 8 bit (2 bytes) numbers and multiply it manually.

5 X 4 = 20
5 - Multiplicand (8 bits)
4 - Multiplier (8 bits)
20 - Multiplied result (16 bits)

Let us take two 8 bit (2 bytes) numbers and Divide it manually.

21 / 4 = 5
21 - Dividend
4 - Divisor
5 - Quotient
1 - Remainder
Multiplication Program:
Address Label Mnemonics Opcode Comments

MOV A, # 05 H Move the multiplicand to A

register

MOV B, # 04 H Move the multiplier to B

register

MUL AB Multiplies A & B and stores

the result, LSB part in A and
MSB part in B registers
respectively

MOV DPTR, # 8450 H Make the data pointer to

point is such a way that to
store the result LSB and
MSB part in successive
memory locations

MOVX @DPTR, A Move the LSB result from A

register to data pointer
pointed memory location
8450 H

INC DPTR Make the Data pointer to

point next memory location

MOV A, B Move the MSB result from B

to A register

MOVX @DPTR, A Now move MSB result from

A register to Data pointed
memory location 8451 H

HERE SJMP HERE Makes a endless loop

Division Program:
Address Label Mnemonics Opcode Comments

MOV A, # 21 H Move the Dividend to A

register

MOV B, # 04 H Move the Divisor to B

register

DIV AB Divide A by B and stores the

result, Quotient part in A
and Remainder part in B
registers respectively

MOV DPTR, # 8450 H Make the data pointer to

point is such a way that to
store the results both
Quotient and Remainder
part in successive memory
locations

MOVX @DPTR, A Move the Quotient result

from A register to data
pointer pointed memory
location 8450 H

INC DPTR Make the Data pointer to

point next memory location

MOV A, B Move the Remainder result

from B to A register

MOVX @DPTR, A Move Remainder result from

A register to Data pointed
memory location 8451 H

HERE SJMP HERE Make a endless loop

Actual Output: Multiplication
A register
(Multiplicand)

B register
(Multiplier)

Multiplied Result

Output Address 8451 H ( MSB ) 8450 H ( LSB )

Actual Output: Division

A register
(Dividend)

B register
(Divisor)

Division Result

Output Address 8451 H ( Remainder ) 8450 H ( Quotient )

Result:
Thus the Multiplication & Division program was entered in 8051 Microcontroller kit and output was
verified with manual calculations.
Expt. No.3 Sorting an Array in Ascending order

Aim:
To write an Assembly Language Program for sorting operation in ascending order for a given array of
data and execute the same using an 8051 microcontroller kit.

Component Required:
1. 8051 Microcontroller Kit - 1
2. Power Supply & Connecting wires - As required

Procedure:
● Switch ON the Power supply
● Follow the General procedures to operate the 8051 microcontroller kit
● Enter the corresponding opcodes of the instruction in the program
● Execute the program
● Verify the outputs from the microcontroller kit with manual calculations
Flowchart:
Start

Place unsorted 5 data in memory

locations starting from 9200H

Initialize registers R0 & R1 for outer and inner loop

operations and DPTR to the unsorted memory
locations

Push the DPTR address to

Stack

Hold the first Data in B register and the second data

in A register respectively

Compare A & B
and Check for

NO
YE
POP the DPTR address from
STACK

Interchange the values such

that it stores in ascending order

Decrement R1 & make Inner Loop Untill R1 becomes

Zero

Decrement R0 & make outer Loop Untill R0 becomes

Zero

Stop
Program:
Address Label Mnemonics Opcode Comments

MOV R0, #05H Length of the array stored in

R0 & R1
AGAIN MOV A, R0

MOV R1, A

MOV DPTR, #9200H Data pointer made to point

first memory location

DPTR ← 9200

FIRST PUSH DPH (83) Move the Memory Location

to the stack
PUSH DPL (82)

MOVX A, @ DPTR Data present inside Data

pointer address will be
moved to accumulator

MOV B , A B register holds the A

register value

INC DPTR DPTR ← DPTR +1

MOVX A, @DPTR A ← [ DPTR ]

CJNE A, B, NEXT Compare A & B and Jump

if not equal to NEXT
pointed memory location

NEXT JNC LOOP Jump on NO Carry to LOOP

pointed memory Location

POP DPL Retrieve the data from stack

for interchanging
POP DPH

MOVX@ DPTR, A Interchanging the values in

ascending order
INC DPTR

MOV A,B

MOVX @DPTR, A

LOOP DJNZ R1, FIRST Decrement R1 and Jump if

non zero to FIRST pointed
memory location

Inner Loop
 DJNZ R0, AGAIN Decrement R0 and Jump if
non zero to AGAIN pointed
memory location

Outer Loop

HERE SJMP HERE

Actual output
:
INPUT OUTPUT

Memory Address Data Memory Address Data

9200 45 9200

9201 58 9201

9202 8A 9202

9203 12 9203

9204 93 9204

Result:
Thus the 8051 microcontroller program for ascending order sorting was entered in the microcontroller
kit and the output was tabulated and verified.
Expt. No.4 ASCII to Binary Conversion

Aim:
To write an Assembly Language Program for ASCII to Binary Conversion and execute the same using
an 8051 microcontroller kit

Component Required:
1. 8051 Microcontroller Kit - 1
2. Power Supply & Connecting wires - As required

Procedure:
● Switch ON the Power supply
● Follow the General procedures to operate the 8051 microcontroller kit
● Enter the corresponding opcodes of the instruction in the program
● Execute the program
● Verify the outputs from the microcontroller kit with manual calculations
 ASCII to Binary Conversion
Flow chart
Start

Place data in memory locations

9100H

Move the data from 9100 to A

register

Compare A & 40H

and Check for

NO

YE
CARR
Y?
NO
Clear CARRY
Flag

Subtract A with 07H

Clear CARRY
Flag

Subtract A with 30H

Increment DPTR

Move the result contents from A to

DPTR pointed memory location

Stop
Program:
Address Label Mnemonics Opcode Comments

MOV DPTR, # 9100H 9100 ← 45 [Assumed]

MOVX A, @DPTR A ← 45

CJNE A, #40 H, LOOP Compare 45 with 40, if it’s

not equal jump to label
LOOP

LOOP JC NEXT Jump on CARRY to NEXT

location

CLRC CF ← 0

SUBB A, # 07 H A ← 3E

NEXT CLRC Clear CARRY Flag

CF ← 0

SUBB A, # 30 H Subtract with borrow

A ← 3E - 30
A←E

INC DPTR DPTR ← 9101

MOVX @DPTR, A 9101 ← E

HERE SJMP HERE

Actual output:
INPUT OUTPUT

Memory Address ASCII Data Memory Address Binary Data

9100 9101

Result:
Thus the 8051 microcontroller program for ASCII to Binary Conversion was entered in the kit and the
output was tabulated and verified.
Expt. No.5 Parity Bit Generator

Aim:
To write an Assembly Language Program for parity bit generation and execute the same using an 8051
microcontroller kit.

Component Required:
1. 8051 Microcontroller Kit - 1
2. Power Supply & Connecting wires - As required

Procedure:
● Switch ON the Power supply
● Follow the General procedures to operate the 8051 microcontroller kit
● Enter the corresponding opcodes of the instruction in the program
● Execute the program
● Verify the outputs from the microcontroller kit with manual calculations
 Parity Bit [Even] Generation
Flow chart
Start

Place data in memory locations

8500H

As shifting process to be carried based on bit size, and

we have 8 bits in total in a register, Initialize R0 looping
register with 08H

Initialize register R1 with 00H, to store the number of 1’s

occurance

Move the contents from Data pointed memory location to

Accumulator

Rotate with CARRY instruction for 8 times will make all

the eight bits in A register to pass through the CARRY
Flag

NO
CARRY
FLAG

YE
Increment register R1 by
1

After the above process we have total 1’s occurrences

count in R1 Register, divide it by 2 by using DIV AB
instruction, We get the result in B register the
remainder value

Increment DPTR and Move the contents from B to

DPTR pointed memory through A register

Stop
Program:
Address Label Mnemonics Opcode Comments

MOV R0, #08 H R0 ← 8 LOOP SIZE

MOV DPTR, # 8500H DPTR ← 8500

MOV R1, # 00H R1  00 H

MOVX A, @DPTR A  [DPTR]

NEXT RRC A Rotate right with carry storing

the 1’s in carry bit

JNC LOOP Jump instruction for checking

CARRY bit

INC R1 R1 ← holds the number of

1’s

LOOP DJNZ R0, NEXT Loop for 8 times

MOV A, R1 Move the number of 1’s in A

register from R1 register

MOV B, # 02 H B←2

DIV AB Divide by 2 to check even or

not

MOV A, B Move the Remainder in A

INC DPTR Increment DPTR

MOVX @DPTR, A Store the result in DPTR

memory

HERE SJMP HERE

Actual output:
INPUT OUTPUT

Memory Address Data Memory Address Parity Bit

8500 8501

Result:
Thus the 8051 microcontroller program for parity bit generation was entered in the kit and the output
was tabulated and verified.