8051 Manual Fin

Microcontrollers Lab Manual 06ESL47
KVG COLLEGE OF ENGINEERING

Electronics and Communications
Micro
Controller
Lab Manual
Dept. Of E & C Engg KVGCE,Sullia

1. DATA TRANSFER INSTRUCTIONS

1. Write A Program to move a block of data within the internal RAM
Algorithm
1. Initialize registers to hold
a. the count, the number of data bytes to be moved,
b. the starting addresses of source block
c. starting addresses of destination block.
2. Get data from source location into accumulator
3. Transfer accumulator content to the destination location.
4. Decrement the count register
5. Update data pointers.
6. Check whether all the bytes are transferred or not. ie, if count is not
zero repeat step 2 through 6.
PROGRAM CODE:
ORG 0H
START1: MOV R0,#40H ;R0 POINTED TO INTERNAL RAM 40H
MOV R1,#30H ;R1 POINTING TO INTERNAL RAM 030H
MOV R2,#5 ;R2 LOADED WITH NO. OF ELEMENTS IN `
;THE ARRAY
START: MOV A,@R0 ;DATA TRANSFER
MOV @R1,A
INC R0
INC R1
DJNZ R2,START ;DECREMENT R2,IF NOT EQUAL TO ;
0,CONTINUE WITH DATA
;TRANSFER PROCESS.
HERE: SJMP HERE
END
RESULT:
Before Execution: Fill 5 locations at I:0040h with data bytes.
5 locations at I:0030h are blank.
After Execution: 5 locations I:0040h are filled up with data. These are copied
to 5 locations at I:0030h .

2) Write an assembly language program to transfer n =10 bytes of data

from location 8035h to location 8041h within External RAM.(without
overlap). Write the code at C:030h
Algorithm
1. Initialize registers to hold
a. the count, the number of data bytes to be moved,
b. the starting addresses of source block
c. starting addresses of destination block.
2. Get data from source location into accumulator and transfer to the
destination location.
3. Update data pointers.
4. Decrement the count register, repeat step 2-3 if count is not zero.
PROGRAM CODE:
ORG 0000H
SJMP 30H
ORG 30H
MOV DPH,#80H ; source/Desti address Higher order Byte
MOV R0,#35H ;//source address Low Byte
MOV R1,#41H ;//destination address Low Byte
MOV R3,#0AH ;//count
BACK: MOV DPL, R0
MOVX A,@DPTR
MOV DPL, R1
MOVX @DPTR,A
INC R0
INC R1
DJNZ R3, BACK
HERE: SJMP HERE
END
RESULT:
Before Execution: 10 locations at X:8035h are to be filled up with data.
After Execution: 10 locations at X:8041h are filled up with data from 8035h.

3) Write an ALP to move a block of 6 data bytes ,stored in internal

RAM starting at location 10h to locations starting at 13h.(Block move
with overlapped memory addresses)
Algorithm:
1. Initialize registers to hold the count of number of data bytes to be
moved, the source address and the shift(difference between
destination addresses and source address).
2. Compute addresses of last locations of destination and source blocks.
and set the pointers(using bank registers R0 & R1)
3. Get data from source location into accumulator
4. Transfer accumulator content to the destination location.
5. Decrement the count, update data pointers(Decrement R0&R1).
6. Check whether all the bytes are transferred or not. ie, if count is not
zero repeat step 3 through 6.
Note: To transfer the Block to a memory with overlapped memory address
the pointers are to be pointed to the end of the blocks
Program Code:
ORG 0
MOV R1,#10H ;SOURCE BLOCK
MOV R2,#6H ;NUMBER OF ELEMENTS TO BE ;MOVED(BLOCK
SIZE)
MOV R3,#3H ;SHIFT
MOV A,R1
ADD A,R2
MOV R1,A
ADD A,R3
MOV R0,A
LOOP:DEC R0
DEC R1
MOV A,@R1
MOV @R0,A
DJNZ R2,LOOP
END
Results:
Before Execution: locations from I:0010h are filled up with data bytes.
After Execution: data bytes from I:0010h are moved to i:0013h

4. EXCHANGE BLOCKS OF DATA.

Write an ALP to exchange 5 bytes of data stored in locations starting
from 0027h with 5 bytes in locations starting from 0041h of external
memory.Use Bank Registers to hold memory addresses.
Algorithm
1. Initialize bank registers to hold the array size (count), the block_1
address & the block_2 addresses.
2. Get data from block_1 location into accumulator and save in a
register temporarily (Say / Use R2).
3. Get data from the block_2 location into accumulator and store in
block_1 location
4. Get the data from temporary register(R2) and store in block_1
locations.
5. Decrement the count register and repeat from step 2 to 4 till count is
zero.
Program Code:
ORG 00H
MOV R0,#27H //source address
MOV R1,#41H //destination address
MOV R3,#05H //count
BACK: MOVX A,@R0
MOV R2,A
MOVX A,@R1
MOVX @R0,A
MOV A, R2
MOVX @R1,A
INC R0
INC R1
DJNZ R3, BACK
HERE: SJMP HERE
END
ii) Write the program using XCH instruction
ORG 0000H
SJMP 30H
ORG 30H
MOV R0,#27H //source address
MOV R1,#41H //destination address
MOV R3,#05H //count
BACK: MOVX A,@R0
MOV R2,A
MOVX A,@R1
XCH A, R2

MOVX @R1,a
XCH A, R2
MOVX @R0,a
INC R0
INC R1
DJNZ R3, BACK
HERE: SJMP HERE
END
RESULT:
Before Execution: 5 locations at X:0027h & X:0041h are filled up with data.
After Execution: The data at X:0027h & X:0041h are exchanged.
LAB Assignments:
1) Write an ALP to move a block of 10 data bytes, stored in external RAM
starting at location 8050h to internal RAM locations at 30h.
2) Write an ALP to move a block of 10 data bytes, stored in internal RAM
starting at location 10h to locations in external RAM starting at 30h.
(i) Use DPTR ii) Bank registers to point to External RAM locations.
3) Write an ALP to move a block of 10 data bytes, stored in external RAM
starting at location 8050h to locations starting at 8055h.
4) Write an ALP to Reverse a block of 10 data bytes, stored in internal RAM
starting at location 10h
5) Write an ALP to exchange 10 data bytes, stored in internal RAM starting
at location 20h with data bytes, stored in internal RAM locations starting at
35h.
at location 20h with data bytes, stored in external RAM locations starting at
35h
at location 20h with data bytes, stored in external RAM locations starting at
8035h
8) Write an ALP to exchange 10 data bytes, stored in external RAM
starting at location 8020h with data bytes, stored in external RAM locations
starting at 8035h

5) ASSEMBLY LANGUAGE PROGRAM TO SORT NUMBERS.

//BUBBLE SORT PROGRAM
Write an assembly language program to sort an array of n= 6 bytes of
data in ascending order stored from location 8035h.(use bubble sort
algorithm)
ORG 0000H
SJMP 30H
ORG 30H
MOV R0,#05 //count n-1 -ARRAY SIZE-n- Pass Counter
L1: MOV dptr, #9000h //array stored from address 9000h
MOV A,R0 //initialize exchange counter
MOV R1,A
L2: MOVX a, @dptr //GET NUMBER FROM ARRAY
MOV B, A //& STORE IN B
INC dptr
MOVX a, @dptr //next number in the array
CLR C //reset borrow flag
MOV R2, A //STORE IN R2
SUBB A, B //2nd - 1st no.—no compare instruction in 8051
JC NOEXCHG // JNC - FOR ASCENDING ORDER
MOV A,B //EXHANGE THE 2 NOES IN THE ARRAY
MOVX @dptr,a
DEC DPL //DEC dptr-INSTRUCTION NOT PTRESENT
MOV a,R2
MOVX @dptr,a
INC DPTR
NOEXCHG: DJNZ R1,L2 //decrement compare counter
DJNZ R0,L1 //decrement pass counter
here: SJMP here
END

Algorithm
1. Store the elements of the array from the address 9000h
2. Initialize a pass counter with array size-1 count (for number of
passes).
3. Load compare counter with pass counter contents & initialize DPTR
to point to the start address of the array (here 9000h).
4. Store the current and the next array elements pointed by DPTR in
registers B and r2 respectively.
5. Subtract the next element from the current element.
6. If the carry flag is set (for ascending order) then exchange the 2
numbers in the array.
7. Decrement the compare counter and repeat through step 4 until the
counter becomes 0.
8. Decrement the pass counter and repeat through step 3 until the
counter becomes 0.
RESULT:
Before Execution:Unsorted Array at 9000h
After Execution: Sorted Array (Descending order) at 9000h
4) Write an assembly language program to find the largest element in a

given string of n = 6 bytes at location 4000h. Store the largest element
at location 4062h.
ORG 0000H
SJMP 30H
ORG 30H
MOV R3,#6 //length of the array
MOV DPTR,#4000H //starting address of the
array
MOVX A,@DPTR
MOV r1,a
NEXTBYTE: INC DPTR
MOVX A,@DPTR
CLR C //reset borrow flag
MOV R2,A //next number in the array
SUBB A,R1 //OTHER Num - PREVIOUS LARGEST
no.
JC skip // JNC for smallest element
MOV A,r2 //UPDATE larger number in r1
MOV R1,A
skip:DJNZ R3,NEXTBYTE

MOV DPL, #62H //LOCATION OF THE RESULT-4062H

MOV A,R1 //LARGEST NUMBER
MOVX @DPTR,A //STORE AT #4062H
OVER: SJMP OVER
END
Algorithm
2. Store the length of the array in r3 and set it as counter.
3. DPTR is loaded with starting address of the array.
4. Store the first number of the array in r1 (r1 is assigned to hold the
largest number).
5. Increment DPTR.
6. Subtract the number pointed by DPTR from the contents of r1 (to
compare whether the next array element is larger than the one in r1).
7. If the element pointed by DPTR is larger then load the larger number
into r1.
8. Decrement the counter and repeat steps through 5 until the counter
becomes 0.
9. Store the largest number in r1 in address 4062h
RESULT:
Before Execution:
After Execution: Location 4062 has the largest element.
2. ARITHMETIC INSTRUCTIONS
ASSEMBLY LANGUAGE PROGRAM ILLUSTRATING ADDITION,
SUBTRACTION, MULTIPLICATION AND DIVISION .
5) Write an ALP to perform the following:
If x=0-perform w + v; else if x=1-perform w-v; else if x=2-perform w*v; elseif
x=3-perform w/v, where w & v are eight bit numbers.
ORG 0000H
SJMP 30H
ORG 30H
MOV R0, #40H
MOVX A,@R0
MOV R1, A //R1 HAS CONDITION X
INC R0
MOVX A,@R0
MOV B, A //B HAS 1ST NUMBER-v
INC R0
MOVX A,@R0 //A HAS 2ND NUMBER-w

CJNE R1,#00,CKSUB
ADD A,B //PERFORM ADDITION
MOV B,#00 //B HAS CARRY
JNC SKIP
MOV B,#01H
SKIP:SJMP LAST
CKSUB: CJNE R1,#01,CKMUL
CLR C //RESET BORROW FLAG
SUBB A,B
MOV B,#00 //B INDICATES BORROW
JNC SKIP1
MOV B,#0FFH //FF INDICATES NEGATIVE NUMBER
SKIP1:SJMP LAST
CKMUL: CJNE R1,#02,CKDIV
MUL AB //16 bit product in AB with A having lower
byte
SJMP LAST
CKDIV: CJNE R1,#03,OTHER
DIV AB //Quotient in A & remainder in B
SJMP LAST
OTHER:MOV A,#00
MOV B,#00
LAST: INC R0
MOVX @R0,A
INC R0
MOV A,B
MOVX @R0,A
HERE:SJMP HERE
END
Algorithm
1. Store the condition x in r1.
2. Load the first and second numbers to A and B registers respectively
3. Compare the contents of r1 and perform the operations add, sub, etc
accordingly.
4. Store the result present in A and B registers to the appropriate
memory locations.
RESULT:Before Execution: ADD SUB
After Execution: ADD After Execution: SUB
Before Execution: MUL After Execution: MUL


ASSEMBLY PROGRAM ILLUSTRATING SQUARE AND CUBE

OPERATIONS.
//cube is an example of 16-bit arithmetic operation
//depending on flag condition, square or cube is performed
// Flag is a bit in the bit addressable RAM, say 1st bit of location 20h is
used, then bit address is 01
6) An eight bit number X is stored in external memory location 9000h. Write
an ALP to compute (i) the square of the number X if LSB of data RAM 20h
(bit address 01H) is set
(ii) the cube of the number X if LSB of data RAM 20h (bit address 01H) is
reset.
Store your result at locations 9001, 9002, 9003h.
ORG 0000H
SJMP 30H
ORG 30H
MOV DPTR,#9000H
MOVX A,@DPTR //GET NUMBER-X
MOV R0,A //STORE IN R0
MOV B,A
MUL AB //SQUARE IT-X^2
CLR C //FOR STORING RESULT
JB 01,LAST //IF BIT 01 IS SET THEN END, ELSE DO
CUBE
PUSH B //STORE UPPER PART OF SQUARE
MOV B,A //B-LOWER PART OF X^2
MOV A,R0 //A-X
MUL AB //X*LOWER X^2
INC DPTR
MOVX @DPTR,A //STORE PARTIAL RESULT
MOV A,B
MOV R2,A //UPPER PART OF X*LOWER X^2 IN R2
POP B //GET BACK UPPER PART OF SQUARE
MOV A,R0 //A-X
MUL AB //X*UPPER X^2
ADD A,R2 //ADD TO PARTIAL RESULT
LAST:INC DPTR
MOVX @DPTR,A
MOV A,B
ADDC A,#00 //ADD CARRY TO B(FOR SQUARE RESULT,
C=0)
INC DPTR
MOVX @DPTR,A
HERE:SJMP HERE
END
RESULT:
CUBE OF 56H IS 9B498 WHICH IS STORED AS 98, B4, 09 (LOWER BYTE
FIRST)

To get square make the D1 bit of data memory 20h high, say FF,02,06,etc.
The bit address is 01. Similarly bit address 78h correspond to D0 bit 0f data
ram location 2Fh.
Algorithm
1. Store the eight bit number x in A, r0 & B registers.
2. Multiply A and B registers to obtain the square (say SQH:SQL) of
the number x.
3. Check if bit 01 is set. If set go to end (storing the result), else do the
cube operations.
4. The high part of the square result (SQH) is stored on the stack.
5. Multiply the low part of the square result (SQL) with x (partial cube
result).
6. Store the low part of the above result at 9001h & the high part in R2.
7. Retrieve the high part of the square result (SQH) stored on the stack
& multiply with x.
8. Add the low part of the above result (SQH*X) with R2 and store in
9002h.
9. Add the high part (SQH*X) with the resulting carry and store in 9003.
3. PROGRAM ILLUSTRATING BIT MANIPULATIONS

7) Two eight bit numbers NUM1 & NUM2 are stored in external memory
locations 8000h & 80001h respectively. Write an ALP to compare the 2 nos.
Reflect your result as: if NUMI<NUM2, SET LSB of data RAM 2F (bit
address 78H)
IF NUM1>NUM2, SET MSB OF 2F(7FH). if NUM1 = NUM2-Clear both LSB
& MSB of bit addressable memory location 2Fh
ORG 0000H
SJMP 30H
ORG 30H
MOV DPTR,#8000H
MOVX A,@DPTR
MOV R0,A
INC DPTR
MOVX A,@DPTR
CLR C
SUBB A,R0
JZ EQUAL
JNC BIG
SETB 78H

SJMP END1
BIG:SETB 7FH
SJMP END1
EQUAL:CLR 77H
CLR 7FH
END1:SJMP END1
END
Algorithm:
2. Move the first number in r0 and the second number in register A
respectively
3. Clear carry flag and subtract the two numbers, if the carry flag is 0(if
the nos are equal), Clear both LSB & MSB of bit addressable memory
location 2Fh
4. If the carry bit is set then Set MSB of 2F(7FH), else LSB of data RAM
2F (bit address 78H).
RESULT: 1) Before Execution: X:08000h = 45 & X:8001 = 35

After Executuion: D:02FH =01
2) Before Execution: X:08000h = 25 & X:8001 = 35
3) Before Execution: X:08000h = 45 & X:8001 = 45
4. LOGICAL INSTRUCTIONS
8) ASSEMBLY PROGRAM ILLUSTRATING LOGICAL INSTRUCTIONS
(BYTE LEVEL)
3 eight bit numbers X, NUM1 & NUM2 are stored in internal data RAM
locations 20h, 21h & 22H respectively. Write an ALP to compute the
following.
IF X=0; THEN NUM1 (AND) NUM2, IF X=1; THEN NUM1 (OR) NUM2,
IF X=2; THEN NUM1 (XOR) NUM2, ELSE RES =00, RES IS 23H
LOCATION
ORG 0000H
SJMP 30H
ORG 30H
MOV A, 20h //donot use #, as data ram 20h is to be accessed
MOV R1,A //X IN R1
MOV A,21H //A -NUM1
CJNE R1,#0,CKOR
ANL A, 22H
SJMP END1
CKOR:CJNE R1,#01,CKXOR
ORL A, 22H
SJMP END1
CKXOR:CJNE R1,#02,OTHER
XRL A, 22H
SJMP END1
OTHER: CLR A
END1: MOV 23H,A //STORE RESULT

HERE: SJMP HERE

END
Algorithm:
1. Point to the data RAM register 20h and store the condition x.
2. Point to 21h and 22h and move the first number to A register.
3. Compare the contents of r1 and perform the operations accordingly.
4. The result will be stored in 23H register.
RESULT: 1)Before Execution: D:020H =00, 21=0f, 22 = 12
After Execution D:023H = 02
2)Before Execution: D:020H =01, 21=0f, 22 = 12
After Execution D:023H = 1F
After Execution D:023H = 1D
After Execution D:023H = 00
The above program can also be written as shown below (using indirect
addressing)
ORG 0000H
SJMP 30H
ORG 30H
mov r0,#20h
MOV A,@R0 //ON CHIP DATA RAM-DONOT USE
MOVX
MOV R1,A //X IN R1
INC R0
MOV A,@R0 //A -NUM1
INC R0 // R0 POINTS TO NUM2
CJNE R1,#0,CKOR
ANL A, @R0
SJMP END1
CKOR:CJNE R1,#01,CKXOR
ORL A, @R0
SJMP END1
CKXOR:CJNE R1,#02,OTHER
XRL A, @R0
SJMP END1
OTHER: CLR A
END1:INC R0
MOV @R0,A //STORE RESULT
HERE:SJMP HERE
END
Boolean variable instructions are also called as bit level logical
instructions
9) 3 eight bit numbers X, NUM1 & NUM2 are stored in internal data RAM
locations 20h, 21h & 22H respectively. Write an ALP to compute the
following.
IF X=0; THEN LSB OF NUM1 (AND) LSB OF NUM2,
IF X=1; THEN MSB OF NUM1 (OR)MSB OF NUM2 ,
IF X=2; THEN COMPLEMENT MSB OF NUM1

STORE THE BIT RESULT IN RES, WHERE RES IS MSB OF 23H

LOCATION
ORG 00H
SJMP 30h
ORG 30h
MOV R0,20H //R0-X
CJNE R0,#0,CK1
MOV C,08H //LSB OF NUM1 (21H) - BIT ADDRESS
-08
ANL C,10H //LSB OF NUM2 (22H) - BIT ADDRESS
-10
SJMP LAST
CK1:CJNE R0,#1,CK2
MOV C,0FH //MSB OF NUM1 (21H) - BIT ADDRESS
-0F
ANL C,17H //MSB OF NUM2 (22H) - BIT ADDRESS
-17
SJMP LAST
CK2:CJNE R0,#2,CK3
CPL 0FH
MOV C,0FH //MSB OF NUM1 (21H) - BIT ADDRESS
-0F
SJMP LAST
CK3:CLR C
LAST:MOV 1FH,C //RES IS MSB OF 23H LOCATION -1FH
HERE:SJMP HERE
END
RESULT: 20h = 00 => AND OF LSBs=1 (hence 80 in 23h location)
20h = 01 => OR of MSBs = 0 (hence 00 in 23h location)
20h = 01 =>complement of MSB of 21h location. Hence 21h is changed to

A1 and 23h location has 80h
Before Execution After Execution
Algorithm:
1. Move the condition X (from 20h location) into R0 register.

2. If X=0; then move LSB bit of 21h to carry flag and ‘AND’ Carry flag
with LSB bit of 22h. Goto step5
3. If X=1; then move MSB bit of 21h to carry flag and ‘OR’ Carry flag
with MSB bit of 22h. Goto step5
4. If X=0; then complement MSB bit of 21h and move it to carry flag.
Goto step5
5. Store Carry flag at MSB bit of 23h location.
5. COUNTERS
ASSEMBLY PROGRAM ILLUSTRATING HEX UP/DOWN COUNTERS.
//counter program - hex/binary counters
10) Write an ALP to implement (display) an eight bit up/down binary (hex)
counters on watch window.
Note: to run this program, after selecting DEBUG session in the main menu
use
View-> Watch& call Stack window, in the Watches select watch
1(or 2) and
press F2 and enter a (for accumulator A)
ORG 0H
SJMP 30H
ORG 0H
MOV a,#00
BACK: ACALL DELAY
INC a //dec a for binary down counter
JNZ BACK
HERE:SJMP HERE
DELAY: MOV r1,#0FFH

DECR1:MOV r2,#0FFH
DECR: MOV r3,#OFFH
DJNZ r3,$
DJNZ r2,DECR
DJNZ r1,DECR1
RET
END
RESULT: Accumulator A is incremented in binary from 00, 01,02…09,0A,

0B,…,0F,10,11,…FF

Algorithm:
1. Move 00 to A register
2. Call the delay subroutine for 1 second, in delay program move FFH to
registers r1, r2 and r3, loop and decrement until 0.
3. Increment A register(decremant for down counter)
ASSEMBLY PROGRAM ILLUSTRATING BCD UP/DOWN COUNTERS.

//counter program – BCD up/down counters
11) Write an ALP to implement (display) an eight bit up/down BCD counters
on watch window.
ORG 0H
SJMP 30H
ORG 30H
MOV a,#00
BACK:ACALL DELAY
ADD a,#99H //ADD 01 for BCD up counter
DA A //for bcd counter
JNZ BACK
HERE:SJMP HERE
DELAY:MOV r1,#0FFH
DECR1:MOV r2,#0FFH
DECR:MOV r3, #0FFH
DJNZ r3,$
DJNZ r2, DECR
DJNZ r1, DECR1
RET
END
Algorithm:
4. Move 00 to A register
5. Call the delay subroutine for 1 second (in delay program move FFH
to registers r1, r2 and r3, loop and decrement until 0).
6. Increment A register(add 99h for down counter)
7. Decimal adjust accumulator for the BCD up/down counter.
RESULT: Accumulator A is incremented in BCD from 00, 01, 02…09, 10,

11,…99.
6. SERIAL DATA TRANSMISSION
Program illustrating serial ascii data transmission (data-yE)

Note-to use result of this program, after selecting DEBUG session in the
main menu use
View-> serial window #1. On running & halting the program, the data is
seen in the serial window.
12) Conduct an experiment to configure 8051 microcontroller to transmit
characters (yE) to a PC using the serial port and display on the serial
window.
ORG 0H
SJMP 30H

ORG 30H
MOV TMOD,#20H //timer 1; mode 2
MOV TH1,#-3 //-3=FD loaded into TH1 for 9600 baud,
11.0592MHz.
MOV SCON,#50H //8-bit, 1 stop bit, REN enabled
SETB TR1 //Start timer 1
AGAIN:MOV A,#’y’ //transfer “y”
ACALL TRANS
MOV a,#’E’ //transfer “E”
ACALL TRANS
AGAIN1:SJMP AGAIN1
TRANS: MOV SBUF,a //load SBUF
HERE:JNB TI,HERE //Wait for last bit to transfer
CLR TI //get ready for next byte
RET
END
RESULT: yE is printed on the serial window each time the program is

executed.
Theory: In serial transmission as opposed to parallel transmission, one bit at

a time is transmitted. In serial asynchronous transmission, the data consists
of a Start bit (high), followed by 8 bits of data to be transmitted and finally the
stop bit. The byte character to be transmitted is written into the SBUF
register. It transmits the start bit. The 8-bit character is transferred one bit at
a time. The stop bit is transferred. After the transmission, the TI flag = 1
indicating the completion of transmission. Hence in the subroutine wait until
TI is set. Later clear the TI flag and continue with transmission of the next
byte by writing into the SBUF register. (The program can also be written in
interrupt mode). The speed of the serial transmission is set by the baud rate
which is done with the help of timer 1. (Refer Ayala). Timer1 must be
programmed in mode 2 (that is, 8-bit, auto reload).
Baud rate Calculation: Crystal freq/ (12*32) = (11.0592MHz)/(12*32) =
28800.
Serial communication circuitry divides the machine cycle
frequency(11.0592MHz)/(12) by 32 before it is being used by the timer to set
the baud rate.
To get 9600, 28800/3 is obtained by loading timer1 with -3 (i.e., FF – 3 = FD)
for further clock division. For 2400 baud rate, 28800/12 => -12 = F4 in TH1.
Algorithm:
1. Initialize timer 1 to operate in mode 2 by loading TMOD register.
2. load TH1 with -3 to obtain 9600 baud.
3. Initialize the asynchronous serial communication transmission
(SCON) register.
4. Start timer1 to generate the baud rate clock.
5. Transmit the characters “y” & “E” by writing into the SBUF register
and waiting for the TI flag.
7) TIMER DELAY PROGRAM

Program illustrating timer delay

13) Generate a 1second delay continuously using the on chip timer in

interrupt mode.
ORG 0H //Reset Vector
SJMP 30H
ORG 0BH //TF0 vector
SJMP ISR
ORG 30H
MOV a,#00
MOV R0,#0
MOV R1,#0
MOV TMOD,#02H //00000010-Run timer0 in mode 2
MOV TH0,#118 //Set up timer 0 to overflow in 0.05msec
MOV IE,#82H //%10000010 – Enable timer0
interrupt
SETB TCON.4 //Start the timer0
HERE:SJMP HERE
ISR: CLR TCON.4 //Disable timer0
INC r1 //r1*r2 = 100*200 = 20000 * 0.05msec = 1sec
CJNE r1,#100,SKIP
MOV r1,#00
INC r0
CJNE r0,#200,SKIP
MOV r0,#00H
INC a
SKIP: SETB TCON.4 //Enable Timer
RETI //Return from interrupt subroutine
END
RESULT: Accumulator A is incremented in binary from 00, 01,02…09,0A,

0B, …, 0F, 10, 11, …FF every 1 second (for 33MHz clock setting & every 3
seconds for 11.0598MHz)
Algorithm:
1. Set up timer0 in mode 2 operation
2. Load TH1 with 118 to generate an interrupt every 0.05msec.
3. Reset registers a, r1 & r0.
4. Repeat step 4 continuously
5. On interrupt; ISR at 000B loaction goes to step 6
6. disable timer0
7. Update r1 & r0
8. Check if 20000 interrupts (=1 sec) over. Yes –increment accumulator a.
9. enable timer & return from ISR.

Timerdelay = 12*(257-delay)/frequency
Timerdelay=0.05msec
Delay=256-((timerdelay * frequency)/12) =256-(0.05*10 -3 * 33*106)/12
=256-137.5 =118.5 //loaded in TH0
To get 1sec delay
1/0.05msec = 200*100 in the ISR
(assuming 33 MHZ crystal frequency. For 11 MHz, the calculations change).

8. CONVERSION PROGRAMS
14) Write an ALP to implement decimal to hex conversion
ORG 0000H
SJMP 30h
ORG 30h
MOV DPTR,#40H //2-digit decimal number to be converted is given
in data memory 40h
MOVX A, @DPTR
ANL A, #0F0H //obtain upper decimal digit
SWAP A //bring to the units place
MOV B,#0AH //MULTIPLY tens digit with #0A-toget tens
in hex
MUL AB
MOV r1,a //temporarily store the converted tens
value
MOVX A,@DPTR //get the decimal number again
ANL A,#0FH //obtain the units digit
ADD A,R1 //add to the converted tens value
INC DPTR //increment data address
MOVX @DPTR,A //converted hexadecimal number in next
location
HERE:SJMP HERE
END
RESULT: before execution- X:0040H = 45 (Decimal/BCD)

After Execution: X:0041h = 2D (hex value)
Algorithm
1. Move the decimal data to be converted from external memory 40h to
accumulator.
2. AND A reg with 0f0h and obtain the upper MSB of the decimal digit
and swap the LSB and MSB of accumulator to bring the same to units
place.
3. Move 0ah to B register and multiply with A reg to convert to hex
value, store the converted tens value in r1
4. Get the LSB of the decimal number and add to the converted tens
value
5. point to the next memory location and store the result (hexadecimal).
15) Write an ALP to implement hex to decimal conversion

ORG 0000H
SJMP 30h
ORG 30h
MOV DPTR,#9000H
MOVX A,@DPTR //Get hex number
MOV B,#10
DIV AB //divide by 10 (0AH)

INC DPTR
XCH A,B
MOVX @DPTR,A //Store the remainder (in B) In units place
XCH A,B
MOV B,#10 //Divide the quotient in A by 10
DIV AB
INC DPTR
XCH A,B
MOVX @DPTR,A //Store the remainder (in B) In tens place
XCH A,B
INC DPTR
MOVX @DPTR,A //Store the quotient (in A) in hundreds place
HERE:SJMP HERE
End
RESULT: 9000H – FF (HEX NUMBER)

9001 to 9003 – unpacked BCD number (decimal)- 5,5,2 (i.e., 255 stored
Lower digit first)
Algorithm
1. Move the hex data to be converted to accumulator.
2. Move 10 to B register and divide with A reg to convert to ascii value
3. Store the converted LSB value in r7
4. Repeat the step 2 to obtain the converted MSB value
5. Store the same in r6
16) Write an ALP to implement BCD to ASCII conversion

ORG 0000H
SJMP 30h
ORG 30h
MOV R1,#50H
MOV A,@R1 //get BCD data byte from RAM location 50h
MOV R2,A //Store in R2
ANL A,#0FH //Get the lower nibble
ORL A,#30H //Add/or with 30h i.e., 0-9 converted to 30-39h
INC R1
MOV @R1,A //Store the lower digit's ASCII code
MOV A,R2 //Get back the number
SWAP A //Swap nibbles in A
ANL A,#0FH //Get the upper BCD digit
ORL A,#30H //Convert to ASCII
INC R1
MOV @R1,A //Store the upper digit's ASCII code
here: sjmp here
END

RESULT: The BCD code 28 at D:0050h is converted to 2 ASCII codes-38h

32h
Algorithm :
//Converts the BCD byte in A into two ASCII characters.
1. Move the BCD data to be converted to accumulator.
2. Get the lower nibble(BCD digit) & ADD (or ORL) with 30h
3. Store the converted ASCII value
4. Get the higher nibble(tens BCD digit) & ADD (or ORL) with 30h
17) Write an ALP to implement hexadecimal to ASCII conversion

//This program also illustrates conditional branching (JNC), call and
return instructions.
ORG 0000H
SJMP 30h
ORG 30h
MOV R1,#50H
MOV A,@R1 //get hexadecimal data byte from RAM location 50h
MOV R2,A //Store in R2
ANL A,#0FH //Get the lower nibble
ACALL ASCII //Convert to ASCII
INC R1
MOV @R1,A //Store the lower digit's ASCII code
MOV A,R2 //Get back the number
SWAP A //Swap nibbles in A
ANL A,#0FH //Get the upper BCD digit
ACALL ASCII
INC R1
MOV @R1,A //Store the upper digit's ASCII code
here: sjmp here
ASCII:MOV R4,A //Store a

CLR C
SUBB A,#0AH //Check if digit >=0A
MOV A,R4
JNC SKIP
ADD A,#07H //Add 07 if >09
SKIP:ADD A,#30H //Else add only 30h for 0-9
RET
END
RESULT: The BCD code 2C at D:0050h is converted to 2 ASCII codes-

43h(for 0B) & 32h (for 02) Another Example-BA

Algorithm :
//Converts the hexadecimal byte in A into two ASCII characters.
1. Move the hexadecimal data to be converted to accumulator.
2. Get the lower nibble & call ASCII routine
4. Get the higher nibble & call ASCII routine
ASCII subroutine
1. If digit greater than 09,(for A-F) add 07h & 30h
2. Else (i.e., for 0-9) add only 30h
3. return
18) Write an ALP to implement ASCII to hexadecimal conversion

ORG 0000H
SJMP 30h
ORG 30h
MOV R1,#50H
MOV A,@R1 //get ascii byte from RAM location 50h
CLR C
SUBB A,#41H
MOV A,@R1
JC SKIP
CLR C
SUBB A,#07H
SKIP:CLR C
SUBB A,#30H
INC R1
MOV @R1,A //Store the hex code
here: sjmp here
END
RESULT: The ASCII code 45 at D:0050h is converted to hexadecimal -0E

at 51h
Note: For this program the input data should be only in the range 30h-39h &
41h to 46h.
Algorithm :

//Converts the ASCII characters into hexadecimal number.

1. Move the ASCII character to be converted to accumulator.
2. If character is greater than 41h,(for A-F), then subtract 07h &
30h
3. Else (i.e., for 0-9) subtract only 30h
4. Store the converted hexadecimal number.
Hardware Interfacing
1.Waveform Generation using Dual DAC

2.Stepper Motor interface.
3.4X4 hexadecimal Keyboard interface
4.DC motor interface
5.Calculator using Keyboard and Seven segment display.
6.Elevator control.
7.Temperature sensor.
Features of Embedded C
• C is a simple programming language and so very easy to code.
• Embedded C has most features of C-language with more stress on certain bit
manipulative instructions.
• This feature makes it easy to write program for μC and μP.
• Keil is a versatile software with a cross compiler that will convert the C
program to assembly language and thus the program can be executed on the
desired target (say 8051).
Some of the bit manipulative instructions used are

Symbol Operation
& Bitwise AND
| Bitwise OR
~ Bitwise NOT
>> Shift Right
<< Shift Left
^ P0.0
1.Dual Dac Interface to generate
a.Square waveform
b.Triangular Waveform
c.Ramp waveform

d.Sine waveform
8
0 CRO
5 P0 Dual Xout
1 P1 DAC
μC
1.aAlgorithm for Square wave generation
 Let initial, amplitude of the square wave be 2.5v(7F) and frequency count
100.
 Output the values 00h(0ff) and 7fh(on) Values through P0.
 If amplitude key is pressed then increase the voltage in steps of 0.15v(8).
 If the frequency key is pressed increment the count in steps of 50. If the
count exceeds 1000 reset it back to 100.
 Every time amplitude and frequency changes output the value thro P0 and
note the waveform on CRO.
Program for square wave
#include <REG51xD2.H>
sbit Amp = P3^3; /* Port line to change amplitude */
sbit Fre = P3^2; /* Port line to change frequency */
void delay(unsigned int x) /* delay routine */
{
for(;x>0;x--);
}
main()
{
unsigned char on = 0x7f,off=0x00;
unsigned int fre = 100;
while(1)
{
if(!Amp) /* if user choice is to change amplitude */
{
while(!Amp); /* wait for key release */
on+=0x08; /* Increase the amplitude */
}
if(!Fre) /* if user choice is to change frequency */

{
if(fre > 1000) /* if frequency exceeds 1000 reset to default */
fre = 100;
while(!Fre); /* wait for key release */

fre += 50; } /* Increase the frequency */
P0=on; /* write amplitude to port */
P1=on;
delay(fre);
P0 = off; /* clear port */
P1 = off;
delay(fre);
}}
1.bAlgorithm for Triangular wave generation
 Output the initial value 00 through P0.

 Increment it in steps of 1 until a count value of FFh (5V) is reached. Every
time repeat step 1.
 Decrement it in steps of 1 until a zero value is reached and repeat step 1.
Program for triangular wave:
main()
{
unsigned char i=0;
P0 = 0x00; /* P0 as Output port */
while(1)
{
for(i=0;i<0xff;i++){ /* Generate ON pulse */
P1 = i;
P0 = i;
}
for(i=0xfe;i>0x00;i--) /* Generate OFF pulse */
{P0 = i;
P1 = i;}
}
}
1.c.Algorithm for Ramp wave generation
 Output the initial value 00 through P0.

 Increment it in steps of 1 until a count value of FFh (5V) is reached.
Every time repeat step 1.
 Repeat step 1 & 2 continuously.
Program for Ramp waveform
main ()

{ Unsigned char i=0;

while (1)
{
for (i=0;i<0xff;i++) /* Generate ON pulse */
{
P1 = i;
P0 = i; }
}
}
1d.Algorothm for Sine wave
 Compute different step values (θ = 20o,15o…) of sine using the equation

V= 2.5V +2.5Vsinθ. . Output the values thro P0.
 More the steps smoother will be sine wave.
 E.g.: θ = 0o
V= 2.5V +2.5Vsinθ = 2.5V
The value sent to DAC is 25.6X5V= 128.
Program for sine wave
main()
{
static int a[13]={128,192,238,255,238,192,128,64,17,0,17,64,128};
unsigned char i=0;
while (1)
{
for(i=0;i<13;i++) /* Output different values */
{ P0 = a[i]; }
}
}
2.Stepper Motor
• Stepper motor unlike DC motor rotates in steps.

• Stepper motor has 4 coils which forms the stator and a central rotor.
• Rotation depends on excitation of stator coils.
step coil A coil B coil C coil D
1 0 0 0 1
2 1 0 0 0
3 0 1 0 0
4 0 0 0 1
Anyone of these values forms the initial value. To get 360o revolution 200 steps are
required.

Step angle= 360o /200 = 1.8o. (difference between 2 teeth).
Algorithm for Stepper Motor
• Configure P0 as output.
• Apply the initial excitation of 11 to motor coils through P0.
• For clockwise motion -Rotate right once the excitation and repeat step 2.
• For anticlockwise motion -Rotate left once the excitation and repeat step 2.
PS
PS
8051µC
P0 Stepper
FRC 26pin Motor Stepper
Cable Interface Motor
Card
//Program for stepper motor interface
void delay (unsigned int x) /* Delay Routine */
{
for(;x>0;x--);
return;
}
Main ( )
{
unsigned char Val, i;
P0=0x00;
Val = 0x11;
for (i=0;i<4;i++)
{
P0 = Val;
Val = Val<<1; /* Val= Val>>1; for clockwise direction*/
delay (500);
}
}
3. 4X4 HEX Keyboard
Algorithm for Keyboard Interface
• Configure P1 as output port to scan the rows and P0 as input port to read the
column values.

• First select the last row by grounding that row. Scan the columns of entire
row if a key is pressed in that row then one of the column reads ‘0’.
• If now key is pressed in the selected row all 1’s is returned. So scan next
row. Repeat the action until all rows are scanned.
PS
PS
8051µC
P0 4X4
FRC 26pin Keyboard 4X4 Hex
Cable Interface keypad
Card
//Program for 4X4 hex keypad.
#include < REG51xD2.H>

#include <intrins.h>
#include "lcd.h"
unsigned char rows,columns,result,abhi;
unsigned char temp = 0;
void delay()
{
unsigned int i;
for(i = 0; i <= 20000; i ++);
}
void Display()
{
if(result > 0x09)
{
result += 0x37;
WriteChar(result);
}
else
{
result += 0x30;
WriteChar(result);
}
}
void KeyScan()
{
again: columns = 0x77;
rows = 0x04;
result = 0x0c;
next: P1 = columns;
columns >>=1;

if(CY)
columns = columns |0x08 ;

temp = P0;
temp = (temp & 0x0f);
if(temp != 0x0f)
{
rot: temp >>= 1;
if(!CY)
{
ClrLcd();
return;
}
else
{
result += 1;
goto rot;
}
}
else
{
result -= 0x04;
rows --;
if(rows == 0)
goto again;
else
{
goto next;
}
}
}
void main()
{
P0 = 0xff;
P1 = 0x00;
InitLcd();
WriteString ("KEY PRESSED=");
while(1)
{
KeyScan();
WriteString ("KEY PRESSED=");
Display();
}
}
4.DC Motor
Algorithm for DC motor interface

• Configure P0,P1 as output port and P3 as input port.

• Let initially the motor rotate with half speed count 7fh.
• If “INR” button is pressed reduce the count because the speed is inversely
proportional to count.
• If “DEC” button is pressed increase the count.
PS
PS
8051µC
P0
FRC 26pin DC Motor
DC
Cable Interface
Motor
P3.2(inr) Card
P3.3(dec)
Program for DC motor
sbit inr= P3^2; //speed increment switch
sbit dcr= P3^3; //speed decrement switch
main()
{
unsigned char i=0x80;
P0 = 0x7f; /*Run the motor at half speed.*/
while (1)
{ if (!inr)
{while (!inr);
if(i>10)
i=i-10; //increase the DC motor speed
}
if(!dcr)
{
while(!dcr);
if(i<0xf0)
i=i+10; //decrease the DC motor speed
}
P0=i;
} }
5.Calculator using Keyboard and 7-segment display

Algorithm

• Read the numbers n1 and n2 from keyboard and display them on seven
segment.
• Read the operand from the keypad if key pressed is B (+), C(-),D(*),E(/) then
respective operation is performed.
• Result is displayed on 2 digit seven segment display.
• If any time the key pressed value returned as 10h then clear the LCD.
PS
PS
8051µC
Keypad
P0
FRC 26pin
Cable
7 Seg
Display
Program for calculator
void DispChar(unsigned char ch);
void ClrLED();
unsigned char getkey();
unsigned char getnum();
unsigned char getOp();
sbit Clk = P3^4; /* Clock line for 7 segment display */
sbit Dat = P0^0; /* Data line for 7 segment display */
main()
{
unsigned char tmp=0x0ff,n1=0,n2,Op,Res;
unsigned char NumTab[10] = {
0x0c0,0x0f9,0x0a4,0xb0,0x99,0x92,0x82,0x0f8,0x80
,0x90 };
unsigned char OpTab[4] = { 0x88,0x0Bf,0xc8,0x0a1};
bit Neg=0;
ClrLED(); /* Clear 7 segment display */
while(1)
{
Neg = 0; /* Negative flag */
n1=getnum(); /* Get 1st number */
Op = getOp() - 0x0B; /* Get Opcode. 0x0b is keycode of '+'(see keyboard

schematics)*/
n2=getnum(); /* Get 2nd number */

while(getkey()!=0x13); /* wait for '=' key */

ClrLED();
switch(Op) /* Perform corresponding operation */
{
case 0: Res = n1 + n2;
break;
case 1:
if(n2>n1) /* check for negativity */
{
Neg = 1;
Res = n2 - n1;
break; }
Res = n1 - n2;
break;
case 2: Res = n1 * n2;
break;
case 3: Res = n1 / n2;
break; }
DispChar(NumTab[Res%10]); /* Display number */
DispChar(NumTab[Res/10]);
if(Neg) /* if negative result display '-' */
DispChar(0x0Bf);
}}
void DispChar(unsigned char ch) /* Routine to display char on 7
segment */
{
unsigned char i,tmp;
P0=0x00;
for(i=0;i<8;i++) /* for all bits */
{
tmp = ch & 0x80;
if(tmp) /* write data depending on MSB */
Dat = 1;
else
Dat = 0;
Clk = 0; /* Give Clk Pulse for synchronization */
Clk = 1;
ch = ch << 1; /* Get next bit */
}
}
void ClrLED()
{
unsigned char i;
for(i=0;i<4;i++)
DispChar(0x0ff); /* 0xff for clear segment ( see 7 segment manual for more
info) */
}
unsigned char getkey()
{ unsigned char i,j,indx,t;


P0 = 0x0ff;
indx = 0x00; /* Index for storing the first value of scanline */
while(1)
{
for(i=1;i<=4;i<<=1) /* for 4 scanlines */
{
P2 = 0x0f & ~i; /* write data to scanline */
t = P0; /* Read readlines connected to P0*/
t = ~t;
if(t>0) /* If key press is true */
{
for(j=0;j<=7;j++) /* Check for 8 lines */
{ t >>=1;
if(t==0) /* if get pressed key*/
{
return(indx+j); /* Return index of the key pressed */
}
}
}
indx += 8; /* If no key pressed increment index */
} }}
unsigned char getnum() /* Method for getting number */
{
unsigned char tmp;
while(1)
{
tmp = getkey();
if(tmp < 0x0a || tmp==0x10) /* if pressed key is number, return */
return(tmp);
}}
unsigned char getOp() /* Method for getting Operator */
{
unsigned char tmp;
while(1)
{
tmp = getkey();
if((tmp > 0x0a && tmp <0x0f)|| tmp==0x10) /* if pressed key is a Operator,
return */
return(tmp);
}}
6.Elevator
Algorithm for elevator interface
• Read the floor request through input port P1.

• If the current floor and requested floor are the same no change light up the
corresponding LED through P0.
• If the requested floor greaterthan current moving up of the lift is indicated
by glowing of LED’s from current floor to the requested.
• If the requested floor lesserthan current moving down of the lift is indicated
by glowing of LED’s from current floor to the requested.
PS
PS
8051µC
P0
FRC 26pin Elevator
Cable interface
Program for Elevator
#include <REG51F.H>
void delay(unsigned int);
main()
{
unsigned char Flr[9] = {0xff,0x00,0x03,0xff,0x06,0xff,0xff,0xff,0x09};
unsigned char FClr[9] = {0xff,0x0E0,0x0D3,0xff,0x0B6,0xff,0xff,0xff,0x79};
unsigned char ReqFlr,CurFlr = 0x01,i,j;
P0 = 0x00;
P0 = 0x0f0;
while(1)
{
P1 = 0x0f;
ReqFlr = P1 | 0x0f0;
while(ReqFlr == 0x0ff)
ReqFlr = P1 | 0x0f0; /* Read Request Floor from P1 */
ReqFlr = ~ReqFlr;
if(CurFlr == ReqFlr) /* If Request floor is equal to Current
Floor */
{
P0 = FClr[CurFlr]; /* Clear Floor Indicator */
continue; } /* Go up to read again */
else if(CurFlr > ReqFlr) /* If Current floor is > request floor */
{
i = Flr[CurFlr] - Flr[ReqFlr]; /* Get the no of floors to travel
*/
j = Flr[CurFlr];
for(;i>0;i--) /*Move the indicator down */
{

delay(25000);
}}
else /* If Current floor is < request floor */
{
i = Flr[ReqFlr] - Flr[CurFlr]; /* Get the no of floors to travel */
j = Flr[CurFlr];
for(;i>0;i--) /* Move the indicator Up */
{
P0 = 0x0f0 | j;
j++;
delay(25000);
} }
CurFlr = ReqFlr; /* Update Current floor */
P0 = FClr[CurFlr]; /* Clear the indicator */
}
}
void delay(unsigned int x)
{
for(;x>0;x--);
}
7.Temperature Sensor
PS
PS
8051µC
Temp Heat
P0,P2,P3 Sensor Source
FRC 26pin Interface
Cable
The interface card has a DAC to convert the actual temperature to digital this is
compared with reference temperarture. Realay also a part of interface card will turn
on and off to indicate if the actual temperature is above or below reference.
Algorithm for Temperature sensor
1. Configure P0 and P1 as o/p, P3 as input port.

2. Set up a counter with intial value 0xff send it to dac thro P0 after a delay check if
comparator o/p has gone low.
3. If low compare with set value if actual greaterthan set turn on the relay else turn
off.

Program for temperature sensor.
sbit Cmp_Out = P3^4; /*Input Bit for Comparator output*/
sbit Rel_Con = P0^0; /*Relay controller Bit i.e Heater Power supply control*/
/*1- Supply OFF, 0-Supply ON*/
#define Dac_Data P1 /*DAC input Data PORT i.e. P1*/
void delay()
{ int l;
for (l=0;l<=0x8;l++);
}
main()
{
unsigned char DacIp;
void delay(void);
Dac_Data =0x00; /*Move 00h to Dac input*/
P0=0x00; /*make P0 as output*/
while(1)
{
DacIp= 0xff; /*DAC input Data counter*/
do
{
DacIp++; /*Increment the DAC input Data*/
Dac_Data = DacIp; /*Move the DAC data to DAC*/
delay();
}while(Cmp_Out); /* Check comparator output for low */
if(DacIp > 0x20) /*Compare with the set value i.e.0x20*/
Rel_Con = 1;
else
Rel_Con = 0; /* Relay ON, Supply OFF */
}
}

8051 Manual Fin

Uploaded by

Copyright:

Available Formats

8051 Manual Fin

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

8051 Manual Fin

Uploaded by

Copyright:

Available Formats

Microcontrollers Lab Manual 06ESL47

KVG COLLEGE OF ENGINEERING

Dept. Of E & C Engg KVGCE,Sullia

1. DATA TRANSFER INSTRUCTIONS

Dept. Of E & C Engg KVGCE,Sullia

2) Write an assembly language program to transfer n =10 bytes of data

Dept. Of E & C Engg KVGCE,Sullia

3) Write an ALP to move a block of 6 data bytes ,stored in internal

After Execution: data bytes from I:0010h are moved to i:0013h

Dept. Of E & C Engg KVGCE,Sullia

4. EXCHANGE BLOCKS OF DATA.

Dept. Of E & C Engg KVGCE,Sullia

After Execution: The data at X:0027h & X:0041h are exchanged.

Dept. Of E & C Engg KVGCE,Sullia

5) ASSEMBLY LANGUAGE PROGRAM TO SORT NUMBERS.

Dept. Of E & C Engg KVGCE,Sullia

After Execution: Sorted Array (Descending order) at 9000h

4) Write an assembly language program to find the largest element in a

Dept. Of E & C Engg KVGCE,Sullia

MOV DPL, #62H //LOCATION OF THE RESULT-4062H

After Execution: Location 4062 has the largest element.

Dept. Of E & C Engg KVGCE,Sullia

RESULT:Before Execution: ADD SUB

After Execution: ADD After Execution: SUB

Before Execution: MUL After Execution: MUL

Dept. Of E & C Engg KVGCE,Sullia

Dept. Of E & C Engg KVGCE,Sullia

ASSEMBLY PROGRAM ILLUSTRATING SQUARE AND CUBE

Dept. Of E & C Engg KVGCE,Sullia

3. PROGRAM ILLUSTRATING BIT MANIPULATIONS

Dept. Of E & C Engg KVGCE,Sullia

RESULT: 1) Before Execution: X:08000h = 45 & X:8001 = 35

Dept. Of E & C Engg KVGCE,Sullia

HERE: SJMP HERE

Dept. Of E & C Engg KVGCE,Sullia

STORE THE BIT RESULT IN RES, WHERE RES IS MSB OF 23H

20h = 01 => OR of MSBs = 0 (hence 00 in 23h location)

20h = 01 =>complement of MSB of 21h location. Hence 21h is changed to

Dept. Of E & C Engg KVGCE,Sullia

DELAY: MOV r1,#0FFH

RESULT: Accumulator A is incremented in binary from 00, 01,02…09,0A,

Dept. Of E & C Engg KVGCE,Sullia

ASSEMBLY PROGRAM ILLUSTRATING BCD UP/DOWN COUNTERS.

RESULT: Accumulator A is incremented in BCD from 00, 01, 02…09, 10,

6. SERIAL DATA TRANSMISSION

Program illustrating serial ascii data transmission (data-yE)

Dept. Of E & C Engg KVGCE,Sullia

RESULT: yE is printed on the serial window each time the program is

Theory: In serial transmission as opposed to parallel transmission, one bit at

7) TIMER DELAY PROGRAM

Dept. Of E & C Engg KVGCE,Sullia

13) Generate a 1second delay continuously using the on chip timer in

RESULT: Accumulator A is incremented in binary from 00, 01,02…09,0A,

Dept. Of E & C Engg KVGCE,Sullia

Dept. Of E & C Engg KVGCE,Sullia

14) Write an ALP to implement decimal to hex conversion

RESULT: before execution- X:0040H = 45 (Decimal/BCD)

15) Write an ALP to implement hex to decimal conversion

Dept. Of E & C Engg KVGCE,Sullia

RESULT: 9000H – FF (HEX NUMBER)