TRIBHUVAN UNIVERSITY

INSTITUTE OF ENGINEERING
Pulchowk, Lalipur

A
Lab Report
On
Embedded System
Lab1

Submitted By: Submitted To:

Name: Saroj Kumar Katwal Department of Electronics
Group: B And Computer Engineering
Roll No: 074BCT536
Theory:

MICROCONTROLLER 8051

The Intel 8051 microcontroller is one of the most popular general-purpose

microcontrollers in use today. The 8051 Microcontroller is one of the basic type of
microcontroller which is based on Harvard Architecture and developed primarily for
use in embedded systems technology. Normally, this microcontroller was developed
using NMOS technology, which requires more power to operate. The 8051
Microcontroller has two buses and two memory spaces of 64K X 8 size for program
and data units. It has an 8-bit processing unit and 8-bit accumulator units.

A. 8051 Microcontroller Architecture

1) Central Processor Unit (CPU): The CPU controls as well as monitors all the
operations being performed in the Microcontroller. The CPU reads program
written in ROM memory and executes them and do the expected task of that
application.

2) Memory: A Microcontroller reads its instructions from a memory. A program

which is a collection of instructions for a Microcontroller is stored in the
memory. The memory which is used to store the program of the
microcontroller is known as code memory or Program memory of
applications. It is known as ROM memory of microcontroller also requires a
memory to store data or operands temporarily of the micro controller. The
data memory of the 8051 used to store data temporarily for operation is
known RAM memory. 8051 microcontrollers has 4K of code memory or
program memory that has 4KB ROM and also 128 bytes of data memory of
RAM.

3) BUS: Bus is a collection of wires that work as a communication channel or

medium for transfer of Data. These buses consist of 8, 16 or more wires of
the microcontroller. Thus, these can carry 8 bits, 16 bits simultaneously. The
two types of microcontroller buses are:
Address Bus: Microcontroller 8051 has a 16-bit address bus for transferring
the data. It is used to address memory locations and to transfer the address
from CPU to Memory of the microcontroller.
Data Bus: Microcontroller 8051 has an 8-bit data bus, which carries data in
and out of the microcontroller.
 4) Input/output Port: Normally microcontroller is used in embedded systems to
control the operation of machines in the microcontroller. Therefore, to
connect it to other machines, devices or peripherals we require I/O interfacing
ports in the microcontroller interface. For this purpose, microcontroller 8051
has 4 inputs, output ports to connect it to the other peripherals.

SIMULATION SOFTWARE

A. Keil Vision
It is an embedded development tool. It is used for programming in both assembly
and c programming. It is also used for generating the hex file required for burning
in the hardware implementation or hardware simulation.

B. Proteus Design Suite

It is used for different purposes such as professional PCB layout, circuit design
and simulation etc. It is used in simulation of hardware. It contains different
functions and components required for the hardware simulation. Hex files can
be used and implemented in the designed hardware simulation to check the
output of the program before it is used in practical hardware.
Fig. Port 0 of 8051 Microcontroller used to interface with LEDs.
Problem 1:
Assembly Code:- C Code:
#include<regx51.h>
ORG 00H unsigned long int d _at_ 0x40;

MOV R0,#9AH void delay(int i){

MOV R1,#7FH unsigned int j,k;
MOV R2,#89H for(j=0;j<i;j++)
MOV R3,#48H for(k=0;k<1275;k++);
MOV R4,#0BCH }
MOV R5,#34H
MOV A,R0 void main(void){
ADD A,R3 unsigned long int num1 = 0x897F9A;
MOV 40H,A unsigned long int num2 = 0x34BC48;
MOV A,R1 unsigned char* dptr = 0x40;
ADDC A,R4 unsigned int count = 0x00;
MOV 41H,A P0=0x00;
MOV A,R2 d = num1+num2;
ADDC A,R5 while(1){
MOV 42H,A if(count<4){
JNC SKIP P0 = *dptr;
MOV 43H,#1H dptr++;
delay(250);
count++;
}
SKIP: MOV R0,#40H else{
MOV R1,#04H count=0;
SKIP1: MOV A,@R0 dptr = 0x40;
MOV P0,A }
INC R0 }
ACALL DELAY }
DJNZ R1, SKIP1
SJMP SKIP

DELAY: MOV R6,#25

HERE1: MOV R7,#255
HERE2: MOV B,#255
HERE3: DJNZ B,HERE3
DJNZ R7,HERE2
DJNZ R6,HERE1
RET
END
Problem 2:
Assembly Code:- C Code:

ORG 00h #include <reg51.h>

MOV A,#6BH void delay(int time){

MOV B,A int i,j;
RR A for (i=0;i<=time;i++)
RR A for (j=0;j<1275;j++);
RR A }
RR A
void main()
AGAIN: MOV P0,B {
ACALL DELAY unsigned long int num1,num2,num3,a;
MOV P0,A a= 0x6B;
ACALL DELAY P0=0x00;
SJMP AGAIN num1 = a;
num2 = (a & 0x0F);
DELAY: MOV R6,#25 a = num1;
HERE1: MOV R7,#255 num3 = (a & 0xF0);
HERE2: MOV R5,#255 a = (num3 / 0x10 + num2 * 0x10);
HERE3: DJNZ R5,HERE3 num2 = a;
DJNZ R7,HERE2
DJNZ R6,HERE1 while (1)
RET {
P0 = num1;
END delay(200);
P0 = num2;
delay(200);
}
}
Problem 3:
Assembly Code:- C Code:

ORG 00h #include<regx51.h>

MOV 22H,#0FFH unsigned int multiplier _at_ 0x22;
MOV 15H,#0DEH unsigned int multiplicand _at_ 0x15;
MOV R0,22H unsigned int result _at_ 0x19;
MOV R1,15H unsigned char* dptr=0x19;
MOV A,#00H
CLR C void delay(int i)
LBIT: ADD A,R0 {
JNC SKIP unsigned int j,k;
INC B for(j=0; j<i; j++)
SKIP: DJNZ R1, LBIT for(k=0; k<1200; k++);
MOV 19H,A }
MOV 1AH,B
AGAIN: MOV P0,19H void main(){
ACALL DELAY int count=0x00;
MOV P0,1AH multiplicand=0xFF;
ACALL DELAY multiplier=0xDE;
SJMP AGAIN P0=0x00;
result=multiplicand*multiplier;
DELAY: MOV R6,#25 while(1){
HERE1: MOV R7,#255 if(count<0x02){
HERE2: MOV R5,#255 P0=*dptr;
HERE3: DJNZ R5,HERE3 dptr++;
DJNZ R7,HERE2 delay(250);
DJNZ R6,HERE1 count++;
RET }
else
END {
count=0x00;
dptr=0x19;
}
}
}
Problem 4:
Assembly Code:- C Code:-

ORG 00h #include<regx51.h>

MOV 3EH,#0AFH
MOV A,3EH unsigned int dividend _at_ 0x3E;
CLR C
void delay(int i)
LBIT: SUBB A,#12H {
JC SKIP unsigned int j,k;
INC R6 for(j=0; j<i; j++)
JMP LBIT for(k=0; k<1200; k++);
SKIP: ADD A,#12H }
MOV R5,A
void main(void)
AGAIN: MOV P0,R6 {
ACALL DELAY unsigned int divisor = 0x12;
MOV P0,R5 unsigned int quotient = 0x00;
ACALL DELAY dividend = 0xAF;
SJMP AGAIN while(dividend >= divisor)
{
DELAY: MOV R1,#25 dividend-=divisor;
HERE1: MOV R7,#255 quotient++;
HERE2: MOV R2,#255 }
HERE3: DJNZ R2,HERE3 while(1)
DJNZ R7,HERE2 {
DJNZ R1,HERE1 P0 = quotient;
RET delay(200);
P0 = dividend;
END delay(200);
}
}
Problem 5:
Assembly Code:- C Code:

ORG 00H #include<regx51.h>

MOV 50H,#0D6H unsigned int nums[10] _at_ 0x50;
MOV 51H,#0F2H void delay(int i)
MOV 52H,#0E4H {
MOV 53H,#0A8H unsigned int j,k;
MOV 54H,#0CEH for(j=0; j<i; j++)
MOV 55H,#0B9H for(k=0; k<1200; k++);
MOV 56H,#0FAH }
MOV 57H,#0AEH void main(void)
MOV 58H,#0BAH
{
MOV 59H,#0CCH
int largest,smallest,i;
MOV R0,#50H nums[0]=0xD6;
MOV R3,50H nums[1]=0xF2;
MOV R4,50H nums[2]=0xE4;
MOV R1,#09H nums[3]=0xA8;
AGAIN: CLR C nums[4]=0xCE;
INC R0 nums[5]=0xB9;
MOV A,R3 nums[6]=0xFA;
SUBB A,@R0 nums[7]=0xAE;
MOV A,@R0 nums[8]=0xBA;
JC LARGEST
nums[9]=0xCC;
MOV R3,A
LARGEST: MOV A,R4
CLR C largest = nums[0];
SUBB A,@R0 smallest = nums[0];
MOV A,@R0 for(i=1; i<10; i++)
JNC CHECK {
MOV R4,A if(nums[i]<smallest)
CHECK: DJNZ R1,AGAIN {
smallest = nums[i];
AGAI: MOV P0,R3 }
ACALL DELAY
else if(nums[i]>largest)
MOV P0,R4
{
ACALL DELAY
SJMP AGAI largest = nums[i];
}
}
DELAY: MOV R6,#25 while(1)
HERE1: MOV R7,#255 {
HERE2: MOV R2,#255 P0=smallest;
HERE3: DJNZ R2,HERE3 delay(200);
DJNZ R7,HERE2 P0=largest;
DJNZ R6,HERE1 delay(200);
RET }
}
END
Problem 6(i):
Assembly Code:- C Code:
ORG 00h #include<regx51.h>
MOV 60H,#0A5H unsigned nums[10] _at_ 0x60;
MOV 61H,#0FDH void delay(int i)
MOV 62H,#067H {
MOV 63H,#042H unsigned int j,k;
MOV 64H,#0DFH for(j=0; j<i; j++)
MOV 65H,#09AH for(k=0; k<1200; k++);
MOV 66H,#084H }
MOV 67H,#01BH void main(void)
MOV 68H,#0C7H {
MOV 69H,#031H int i,j,temp;
ASDNG: MOV R0,#60H nums[0]=0xA5;
MOV R1,#00H nums[1]=0xFD;
MOV R2,#09H nums[2]=0x67;
CHECK: CLR C nums[3]=0x42;
MOV A,@R0 nums[4]=0xDF;
INC R0 nums[5]=0x9A;
MOV R3,A nums[6]=0x84;
SUBB A,@R0 nums[7]=0x1B;
MOV A,R3 nums[8]=0xC7;
JC NXTBYT nums[9]=0x31;
MOV B,@R0
MOV @R0,A for(i=0; i<9; i++)
DEC R0 {
MOV @R0,B for(j=0; j<9; j++)
INC R0 {
MOV R1,#01H if(nums[j]>nums[j+1])
NXTBYT: DJNZ R2,CHECK {
CJNE R1,#01H,AGAIN temp = nums[j];
SJMP ASDNG nums[j] = nums[j+1];
AGAIN: MOV R0,#0AH nums[j+1] = temp;
MOV R1,#60H }
NEXT: MOV P0,@R1 }
ACALL DELAY }
INC R1 while(1)
DJNZ R0,NEXT {
SJMP AGAIN for(i=0; i<10; i++)
DELAY: MOV R6,#25 {
HERE1: MOV R7,#255 P0 = nums[i];
HERE2: MOV R5,#255 delay(200);
HERE3: DJNZ R5,HERE3 }
DJNZ R7,HERE2 }
DJNZ R6,HERE1 }
RET
END
Problem 6(ii):
DELAY: MOV R6,#25
Assembly Code:- HERE1: MOV R7,#255
ORG 00h
HERE2: MOV R5,#255
MOV 60H,#0A5H
HERE3: DJNZ R5,HERE3
MOV 61H,#0FDH
DJNZ R7,HERE2
MOV 62H,#067H
DJNZ R6,HERE1
MOV 63H,#042H
RET
MOV 64H,#0DFH
END
MOV 65H,#09AH
MOV 66H,#084H
MOV 67H,#01BH C Code:
MOV 68H,#0C7H #include<regx51.h>
MOV 69H,#031H unsigned int nums[10] _at_ 0x60;
CLR C void delay(int i){
unsigned int j,k;
DSDNG: MOV R0,#60H for(j=0;j<i;j++)
MOV R7,#09H for(k=0;k<1200;k++);
LOOP: MOV A,@R0 }
MOV 50H,R0 void main(void){
MOV R1,50H int i,j,largest,laarge,datnum;
RPT: INC R1 nums[0]=0xA5;
MOV B,A nums[1]=0xFD;
SUBB A,@R1 nums[2]=0x67;
MOV A,B nums[3]=0x42;
JNC NXT+ nums[4]=0xDF;
MOV B,A nums[5]=0x9A;
MOV A,R1 nums[6]=0x84;
MOV R5,A nums[7]=0x1B;
MOV A,B nums[8]=0xC7;
MOV A,@R1 nums[9]=0x31;
NXT: CJNE R1,#69H,RPT for(i=0;i<9;i++){
MOV B,@R0 largest = nums[i];
MOV @R0,A laarge = nums[i];
MOV A,R5 for(j=i+1;j<=9;j++){
MOV R1,A if(largest<nums[j]){
MOV @R1,B largest = nums[j];
INC R0 datnum = j;
DJNZ R7,LOOP }}
AGAIN: MOV R0,#0AH nums[i]=nums[datnum];
MOV R1,#60H nums[datnum]=laarge;
NEXT: MOV P0,@R1 }
ACALL DELAY while(1){
INC R1 for(i=0;i<10;i++){
DJNZ R0,NEXT P0 = nums[i];
SJMP AGAIN delay(200);
}}}
Problem 7:
Assembly Code:- DELAY: MOV R6,#25
ORG 00h
HERE1: MOV R7,#255
MOV R1,#40H
HERE2: MOV R5,#255
MOV R2,#21H
HERE3: DJNZ R5,HERE3
MOV A,#0H
DJNZ R7,HERE2
STORE: MOV @R1,A
DJNZ R6,HERE1
INC A
RET
INC R1
DJNZ R2,STORE
END
MOV R1,#40H
MOV R0,#61H C Code:
MOV 25H,#00H #include<regx51.h>
TOP: MOV 20H,#00H unsigned int nums[0x20] _at_ 0x40;
MOV A,@R1 void delay(int i){
ACALL CHEKP unsigned int j,k;
MOV A,20H for(j=0; j<i; j++)
CJNE A,#02H,CHKTOP for(k=0; k<1200; k++);
MOV A,@R1 }
MOV @R0,A void main(void){
INC R0 int i,j,div,prime[0x20],rem,count;
INC 25H int count2=0x00;
CHKTOP: INC R1 for(i=0x00; i<=0x20; i++)
CJNE R1,#61H,TOP nums[i] = i;
for(i=0x00; i<=0x20; i++){
DISPLAY: MOV R1,#61H div=nums[i]/2;
MOV R3,25H if(div!=0){
NEXT: MOV P0,@R1 count=0;
ACALL DELAY for(j=div; j>=1; j--){
INC R1 rem = (nums[i]%j);
DJNZ R3,NEXT if(rem==0){
SJMP DISPLAY count++;
}
CHEKP: CJNE A,#00H,CHECK }
RET if(count>1){
CHECK: MOV R3,#01H prime[count2]=nums[i];
MOV R4,A count2++;
AG: MOV B,R3 }
DIV AB }
XCH A,B }
CJNE A,#00H,CK while(1){
INC 20H for(i=0; i<count2; i++){
CK: INC R3 P0 = prime[i];
MOV A,@R1 delay(200);
DJNZ R4,AG }
RET }
Problem 8:
Assembly Code:- C Code:
ORG 00H #include<regx51.h>
MOV R3,#05H
ACALL FACT void delay(int i)
ACALL FACTD {
AGAIN: MOV P0,40H unsigned int j,k;
ACALL DELAY for(j=0; j<i; j++)
ACALL DELAY for(k=0; k<1200; k++);
ACALL DELAY }
MOV P0,45H
ACALL DELAY void main(void)
MOV P0,46H {
ACALL DELAY int i,num,num2,m=0,n=0,j;
ACALL DELAY num=1;
ACALL DELAY j=5;
SJMP AGAIN for(i=j; i>=1; i--)
FACT: MOV A,R3 {
MOV R4,A num*=i;
MOV A,#01H }
GO: MOV B,R4 num2=num;
MUL AB while(num2>=0x0A)
DJNZ R4,GO {
MOV 40H,A if(num2>0x64)
RET {
FACTD: MOV A,40H num2-=0x64;
MOV B,#0AH m++;
DIV AB }
MOV R5,B else if(num2<0x64)
MOV B,#0AH {
DIV AB num2-=0x0A;
MOV R6,A n++;
MOV A,#10H }
MUL AB }
ADD A,R5 num2=0x10*n+num2;
MOV 45H,R6 while(1)
MOV 46H,A {
RET P0 = num;
DELAY: MOV R6,#25 delay(400);
HERE1: MOV R7,#255 P0=m;
HERE2: MOV R5,#255 delay(200);
HERE3: DJNZ R5,HERE3 P0=num2;
DJNZ R7,HERE2 delay(400);
DJNZ R6,HERE1 }
RET }

END
Problem 9:
Assembly Code:- C Code:-
ORG 00h #include<regx51.h>
MOV 55H,#25H unsigned int nums[10] _at_ 0x55;
MOV 56H,#3DH void delay(int i){
MOV 57H,#0F7H unsigned int j,k;
MOV 58H,#13H for(j=0; j<i; j++)
MOV 59H,#0C9H for(k=0; k<1200; k++);
MOV 5AH,#4EH }
MOV 5BH,#62H void main(void){
MOV 5CH,#77H int i,j,seq[10],num1,num2,count,count2=0;
MOV 5DH,#0B8H nums[0]=0x25;
MOV 5EH,#0EBH nums[1]=0x3D;
MOV R0,#55H nums[2]=0xF7;
MOV R1,#60H nums[3]=0x13;
MOV R3,#00H nums[4]=0xC9;
CONT: MOV R2,#07H nums[5]=0x4E;
MOV A,@R0 nums[6]=0x62;
GO: MOV B,A nums[7]=0x77;
ANL A,#03H nums[8]=0xB8;
CJNE A,#03H,NXT nums[9]=0xEB;
MOV A,@R0 for(i=0; i<10; i++){
MOV @R1,A num1=nums[i];
INC R1 count=0;
INC R3 for(j=0; j<8; j++){
JMP AGN num2 = num1 & 0x03;
NXT: MOV A,B if(num2==0x03){
RR A count=1;
DJNZ R2,GO break;
AGN: INC R0 }
CJNE R0,#60H,CONT num1 = num1 >> 1;
MOV 70H,R3 }
PRINT: MOV R0,#60H if(count==1){
PRINT1: MOV R3,70H seq[count2]=nums[i];
MOV P0,@R0 count2++;
ACALL DELAY }
INC R0 }
DJNZ R3,PRINT1 while(1){
SJMP PRINT for(i=0; i<count2; i++){
DELAY: MOV R6,#25 P0=seq[i];
HERE1: MOV R4,#255 delay(250);
HERE2: MOV R5,#255 }
HERE3: DJNZ R5,HERE3 }
DJNZ R4,HERE2 }
DJNZ R6,HERE1
RET
END
Outputs:
1.
 897F9AH + 34BC48H = BE3B2EH

2.
 Output: 6BH, B6H
3.
 [19H] = DDH and [1AH] = 22H

4.
 R4 = Quotient = 09H ; R5 = Remainder = 0DH
5.
 Largest Number = FAH ; Smallest Number = A8H

6.
Ascending
6.
Descending

7.
 Prime Numbers: 2,3,5,7,11,13,17,19,23
8.
 78H(120)
9.
Ans: 3DH, F7H, 13H, C9H, 4EH, 62H, 77H, B8H, EBH
Discussion:

Assignment – 1:
In this assignment, we carried out addition of two three-bytes numbers 897F9AH
and 34BC48H and saved the result in internal RAM starting at 40H. When two
numbers are added, the carry cannot be greater than 1 so if there was carry, it would
have been stored in location 43H. Then the result was displayed continuously on the
LEDs of the development board starting from the LSB with proper delay between
each byte. Port 0 of the microcontroller was used to interface with the LEDs. When
port 0 is used for interfacing purpose, we need to used pull-up resistor before getting
output at the LEDs since all the other ports have internal pull ups but not port 0.

Assignment – 2:
Although we have SWAP A instruction set for swapping the nibbles within the
accumulator, we used rotate right instruction to swap the nibbles of the accumulator
content. The original number contained in the accumulator is 6BH which was
displayed in the LEDs, then the nibbles were swapped and displayed in the LEDs.

Assignment – 3:
Though we have MUL AB instruction set to multiply two one-byte numbers stored
in accumulator A and register B, we used looping and successive addition
mechanism to perform multiplication operation. The multiplicand FFH was stored
in the RAM location 22H and multiplier DEH was stored in 15H. Then the result
was stored in the RAM location 19H (low byte) and 1AH (high byte). The multiplier
was used as counter and successive addition of multiplicand was carried out until
the multiplier is reduced to zero. Finally, the result i.e. high byte and low byte were
displayed continuously on the LEDs of the development board one by one with an
appropriate delay between them.

Assignment – 4:
We have DIV AB instruction set to carry out division of two one-byte numbers
provided that B doesn’t contain 0. However, we are using looping and successive
subtraction mechanism to perform the division operation. The dividend AFH was
stored in the memory location 3EH and the divisor was 12H. Then the quotient and
remainder were stored in the register R4 and R5 respectively. The divisor was
subtracted from the dividend if dividend didn’t come out to be negative. Finally, the
quotient and remainder were displayed continuously on the LEDs of the
development board one by one with an appropriate delay between them.
Assignment – 5:
Out of ten hexadecimal numbers stored in the internal RAM starting from memory
location 50H, we have to determine the largest and the smallest number. For this
purpose, at first, we considered the first number as the smallest number and the
largest. Then it was compared with every other numbers and replaced the number in
case the other number came out to be smaller than the smallest number assumed.

Assignment – 6:
For Ascending Order sorting we implemented Bubble sort and for descending order
we implemented Selection sort algorithm.

Assignment -7:
The numbers from 00H to 20H were stored in the internal RAM starting from
memory location 40H and we are to implement a subroutine such as to extract only
the prime numbers and display them continuously in the development board one by
one with appropriate delay between them. 0 and 1 are neither prime nor composite,
hence these were not displayed.

Assignment – 8:
To find the factorial of the number stored in register R3 where value in R3 could be
any number in the range from 00H to 05H only. We implemented a subroutine to
calculate factorial of the number in which we stored the value of the number stored
in R3 in R2 and decremented it in each iteration to multiply them continuously until
the number was reduced to 0. If the number is equal to 0 on comparison directly 1 is
assigned. Then another subroutine was defined to convert the factorial of the number
so obtained in hexadecimal format to decimal format. Hence, the so obtained
factorial of the number in both hexadecimal and decimal format were displayed
continuously on the LEDs of the development board one by one with an appropriate
delay between them.

Assignment -9:
Ten hexadecimal numbers are stored in the RAM and the subroutine is created that
searches the number having binary sequence (11)2. Those numbers are continuously
displayed in the LEDS.
Conclusion:
In this lab we learnt about the 8051 microcontroller. We gained knowledge about
different instructions and how to use them to make the microcontroller do a
particular task. After doing this lab we were able to write programs in assembly
language and C language for 8051 microcontrollers that can perform operation such
as data manipulation, branching and looping and subroutine calls. We used Proteus
for the simulation of circuit design.