MICROPROCESSOR LAB
List Of Experiments
CYCLE-1:
1.
2.
3.
4.
Addition of two 16-bit numbers using immediate addressing mode.
Subtraction of two 16-bit numbers using immediate addressing mode.
Addition of two 16-bit numbers using direct addressing mode.
Subtraction of two 16-bit numbers using direct addressing mode.
5. Arithmetic Operation:
a. Multiword addition
b. Multiword Subtraction
c. Multiplication of two 16-bit numbers
d. 32bit/16 division
6. Signed operation:
a. Multiplication
b. Division
7. ASCII Arithmetic:
a. AAA
b. AAS
c. AAM
d. AAD
e. DAA
f. DAS
8. Logic Operations:
a. Shift right
b. Shift left
c. Rotate Right without carry
d. Rotate left without carry
e. Rotate Right with carry
f. Rotate left with carry
g. Packed to unpacked
h. Unpacked to packed
i. BCD to ASCII
j. ASCII to BCD
9. String Operation:
a. String Comparison
b. Moving the block of string from one segment to another segment.
c. Sorting of string in ascending order
d. Sorting of string in descending order
e. Length of string
f. Reverse of string
10. Dos Function:
a. Display a character
b. Display a string
c. Reading a Keyboard without echo
d. Input a character
11. Bios Function:
a. Set video mode
b. Cursor size
c. Keyboard shift status
d. Keyboard input with echo
12. Modular Programs:
a. Generation of fibonacci series
b. Factorial of a given numbers
c. Find largest number of a given ‘n’ numbers
d. Find smallest number of a given ‘n’ numbers
e. Display the system time
CYCLE-2
INTERFACING
13. 8279 Keyword Display-To display string of characters
14. 8255 PPI----ALP to generate
a. Triangular wave
b. Saw tooth wave
c. Square wave
MICROCONTROLLER-8051
15. Addition
16. Subtraction
17. Multiplication
18. Division
19. Reading and writing on a parallel port
20. Swap & Exchange
21. Timer mode operation
22. Serial Communication implementation
Addition of two 16-bit numbers using DAM
Aim: Write an ALP in 8086 to perform the addition of two 16-bit numbers by using
direct addressing mode.
Apparatus: 8086 Trainer Kit.
Program:
Mov ax, [1500]
Mov bx, [1502]
Add ax, bx
Mov [1504], ax
Hlt
Input:
Ax 3322
[1500]22
[1501]33
Bx5544
[1502]44
[1503]55
Output:
Ax8866
[1500]66
[1501]88
Result:
Thus the addition of two 16-bit numbers has been executed successfully using DAM
and the result is verified.
Subtraction of two 16-bit numbers using DAM
Aim: Write an ALP in 8086 to perform the Subtraction of two 16-bit numbers by using
direct addressing mode.
Apparatus: 8086 Trainer Kit.
Program:
Mov ax, [1500]
Mov bx, [1502]
Sub ax, bx
Mov [1504], ax
Hlt
Input:
Ax 4433
[1500]33
[1501]44
Bx2222
[1502]22
[1503]22
Output:
Ax2211
[1500]11
[1501]22
Result:
Thus the Subtraction of two 16-bit numbers has been executed successfully using
DAM and the result is verified.
Addition of two 16-bit numbers using IAM
Aim: Write an ALP in 8086 to perform the addition of two 16-bit numbers by using
Immediate addressing mode.
Apparatus: 8086 Trainer Kit.
Program:
Mov ax, 5611
Mov bx, 1234
Add ax, bx
Mov [1500], ax
Hlt
Input:
Ax 5611
Bx1234
Output:
Ax6845
[1500]45
[1501]68
Result:
Thus the addition of two 16-bit numbers has been executed successfully using IAM
and the result is verified.
Subtraction of two 16-bit numbers using IAM
Aim: Write an ALP in 8086 to perform the addition of two 16-bit numbers by using
Immediate addressing mode.
Apparatus: 8086 Trainer Kit.
Program:
Mov ax, 4567
Mov bx, 1111
Sub ax, bx
Mov [1500], ax
Hlt
Input:
Ax 4567
Bx1111
Output:
Ax3456
[1500]56
[1501]34
Result:
Thus the subtraction of two 16-bit numbers has been executed successfully using
IAM and the result is verified.
1. Arithmetic Operations
a) Multi Word addition
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, 0000h
Mov BX, 0000h
ADD AX, BX
Mov AX, 5678h
Mov BX, 1234h
ADC AX, BX
Mov DX, AX
INT 21h
END
INPUT 1: 56780000h
INPUT 2: 12340000h
OUTPUT: 68AD0000h
CX: 0000
DX: 68AD
RESULT:
Thus the program for addition of two double words has been executed successfully by
using TASM & result is verified.
b) Multi Word subtraction
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, 0111h
Mov BX, 1000h
SUB AX, BX
MOV CX, AX
Mov AX, 5678h
Mov BX, 1234h
ADC AX, BX
Mov DX, AX
INT 21h
END
INPUT 1: 56780111h
INPUT 2: 12341000h
OUTPUT: 4443F111h
CX: F111 LSW of the result
DX: 68AD MSW of the result
RESULT:
Thus the program for subtraction of two double words has been executed successfully
by using TASM & result is verified.
c) Multiplication of two 16-bit numbers
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, 1234h
Mov BX, 1234h
MUL BX
INT 21h
END
INPUT 1: 1234h
INPUT 2: 1234h
OUTPUT: 014B5A90h
CX: 5A90 LSW of the result
DX: 014B MSW of the result
RESULT:
Thus the program for multiplication of two 16-bit program executed successfully by
using TASM & result is verified.
d) Multi Word Division (32-bit/16-bit)
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, 2786h
Mov BX, 2334h
Mov CX, 3552h
DIV CX
INT 21h
END
INPUT 1: 23342786h
INPUT 2: 3552h
OUTPUT: 303EA904h
AX: A904 LSW of the result
DX: 303E MSW of the result
RESULT:
Thus the multi word division of programs executed successfully by using TASM &
result is verified.
3. Signed Operation
a. Multiplication of two signed numbers
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, 8000h
Mov BX, 2000h
IMUL BX
INT 21H
END
INPUT 1:8000h
INPUT 2: 2000h
OUTPUT:
AX 0000h
DX F000h
RESULT:
Thus the program for multiplication of two signed numbers has been executed
successfully by using TASM & result is verified.
b. Division of two signed numbers
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, -0002h
Mov BL, 80h
IDIV BL
INT 21H
END
INPUT 1:AX0002h
BX 80h
OUTPUT:
AX 00C0h
AlC0h
Ah 00h
RESULT:
Thus the program for division of two signed numbers has been executed
successfully by using TASM & result is verified.
4. ASCII Arithmetic Operation
a) AAA
ASM code:
. Model small
. Stack
. Data
. Code
Mov AL, 35h
Mov BL, 37h
ADD AL, BL
AAA
Int 21h
End
INPUT 1: 35h
INPUT 2: 37h
OUTPUT: AX0102h
RESULT:
Thus the program for AAA has been executed successfully by using TASM &
result is verified.
b) AAS
ASM code:
. Model small
. Stack
. Data
. Code
Mov AL, 37h
Mov BL, 35h
SUB AL, BL
AAS
Int 21h
End
INPUT 1: 37h
INPUT 2: 35h
OUTPUT:
AX0002h
RESULT:
Thus the program for AAS has been executed successfully by using TASM &
result is verified.
c) AAM
ASM code:
. Model small
. Stack
. Data
. Code
Mov AL, 06h
Mov BL, 09h
MUL BL
AAM
Int 21h
End
INPUT 1: 09h
INPUT 2: 06h
OUTPUT:
AX0504h(un packed BCD)
RESULT:
Thus the program for AAM has been executed successfully by using TASM &
result is verified.
d) AAD
ASM code:
. Model small
. Stack
. Data
. Code
Mov AX, 1264h
Mov BL, 04h
DIV BL
AAD
Int 21h
End
INPUT 1: 1264h
INPUT 2: 04h
OUTPUT:
AX0499
RESULT:
Thus the program for AAD has been executed successfully by using TASM &
result is verified.
e) DAA
ASM code:
. Model small
. Stack
. Data
. Code
Mov AL, 59h
Mov BL, 0935h
ADD AL, BL
DAA
Int 21h
End
INPUT 1: 59h
INPUT 2: 35h
OUTPUT:
AX0094h
RESULT:
Thus the program for DAA has been executed successfully by using TASM &
result is verified.
f) DAS
ASM code:
. Model small
. Stack
. Data
. Code
Mov AL, 75h
Mov BL, 46h
SUBAL, BL
DAS
Int 21h
End
INPUT 1: 75h
INPUT 2: 46h
OUTPUT:
AL29h
RESULT:
Thus the program for DAS has been executed successfully by using TASM &
result is verified.
Logic Operation
Shift Right
ASM code:
. Model small
. Stack
. Data
. Code
Mov al, 46h
Mov cl, 04h
Shr al, cl
Int 21h
End
Input:
Al46
Cl04
Output:
04h
RESULT:
Thus the program for Shift right operation has been executed successfully by
using TASM & result is verified.
Shift Left
ASM code:
. Model small
. Stack
. Data
. Code
Mov al, 46h
Mov cl, 04h
Shl al, cl
Int 21h
End
Input:
Al46
Cl04
Output:
60h
RESULT:
Thus the program for Shift left operation has been executed successfully by
using TASM & result is verified.
Rotate Right Without Carry
ASM code:
. Model small
. Stack
. Data
. Code
Mov al, 68h
Mov cl, 04h
Ror al, cl
Int 21h
End
Input:
Al68h
Cl04h
Output:
86h
RESULT:
Thus the program for rotate right without carry has been executed successfully
by using TASM & result is verified.
Rotate Left Without carry
ASM code:
. Model small
. Stack
. Data
. Code
Mov al, 60h
Mov cl, 04h
Rol al, cl
Int 21h
End
Input:
Al60h
Cl04h
Output:
06h
RESULT:
Thus the program for rotate left without carry has been executed successfully
by using TASM & result is verified.
Rotate Right With Carry
ASM code:
. Model small
. Stack
. Data
. Code
Mov al, 56h
Mov cl, 03h
Rcr al, cl
Int 21h
End
Input:
Al56h
Cl03h
Output:
Al= Bl
RESULT:
Thus the program for rotate right with carry has been executed successfully by
using TASM & result is verified.
Rotate Left With Carry
ASM code:
. Model small
. Stack
. Data
. Code
Mov al, 56h
Mov cl, 03h
Rcl al, cl
Int 21h
End
Input:
Al56h
Cl03h
Output:
Al=8Ah
RESULT:
Thus the program for rotate left with carry has been executed successfully by
using TASM & result is verified.
Packed BCD to UNPACKED BCD Conversion
ASM Code:
. Model small
. Stack
. Data
. Code
Mov BL, 57h
Mov BH, 04h
Mov AL, BL
Mov CL, BH
SHL AL, CL
Mov CL, BH
ROR AL, CL
Mov DL, AL
Mov AL, BL
Mov CL, BH
SHR AL, CL
Mov DH, AL
INT 21H
END
Input:
BL (Packed BCD) =
Output:
DX (Unpacked BCD) =
RESULT:
Thus the program for conversion of packed to unpacked has been executed
successfully by using TASM & result is verified.
UNPACKED BCD to Packed BCD Conversion
ASM Code:
. Model small
. Stack
. Data
. Code
Mov ax, 0207h
Mov al, 04h
Ror al, cl
Shr ax, cl
INT 21H
END
Input:
AX0207(Unpacked BCD)
Output:
AX0027(packed BCD)
RESULT:
Thus the program for conversion of unpacked to packed has been executed
successfully by using TASM & result is verified.
ASCII to BCD
ASM Code:
. Model small
. Stack
. Data
. Code
Mov ax, 3638h
Mov bx, 3030h
Mov cl, 04h
Shl al, cl
Ror ax, cl
INT 21H
END
Input:
AX3638h(Unpacked BCD)
Output:
AX0068(packed BCD)
RESULT:
Thus the program for conversion of ASCII to BCD value has been executed
successfully by using TASM & result is verified.
BCD to ASCII
ASM Code:
. Model small
. Stack
. Data
. Code
Mov AL, 57h
Mov CL, 04h
SHL AL, CL
ROR AL. 04H
XOR AL, 30H
MOV BL, AL
MOV AL, 57H
MOV CL, 04H
SHR AL, CL
XOR AL, 30H
MOV BH. AL
INT 21H
END
Input:
AL (BCD)
Output:
BX (ASCII)
RESULT:
Thus the program for conversion of BCD TO ASCII value has been executed
successfully by using TASM & result is
STRING OPERATIONS
Strings Comparison:
ASM CODE:
. Model small
. Stack
. Data
Strg1 db ‘lab’,’$’
Strg 2 db ‘lab’, $’
Res db ‘strg are equal’,’$’
Res db ‘strg are not equal’,’$’
Count equ 03h
. Code
Mov ax, @data
Mov ds, ax
Mov es, ax
Lea si, strg1
Lea di, strg2
Cld
Rep cmpsb
Jnz loop1
Mov ah, 09h
Lea dx, res
Int 21h
Jmp a1
Loop1: mov ah, 09h
Lea dx, re1
Int 21h
A1: mov ah, 4ch
Int 21h
End
Input:
Strg1
Strg2
Output:
Result:
Thus the program of string comparison is executed successfully and the result is
verified.
Data Transfer from one segment to another segment
ASM CODE:
. Model small
. Stack
. Data
String db’computer’
String 1 db8 dup (?)
. Code
Mov ax, @data
Mov ds, ax
Mov es, ax
Mov cl, 08h
Mov si, offset string
Mov di, offset string 1
Cld
Rep movsb
Int 21h
End
Input:
Output:
Result:
Thus the program to move a block of string from one memory location to another
memory location is executed successfully.
Sorting a string in an ascending order
ASM code:
. Model small
. Stack
. Data
List1 db 53h, 10h, 24h, 12h
Count Equ, 04h
. Code
Mov AX, @data
Mov DS, AX
Mov Dx, Count-1
Again2: Mov CX, DX
Mov SI, offset List1
Again1: Mov AL, [SI]
CMP AL, [SI+1]
JL PR1
XCHG [SI+1], AL
XCHG [SI], AL
PR1: ADD SI, 01H
Loop Again1
DEC DX
JNZ Again2
Mov AH, 4ch
Int 21h
End
Input:
Enter string: 53h, 10h, 24h, 12h
Output:
Sorted String: 10h, 12h, 24h, 53h
Result:
Thus the program for sorting a string in an ascending order is executed successfully
by TASM & result is verified.
Sorting a string in an descending order
ASM code:
. Model small
. Stack
. Data
List1 db 53h, 10h, 24h, 12h
Count Equ, 04h
. Code
Mov AX, @data
Mov DS, AX
Mov Dx, Count-1
Again2: Mov CX, DX
Mov SI, offset List1
Again1: Mov AL, [SI]
CMP AL, [SI+1]
JL PR1
XCHG [SI+1], AL
XCHG [SI], AL
PR1: ADD SI, 01H
Loop Again1
DEC DX
JNZ Again2
Mov AH, 4ch
Int 21h
End
Input:
Enter string: 53h, 10h, 24h, 12h
Output:
Sorted String: 10h, 12h, 24h, 53h
Result:
Thus the program for sorting a string in an ascending order is executed successfully
by TASM & result is verified.
Length of the string
ASM Code:
. Model small
. Stack
. Data
S1. Label byte
Mx1 db 30
Al1 db?
S2 db’ enter the string’,‘$’
S3 db’ Length of the string’,’$’
. Code
Mov ax, @data
Mov ds, ax
Mov ah, 09H
Lea dx, S2
Int 21h
Mov ah, 0ah
Lea dx, S3
Int 21h
Mov ah, 02h
Mov dl, al1
Or dl, 30h
Int 21h
End
Input: Enter the string
SVCET
Output: length of the string
DS: 0005
Result:
Thus the program to find the length of the string is executed successfully by
TASM & result is verified.
BIOS FUNCTION
(a) Set video mode:
ASM CODE:
. Model small
. Stack
. Data
. Code
Mov ah, 00h
Mov al, 01h
Int 10h
End
Input:
Ah00h; Set video mode
Al01h; mode has been set for 25*40
Output:
The output screen has been changed for 25*40
Result:
Thus the program to set video mode is executed successfully by TASM &
result is verified.
(b) Set cursor size
ASM Code:
. Model small
. Stack
. Data
. Code
Mov ah, 01h
Mov ch, 00h
Mov cl, 14h
Int 10h
End
Input:
Ah01h set cursor size
Cl 14h top level value of the cursor.
Ch 00h low level value of the cursor.
Output:
Thus cursor size has been changed.
Result:
Thus the program to set cursor size is executed successfully by TASM &
result is verified.
© Key board shift status
ASM Code:
. Model small
. Stack
. Data
. Code
Mov ah, 12h
Int 16h
End
Input:
Caps lock, num lock, scroll lock are chosen before execution of the program.
Output:
Al 70-01110000.
The content of the al reg has to represented bit wise.
The corresponding bit has been set.
Result:
Thus the program to know the keyboard status is executed successfully by TASM &
result is verified.
Keyboard Input With Echo
ASM Code:
. Model Small
. Stack
. Data
. Code
Mov ah, 01h
Int 21h
End
Input:
Ah01h
Output:
The character ‘a’ is display along with ASCII value AX=0061.
Result:
Thus the program for keyboard input with echo using TASM software is executed
successfully.
Dos Function Calls
1) Display a character:
Program:
. Model Small
. Stack
. Data
. Code
Mov ah, 02h
Mov Dl, ‘a’
Int 21h
End
Input:
Character ‘a’ is given as input.
Output:
Character ‘a’ is display as output along with ASCII value DX=0061
Result:
Thus the program to display a character has successfully executed and output is
verified.
2) Display a String:
Program:
. Model Small
. Stack
. Data
Stg db “display a string”,’$’
. Code
Mov ax, @data
Mov ds, ax
Mov ah, 09h
Lea dx, stg
Int 21h
End
Input:
“ Display a string” is given as input.
Output:
Display a string is obtained as output.
Result:
Thus the program to display a string was successfully executed and output is verified.
3) Input a character:
Program:
. Model small
. Stack
. Data
. Code
Mov ah, 01h
Int 21h
End
Input:
Ah01h
‘A’ is entered as input.
Output:
The character ‘a’ is displayed along with ASCII value i.e. AX=0161
Result:
Thus the program to input a character was executed successfully and the result is
verified
4) Reading a keyboard without Echo
Program:
. Model small
. Stack
. Data
. Code
Mov ah, 08h
Int 21h
Int 21h
End
Input:
Ah 08h
Press a char ‘a’
Output:
The character ‘a’ is not displayed but ASCII value is AX=0861
Result:
Thus the program to read a keyboard character without echo is executed successfully
by TASM result is verified.
Modular Program
1) Fibonacci series:
Aim: Write a program to generate fibonnaci series.
Apparatus: System with TASM software.
Program:
. Model small
. Stack
. Data
. Code
Mov ax, @data
Mov ds, ax
Mov cl, 05h
Mov al, 00h
Mov bl, 01h
Mov si, 0000h
Mov [si], al
Inc si
Mov [si], bl
Up: add al, bl
Inc si
Mov [si], al
Xchg al, bl
Loop up
Int 21h
End
Input:
Cl 05h
Output:
Result:
Thus the program to find the fibonacci series is executed successfully using
TASM software and output is verified.
2) Factorial of a given numbers
Aim: To write an ALP program to generate factorial of a given numbers.
Apparatus: System with TASM software.
Program:
. Model small
. Stack
. Data
. Code
Mov ax, @data
Mov ds, ax
Mov ax, 0001h
Mov cl, 05h
Up: Mul cl
Dec cl
Jnz up
Int 21h
End
Input:
Cl 05h
Output:
Result:
Thus the factorial of a given number was executed successfully using TASM and
result is verified.
3) Largest number of a given ‘n’ numbers
Aim: To write an ALP program to generate largest number of a given number.
Apparatus: System with TASM software.
Program:
. Model small
. Stack
. Data
List db 02h, 09h, 03h, 06h, 08h, 07
. Code
Mov ax, @data
Mov ds, ax
Mov si, offset list
Mov cl, 05h
Mov ax, 0000h
Mov al, [si]
Up: Inc si
Cmp al, [si]
Jnb go
Mov al, [si]
Go: loop up
Int 21h
End
Input:
02h, 09h, 03h, 06h, 08h, 07
Output:
Result:
Thus the factorial largest number of a given ‘n’ number program was executed
successfully using TASM and result is verified.
4) Smallest number of a given ‘n’ numbers
Aim: To write an ALP program to generate smallest number of a given number.
Apparatus: System with TASM software.
Program:
. Model small
. Stack
. Data
List db 02h, 09h, 03h, 06h, 08h, 07
. Code
Mov ax, @data
Mov ds, ax
Mov si, offset list
Mov cl, 05h
Mov al, 00h
Mov al, [si]
Up: Inc si
Cmp al, [si]
Jnb go
Mov al, [si]
Go: loop up
Int 21h
End
Input:
02h, 09h, 03h, 06h, 08h, 07
Output:
Result:
Thus the factorial smallest number of a given ‘n’ number program was executed
successfully using TASM and result is verified.
5) Display the system time
Aim: To write an ALP to display the system time in cursor position continuously.
Dos function code 2 ch of int 21
When this function is executed, it reads hours, Minutes & Seconds from main
memory and stores it in the following specified registers.
CH=Hour (0 to 23)
CL=Minutes (0 to 59)
DH=Seconds (0 to 59)
Text display function code 02h 0f int 10h
It sets the cursor position and displays the content.
It uses the following specified registers.
DH=cursor row (0 to 24)
DL=cursor column (0 to 79 for 80 X 25 display)
(0 to 39 for 40 X 25 display)
BH=video page no.
Program:
. Model small
. Stack
. Data
Stg1 db’the time is’
Stg2 db 2 dup (0),’:’
Stg3 db 2 dup (0),’:’
Stg4 db 2 dup (0), 0dh, 0ah,’$’
Hrs db 0
Min db 0
Sec db 0
. Code
Main proc
Begin: Mov ax, @data
Mov ds, ax
Mov ah, 2ch
Int 21h
Mov Hours, ch
Mov Min, cl
Mov sec, DH
Lea bx, stg2+2
Xor ax, ax
Mov al, Hrs
Call num
Mov [bx], ax
Lea bx, stg3+2
Xor ax, ax
Mov al, Min
Call num
Mov al, [`bx], ax
Lea bx, stg4+2
Xor ax, ax
Mov al, Sec
Call num
Mov [bx], ax
Mov ah, 00
Mov al, 03
Mov ah, 02
Mov BH, 00
Mov DH, 05
Mov dl, 32
Lea dx, stg1
Mov ah, 09h
Int 21h]
Jmp begin
Main endp
Num proc
Mov ah, 00
Mov dl, 10
Div dl
Or ax, 3030h
Ret
Num endp
End
Result:
Thus the ‘ display the time ‘ output is display.
Cycle-2
8279- keyboard display: