VISVESVARAYA TECHNOLOGICAL UNIVERSITY

GNANA SANGAM, BELGAUM-590014

“MICROPROCESSOR LABORATORY”
Submitted in partial fulfillment of requirements for the
IV semester microprocessor laboratory [06CSL48]
BACHELOR OF ENGINEERING
IN
COMPUTER SCIENCE & ENGINEERING

GSS INSTITUTE OF TECHNOLOGY

Department of Computer Science and Engineering
#37/2, New Byrohalli Road, Kommaghatta,
Kengeri Upnagar, Bangalore-560060
 Department of Computer Science and Engineering

Laboratory Certificate

This is to certify that Mr. /MS.______________________________________________

bearing USN:____________________ has been successfully completed the lab programs of IV

semester Microprocessor Laboratory in partial fulfillment for the award of degree of Bachelors

of Engineering in Computer science and Engineering of the VTU, Belgaum during the year

2010-2011.

Signature of the Lab Incharge Signature of Head of the department

Submitted for the Practical Examination

Held on ________________________

External Examiner Internal Examiner

2
 INDEX
Exp Dat Name of the Experiments Pag
t. e e.
No. No.
01 a Search a key element in a list of ‘n’ 16-bit numbers 5
using the Binary search algorithm.
b Read the status of eight input bits from the Logic 6
Controller Interface & display ‘FF’ if it is even parity
bits, otherwise display 00.
02 a Write ALP macros: 7
i. To read a character from the keyboard in module(1)
(in a different file)
ii. To display a character in Module(2) (from different
file)
iii. Use the above two modules to read a string of
characters from the. Keyboard terminated by the
carriage return & prints the string on the. Display in
the next line.
b Perform the following functions using the Logic 9
Controller Interface.
i. BCD up-down Counter ii. Ring Counter
03 a Sort a given set of ‘n’ numbers in ascending and 11
descending orders using the Bubble Sort algorithm.
b Read the status of two 8-bit inputs (X & Y) from the 12
Logic Controller Interface & display X*Y.
04 a Read an alphanumeric character and display its 13
equivalent ASCII code at the center of the screen.
b Display messages FIRE and HELP alternately with 15
flickering effects on a 7-segment display interface for
a suitable period of time. Ensure a flashing rate that
makes it easy to read both the messages.
05 a Reverse a given string and check whether it is a 17
palindrome or not.
b Assume any suitable message of 12 characters length 19
& display it in the rolling fashion on a 7-segment
display interface for a suitable period of time. Ensure a
flashing rate that makes it easy to read both the
messages.
3
06 a Read two strings, store them in locations STR1 and 21
STR2.
Check whether they are equal or not and display
appropriated messages.
Also display the length of the stored strings.
b Convert a 16-bit binary value (assumed to be an 23
unsigned integer) to BCD & display it from left to right
& right to left for specified number of times on a 7-
segment display interface.

07 a Read your name from the keyboard & display it at a 25

specified location on the screen in front of the
message What is your name?
b Drive a Stepper Motor interface to rotate the motor in 26
clockwise direction by N steps
08 a Compute the factorial of a positive integer ‘n’ using 27
recursive procedure.
b Drive a stepper motor interface to rotate the motor in 28
anticlockwise
direction by N steps
09 a Compute nCr using recursive procedure. Assume that 29
‘n’ and ‘r’ are
Non-negative integers.
b Drive a stepper motor interface to rotate the motor by 30
N steps left direction & N steps right direction (N is
specified by the examiner).
Introduce suitable delay between successive steps.
10 a Find out whether a given sub-string is present or not in 31
a main string of characters.
b Scan an 8 x 3 keypad for key closure & to store the 33
code of the key pressed in a memory location or
display on screen. Also display row & column numbers
of the key pressed.
11 a Generate the first ‘n’ Fibonacci numbers. 35
b Scan a 8 x 3 keypad for key closure & simulate ADD & 36
SUBTRACT
Operations as in a calculator.
12 a Read the current time from the system & display it in the standard 39
format on the screen.
b Generate Sine Wave using DAC interface. 41

4
13 a Program to simulate a Decimal Up-counter to display 00-99. 42
b Generate a Half Rectified Sine wave form using the DAC interface. 43
14 a Read a pair of input co-ordinates in BCD & move the cursor to the 44
Specified location on the screen.
b Generate a Fully Rectified Sine waveform using the DAC interface. 46
15 a Program to create a file (input file) & to delete an existing file. 47
b Drive an elevator interface in the following way: 49
Initially the elevator should be in the ground floor, with
all requests in OFF state. When a request is made from
a floor, the elevator should move to that floor, wait
there for a couple of seconds & then come down to
ground floor and stop. If some requests occur during
going up or coming down they should be ignored.

PROGRAM 1A: SEARCH A KEY ELEMENT IN A LIST OF ‘N’ 16-BIT NUMBERS USING THE BINARY SEARCH
ALGORITHM
DATA SEGMENT
ARR DW 2121H, 2122H, 2123H
KEY DW 2122H
N DW 03H
R DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AX,KEY ;AX with key
MOV BX,00H ; BX with low(0)
MOV DX,N ; DX with high(n)
DEC DX
MOV SI,OFFSET ARR
BACK: CMP BX, DX
JA UNSUCC ;if (low>high)
MOV CX,BX ;CX=low+high
ADD CX,DX ;CX=(low+high)/2
SHR CX,01H
MOV SI,CX
ADD SI,SI
CMP AX,[SI]
JZ SUCC
JC NEXT
MOV BX,CX
INC BX ;if (key>mid, low=mid+1)
JMP BACK
NEXT: MOV DX,CX ;if(key<mid, high=mid-1)
DEC DX
JMP BACK
SUCC: MOV R, 0FFFFH
MOV BX,R

5
 JMP LAST
UNSUCC: MOV R,0000H
MOV BX,R
LAST: INT 3H
CODE ENDS
END START

Output:

PROGRAM 1B: READ THE STATUS OF EIGHT INPUT BITS FROM THE LOGIC CONTROLLER INTERFACE &
DISPLAY ‘FF’ IF IT IS EVEN PARITY BITS, OTHERWISE DISPLAY 00.

CODE SEGMENT
ASSUME CS:CODE
START: MOV DX,9403H
MOV AL,82H
OUT DX,AL
MOV DX,9401H
IN AL,DX
MOV BL,00H
MOV CX,08H
BACK: ROR AL,01H
JNC NEXT
INC BL
NEXT: LOOP BACK
MOV DL,BL
MOV AH,02H
INT 21H
ROR BL,01H
JC NEXT1
MOV AL,0FFH
JMP DISP
NEXT1: MOV AL,00H
DISP: MOV DX,9400H
OUT DX,AL
MOV AH,4CH
INT 21H
CODE ENDS
END START

Output:

6
PROGRAM 2A: WRITE ALP MACROS:
I. TO READ A CHARACTER FROM THE KEYBOARD IN MODULE(1) (IN A DIFFERENT FILE)
II. TO DISPLAY A CHARACTER IN MODULE(2) (FROM DIFFERENT FILE)
III. USE THE ABOVE TWO MODULES TO READ A STRING OF CHARACTERS FROM THE. KEYBOARD
TERMINATED BY THE CARRIAGE RETURN & PRINTS THE STRING ON THE. DISPLAY IN THE NEXT LINE.

C:\MASM\MOD1
READ MACRO ; save in different file
MOV AH,01H
INT 21H
ENDM

C:\MASM\MOD2
WRITE MACRO ; save in different file
MOV AH,02H
INT 21H
ENDM

C:\MASM\MOD3 ;(program file)

INCLUDE:C:\MASM\MOD1
INCLUDE:C:\MASM\MOD2

DATA SEGMENT
STR DB 30H DUP(?)
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
LEA SI,STR
BACK: READ
MOV [SI],AL
INC SI
CMP AL,0DH
JNZ BACK
MOV DL,0AH

7
 WRITE
LEA SI,STR
BACK1: MOV DL,[SI]
WRITE
INC SI
CMP DL,0DH
JNZ BACK1
MOV AH,4CH
INT 21H
CODE ENDS
END START

Output:

PROGRAM 2B1:PERFORM THE FOLLOWING FUNCTIONS USING THE LOGIC CONTROLLER INTERFACE.

I. BCD UP-DOWN COUNTER

CODE SEGMENT
ASSUME CS:CODE
START: MOV DX,9403H
MOV AL,80H
OUT DX,AL
MOV CX,08H
MOV AL,01H
MOV DX,9400H
BACK: OUT DX,AL
CALL DELAY
ADD AL,01H
DAA
LOOP BACK
MOV CX,09H
BACK1: OUT DX,AL
CALL DELAY
SUB AL,01H
DAS
LOOP BACK1
MOV AH,4CH
INT 21H

DELAY PROC NEAR

PUSH CX
MOV CX,23F2H
BACK3: MOV BX,0FFFFH
BACK2: DEC BX
JNZ BACK2
LOOP BACK3
POP CX
RET
DELAY ENDP
CODE ENDS

8
 END START

Output:

II. RING COUNTER

CODE SEGMENT
ASSUME CS:CODE
START: MOV DX,9403H
MOV AL,80H
OUT DX,AL
MOV CX,20H
MOV AL,01H
MOV DX,9400H
BACK: OUT DX,AL
CALL DELAY
ROL AL,01H
LOOP BACK
MOV AH,4CH
INT 21H
DELAY PROC NEAR
PUSH CX
MOV CX,23F2H
BACK3: MOV BX,0FFFFH
BACK2: DEC BX
JNZ BACK2
LOOP BACK3
POP CX
RET
DELAY ENDP
CODE ENDS
END START

Output:

9
 PROGRAM 3A: SORT A GIVEN SET OF ‘N’ NUMBERS IN ASCENDING AND DESCENDING ORDERS USING
THE BUBBLE SORT ALGORITHM.

DATA SEGMENT
ARR DB 05H,04H,03H,02H,01H
N DB 05H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DL,N ;DL with number of elements
DEC DL
B2: LEA SI,ARR
MOV CL,DL
BACK: MOV AL,[SI]
INC SI
CMP AL,[SI]
JC NEXT ;replace ‘JC ‘by ‘JNC’ for descending order
XCHG AL,[SI] ; swapping non order elements
XCHG AL,[SI-1]
DEC CL
JNZ BACK
NEXT: DEC DL
JNZ B2
INT 3H
CODE ENDS
END START

Output:

10
 PROGRAM 3B: READ THE STATUS OF TWO 8-BIT INPUTS (X & Y) FROM THE LOGIC CONTROLLER
INTERFACE & DISPLAY X*Y.

CODE SEGMENT
ASSUME CS:CODE
START: MOV DX,9403H
MOV AL,82H
OUT DX,AL
MOV DX,9401H
IN AL,DX
MOV BL,AL
MOV AH,01H
INT 21H
IN AL,DX
MUL BL
MOV BX,9400H
OUT DX,AL
MOV AH,4CH
INT 21H
CODE ENDS
END START

Output:

11
 PROGRAM 4A: READ AN ALPHANUMERIC CHARACTER AND DISPLAY ITS ASCII CODE AT CENTER OF
THE SCREEN

DATA SEGMENT
M1 DB 10,13,'ENTER ONE ALPHA NUMERIC CHARACTER:$'
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AH,00H
MOV AL,03H
INT 10H
MOV AH,09H
LEA DX,M1 ; load effective address of m1 to DX
INT 21H
MOV AH,01H
INT 21H
MOV BL,AL
MOV CL,04H ;CL is used as counter
AND AL,0F0H
SHR AL,CL ;shift right contents of AL by\CL positions
CMP AL,0AH
JL NEXT
ADD AL,07H
NEXT: ADD AL,30H
MOV AH,02H
MOV BH,00H
MOV DX,0C28H
INT 10H

MOV AH,02H
MOV DL,AL
INT 21H

AND BL,0FH
CMP BL,0AH
JL NEXT1
ADD BL,07H
NEXT1: ADD BL,30H

12
 MOV AH,02H
MOV DL,BL
INT 21H
MOV AH,4CH
INT 21H
CODE ENDS
END START

Output:

PROGRAM 4B: DISPLAY MESSAGES FIRE AND HELP ALTERNATELY WITH FLICKERING EFFECTS ON A 7-
SEGMENT DISPLAY INTERFACE FOR A SUITABLE PERIOD OF TIME. ENSURE A FLASHING RATE THAT
MAKES IT EASY TO READ BOTH THE MESSAGES.

MODEL SMALL

.DATA
FIRE DB 86H,88H,0CFH,8EH
HELP DB 8CH,0C7H,86H,89H

.CODE
MOV AX,@DATA
MOV DS,AX
MOV AL,80H
MOV DX,303H
OUT DX,AL
RPT: LEA SI,FIRE
CALL DISPLAY ; macro display is being called
CALL DELAY
LEA SI,HELP
CALL DISPLAY
CALL DELAY
MOV AH,0BH
INT 21H
JMP RPT
MOV AH,4CH
INT21H

DISPLAY PROC
MOV CX,04H
NCHAR: MOV AL,[SI]
MOV BL,08H
NBIT: ROL AL,01H
MOV DX,301H
OUT DX,AL
PUSH AX
MOV AL,0FFH
MOV DX,302H
OUT DX,AL
MOV AL,00H
MOV DX,302H

13
 OUT DX,AL
POP AX
DEC BL
JNZ NBIT
INC SI
LOOP NCHAR
RET
DISPLAY ENDP

DELAY PROC ; to delay the execution of program

PUSH CX
PUSH BX
MOV CX,03FFH
L2: MOV BX,0FFFFH
L1: DEC BX
JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP
END

Output:

14
PROGRAM 5A: REVERSE A GIVEN STRING AND CHECK WHETHER IT IS A PALINDROME OR NOT.

DISPLAY MACRO MSG

MOV AH,09H
LEA DX,MSG
INT 21H
ENDM
DATA SEGMENT
STR1 DB 'LIRIL'
STR2 DB 30H DUP(?)
MSG1 DB 0AH,0DH,'PALINDROME$'
MSG2 DB 0AH,0DH,'NOT PALINDROME$'
COUNT DB 05H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
LEA SI,STR1
LEA DI,STR2
MOV CH,00H
MOV CL,COUNT
DEC CX
ADD SI,CX
INC CX
BACK: MOV AL,[SI]
MOV [DI],AL
INC DI
DEC SI
DEC CL
JNZ BACK
LEA SI,STR1
LEA DI,STR2
MOV CL,COUNT
BACK1: MOV AL,[SI]
CMP AL,[DI]
JNZ NEXT
INC SI
INC DI
DEC CL

15
 JNZ BACK1
DISPLAY MSG1
JMP LAST
NEXT: DISPLAY MSG2
LAST: MOV AH,4CH
INT 21H
CODE ENDS
END START

Output:

PROGRAM5B: ASSUME ANY SUITABLE MESSAGE OF 12 CHARACTERS LENGTH & DISPLAY IT IN THE
ROLLING FASHION ON A 7-SEGMENT DISPLAY INTERFACE FOR A SUITABLE PERIOD OF
TIME. ENSURE A FLASHING RATE THAT MAKES IT EASY TO READ BOTH THE
MESSAGES.

.MODEL SMALL
.DATA
MSG DB 0C7H,0C0H,0C0H,0C6H,0FFH,0C0H,0C6H,0C0H,0C6H,
DB 0FFH,88H,0C7H,0C0H,0C6H,0FFH
.CODE
MOV AX,@DATA
MOV DS,AX
MOV AL,80H
MOV DX,303H
OUT DX,AL
RPT: LEA SI,MSG
CALL DISPLAY
MOV AH,0BH
INT 21H
JMP RPT
MOV AH,4CH
INT21H

DISPLAY PROC
MOV CX,0EH
NCHAR: MOV AL,[SI]
MOV BL,08H
NBIT: ROL AL,01H
MOV DX,301H
OUT DX,AL
PUSH AX
MOV AL,0FFH
MOV DX,302H
OUT DX,AL
MOV AL,00H
MOV DX,302H
OUT DX,AL
POP AX
DEC BL
JNZ NBIT
CALL DELAY

16
 INC SI
LOOP NCHAR
RET
DISPLAY ENDP

DELAY PROC
PUSH CX
PUSH BX
MOV CX,0FFFH
L2: MOV BX,0FFFFH
L1: DEC BX
JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP
END

Output

17
PROGRAM 6A: READ TWO STRINGS, STORE THEM IN LOCATIONS STR1 AND STR2.
CHECK WHETHER THEY ARE EQUAL OR NOT AND DISPLAY APPROPRIATED MESSAGES.
ALSO DISPLAY THE LENGTH OF THE STORED STRINGS.

CLEAR MACRO
MOV AH,06H
MOV BH,03H
MOV CX,0000H
MOV DX,184FH
INT 10H
ENDM

READ MACRO
MOV AH,01H
INT 21H
ENDM

DISPLAY MACRO MSG

MOV AH,09H
LEA DX,MSG
INT 21H
ENDM
WRITE MACRO
MOV AH,02H
INT 21H
ENDM

DATA SEGMENT
S1 DB 30H DUP(00H)
S2 DB 30H DUP(?)
L1 DB ?
L2 DB ?
M1 DB 10,13,'ENTER THE STRING 1:$'
M2 DB 10,13,'ENTER THE STRING 2:$'
M3 DB 10,13,'STRINGS ARE EQUAL$'
M4 DB 10,13,'STRINGS ARE NOT EQUAL$'
M5 DB 10,13,'LENGTH OF THE STRING1:$'
M6 DB 10,13,'LENGTH OF THE STRING2:$'
DATA ENDS

CODE SEGMENT

18
 ASSUME CS:CODE,DS:DATA,ES:DATA
START:MOV AX,DATA
MOV DS,AX
MOV ES,AX
CLEAR
DISPLAY M1
LEA SI,S1
CALL READSTR
MOV L1,CL
DISPLAY M2
LEA SI,S2
CALL READSTR
MOV L2,CL
CMP L1,CL
JNZ NOTEQ
LEA SI,S1
LEA DI,S2
CLD
REPE CMPSB
JNZ NOTEQ

DISPLAY M3
JMP NEXT

NOTEQ: DISPLAY M4
NEXT: DISPLAY M5
MOV AL,L1
CALL WRITENUM
DISPLAY M6
MOV AL,L2
CALL WRITENUM
MOV AH,4CH
INT 21H

READSTR PROC NEAR

MOV CL,00H

BACK: READ
MOV [SI],AL
INC SI
INC CL
CMP AL,0DH
JNZ BACK
DEC CL
RET
READSTR ENDP

WRITENUM PROC NEAR

MOV BL,AL
AND AL,0F0H
MOV CL,04H
SHR AL,CL

19
 CMP AL,0AH
JL NEXT1
ADD AL,07H
NEXT1: ADD AL,30H
MOV DL,AL
WRITE
AND BL,0FH
CMP BL,0AH
JL NEXT2
ADD BL,07H
NEXT2: ADD BL,30H
MOV DL,BL
WRITE
RET
WRITENUM ENDP
CODE ENDS
END START

Output:

20
 PROGRAM 6B: CONVERT A 16-BIT BINARY VALUE (ASSUMED TO BE AN UNSIGNED INTEGER) TO BCD &
DISPLAY IT FROM LEFT TO RIGHT & RIGHT TO LEFT FOR SPECIFIED NUMBER OF TIMES ON A 7-
SEGMENT DISPLAY INTERFACE.

.MODEL SMALL

.DATA
A DB 0C0H,0F9H,0A4H,0B0H,99H,92H,82H,0F8H,80H,98H
BN DW 0FFH

.CODE
MOV AX,@DATA
MOV DS,AX
MOV AL,80H
MOV DX,303H
OUT DX,AL
MOV CX,BN
MOV DX,00H
NEXT: MOV AL,DL
ADD AL,01H
DAA
MOV DL,AL
MOV AL,DH
ADC AL,00H
DAA
MOV DH,AL
LOOP NEXT
MOV CX,08H
RPT: PUSH CX
CALL DELAY
MOV CH,04H
MOV CL,04H
NDIGIT: LEA BX,A
MOV AX,DX
AND AX,000FH
XLAT
PUSH DX
CALL DISPLAY
POP DX
ROR DX,CL
DEC CH
JNZ NDIGIT

21
 CALL DELAY
MOV CH,04H
NDIG: ROL DX,CL
MOV AX,DX
AND AX,000FH
LEA BX,A
XLAT
PUSH DX
CALL DISPLAY
POP DX
DEC CH
JNZ NDIG
POP CX
LOOP RPT
MOV AH,4CH
INT 21H

DISPLAY PROC
MOV BL,08H
NBIT: MOV DX,301H
ROL AL,01H
OUT DX,AL
PUSH AX
MOV DX,302H
MOV AL,0FFH
OUT DX,AL
MOV AL,00H
OUT DX,AL
POP AX
DEC BL
JNZ NBIT
RET
DISPLAY ENDP

DELAY PROC
PUSH CX
PUSH BX
MOV CX,0FFFH
L2: MOV BX,0FFFFH
L1: DEC BX
JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP
END

Output:

22
PROGRAM 7A: READ YOUR NAME AND DISPLAY IT ON A SPECIFIED LOCATION ON THE SCREEN IN
FRONT OF “ WHAT IS YOUR NAME?”

CLEAR MACRO
MOV AH,06H
MOV BH,03H
MOV CX,0000H
MOV DX,184FH
INT 10H
ENDM

READ MACRO
MOV AH,01H
INT 21H
ENDM

DISPLAY MACRO MSG

MOV AH,09H
LEA DX,MSG
INT 21H
ENDM

DATA SEGMENT
M1 DB 10,13,'ENTER YOUR NAME:$'
M2 DB 10,13,'WHAT IS YOUR NAME?:$'
STR DB 30H DUP(00H)
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
CLEAR
DISPLAY M1
LEA SI,STR
BACK: READ
MOV [SI],AL
INC SI
CMP AL,0DH
JNZ BACK
DEC SI
MOV AL,24H;($)
MOV [SI],AL
CLEAR

23
 MOV AH,02H
MOV BH,00H
MOV DX,0C09H
INT 10H
DISPLAY M2
DISPLAY STR
MOV AH,4CH
INT 21H
CODE ENDS
END START
Output:

PROGRAM 7B: DRIVE A STEPPER MOTOR INTERFACE TO ROTATE A MOTOR IN CLOCKWISE DIRECTION
BY N STEPS

DATA SEGMENT
ARR DB 03H,09H,0CH,06H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,9403H
MOV AL,80H
OUT DX,AL
MOV DX,9402H
MOV CX,02H
BACK1: MOV BL,04H
LEA SI,ARR
BACK: MOV AL,[SI]
OUT DX,AL
CALL DELAY
INC SI
DEC BL
JNZ BACK
LOOP BACK1
MOV AH,4CH
INT 21H
DELAY PROC NEAR
PUSH CX
PUSH BX
MOV CX,23F2H
BACK3: MOV BX,0FFFFH
BACK2: DEC BX
JNZ BACK2
LOOP BACK3
POP BX
POP CX
RET
DELAY ENDP
CODE ENDS
END START

24
Output:

PROGRAM 8A: COMPUTE THE FACTORIAL OF A POSITIVE INTEGER ‘N’ USING RECURSIVE PROCEDURE.

DATA SEGMENT
N DB 05H
F DB ?
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AL,01H
MOV CL,N
CALL FACT
MOV F,AL
INT 3H
FACT PROC NEAR
CMP CL,00H
JZ LAST
MUL CL
DEC CL
CALL FACT
LAST:RET
FACT ENDP
CODE ENDS
END START

Output:

25
 PROGRAM 8B: DRIVE A STEPPER MOTOR INTERFACE TO ROTATE THE MOTOR IN ANTICLOCKWISE
DIRECTION BY N STEPS

DATA SEGMENT
ARR DB 06H,0CH,09H,03H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,9403H
MOV AL,80H
OUT DX,AL
MOV DX,9402H
MOV CX,02H
BACK1: MOV BL,04H
LEA SI,ARR
BACK: MOV AL,[SI]
OUT DX,AL
CALL DELAY
INC SI
DEC BL
JNZ BACK
LOOP BACK1
MOV AH,4CH
INT 21H
DELAY PROC NEAR
PUSH CX
PUSH BX
MOV CX,23F2H
BACK3: MOV BX,0FFFFH
BACK2: DEC BX
JNZ BACK2
LOOP BACK3
POP BX
POP CX
RET
DELAY ENDP
CODE ENDS
END START

26
Output:

PROGRAM 9A: COMPUTE NCR USING RECURSIVE PROCEDURE. ASSUME THAT ‘N’ AND ‘R’ ARE
NON-NEGATIVE INTEGERS.

DATA SEGMENT
N DW 07H
R DW 02H
RES DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AX,N
MOV BX,R
CALL NCR
INT 3H
NCR PROC NEAR
CMP AX,BX
JZ NEXT
MOV CX,01H
CMP BX,CX
JZ NEXT1
MOV DX,AX
DEC DX
CMP DX,BX
JZ NEXT1
PUSH AX
PUSH BX
DEC AX
CALL NCR
POP BX
POP AX
PUSH AX
PUSH BX
DEC AX
DEC BX
CALL NCR
POP BX
POP AX
JMP LAST
NEXT: MOV DX,01H

27
 MOV RES,DX
RET
NEXT1: ADD RES,AX
RET
LAST: RET
NCR ENDP
CODE ENDS
END START

Output:

PROGRAM 9B: DRIVE A STEPPER MOTOR INTERFACE TO ROTATE BOTH IN CLOCKWISE AND
ANTICLOCKWISE DIRECTION

DATA SEGMENT
ARR DB 03H,09H,0CH,06H
ARR1 DB 06H,0CH,09H,03H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,9403H
MOV AL,80H
OUT DX,AL
MOV DX,9402H
MOV CX,02H
BACK1: MOV BL,04H
LEA SI,ARR
BACK: MOV AL,[SI]
OUT DX,AL
CALL DELAY
INC SI
DEC BL
JNZ BACK
LOOP BACK1
MOV CX,02H
BACK4: MOV BL,04H
LEA SI,ARR1
BACK5: MOV AL,[SI]
OUT DX,AL
CALL DELAY
INC SI
DEC BL
JNZ BACK5
LOOP BACK4
MOV AH,4CH
INT 21H
DELAY PROC NEAR
PUSH CX
PUSH BX
MOV CX,23F2H
BACK3: MOV BX,0FFFFH

28
 BACK2: DEC BX
JNZ BACK2
LOOP BACK3
POP BX
POP CX
RET
DELAY ENDP
CODE ENDS
END START
Output:

PROGRAM 10A: FIND OUT WHETHER A GIVEN SUB-STRING IS PRESENT OR NOT IN A MAIN STRING OF
CHARACTERS.

CLEAR MACRO
MOV AH,06H
MOV BH,03H
MOV CX,0000H
MOV DX,184FH
INT 10H
ENDM

READ MACRO
MOV AH,01H
INT 21H
ENDM

DISPLAY MACRO MSG

MOV AH,09H
LEA DX,MSG
INT 21H
ENDM

DATA SEGMENT
STR1 DB 30H DUP(00H)
STR2 DB 30H DUP(00H)
L1 DW ?
L2 DW ?
M1 DB 10,13,'ENTER THE MAIN STRING:$'
M2 DB 10,13,'ENTER THE SUB STRING:$'
M3 DB 10,13,'SUCESS$'
M4 DB 10,13,'UNSUCESS$'
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA,ES:DATA
START: MOV AX,DATA
MOV DS,AX
MOV ES,AX
CLEAR
DISPLAY M1

29
 LEA SI,STR1
CALL READSTR
MOV L1,CX

DISPLAY M2
LEA SI,STR2
CALL READSTR
MOV L2,CX
LEA SI,STR1
MOV BX,L1
BACK: LEA DI,STR2
MOV CX,L2
CMP CX,BX
JA UNSUCC
PUSH SI
PUSH BX
CLD
REPE CMPSB
JZ SUCC
POP BX
POP SI
INC SI
DEC BX
JMP BACK
SUCC: DISPLAY M3
JMP LAST
UNSUCC: DISPLAY M4
LAST: MOV AH,4CH
INT 21H
READSTR PROC NEAR

MOV CX,0000H
BACK1: READ
MOV [SI],AL
INC SI
INC CX
CMP AL,0DH
JNZ BACK1
DEC CX
RET
READSTR ENDP
CODE ENDS
END START
Output:

30
 PROGRAM 10B: SCAN 8X3 KEYPAD CLOSURE AND STORE THE CODE OF THE KEY PRESSED IN A
MEMORY LOCATION OR DISPLAY IT ON THE SCREEN.ALSO DISPLAY ROW AND COLUMN OF THE KEY
PRESSED

WRITE MACRO DIGIT

MOV DL,DIGIT
MOV AH,02H
INT 21H
ENDM

DISPLAY MACRO MSG

MOV AH,09H
LEA DX,MSG
INT 21H
ENDM

DATA SEGMENT
ARR DB '0123456789+-*/=%CE'
M1 DB 0AH,0DH,'ROW NUMBER IS:$'
M2 DB 0AH,0DH,'COLUMN NUMBER IS:$'
ROW DB 31H
COL DB 31H
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,9403H
MOV AL,90H
OUT DX,AL
BACK: MOV DX,9402H
MOV AL,01H
OUT DX,AL
MOV DX,9400H
IN AL,DX
CMP AL,00H
JNZ FIRST
MOV DX,9402H
MOV AL,02H

31
 OUT DX,AL
MOV DX,9400H
IN AL,DX
CMP AL,00H
JNZ SECOND
MOV DX,9402H
MOV AL,04H
OUT DX,AL
MOV DX,9400H
IN AL,DX
CMP AL,00H
JNZ THIRD
JMP BACK
FIRST: LEA SI,ARR
JMP COLUMN
SECOND: INC ROW
LEA SI,ARR
ADD SI,08H
JMP COLUMN
THIRD: INC ROW
INC ROW
LEA SI,ARR
ADD SI,10H
COLUMN: ROR AL,01H
JC DISP
INC COL
INC SI
JMP COLUMN
DISP: MOV AL,[SI]
WRITE AL
DISPLAY M1
WRITE ROW
DISPLAY M2
WRITE COL
MOV AH,4CH
INT 21H
CODE ENDS
END START

Output:

32
PROGRAM 11A: GENERATE THE FIRST ‘N’ FIBONACCI NUMBERS.

DATA SEGMENT
N DB 07H
ARR DB 30H DUP(?)
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
LEA SI,ARR
MOV CL,N
CMP CL,00H
JZ LAST
MOV AL,00H
MOV [SI],AL
INC SI
DEC CL
JZ LAST
MOV AL,01H
MOV [SI],AL
INC SI
DEC CL
CMP CL,00H
JZ LAST
MOV AL,[SI-1]
BACK: ADD AL,[SI-2]
MOV [SI],AL
INC SI
DEC CL
JNZ BACK
LAST: INT 3H
CODE ENDS
END START

Output:

33
 PROGRAM 11B: SCAN A 8 X 3 KEYPAD FOR KEY CLOSURE & SIMULATE ADD & SUBTRACT
OPERATIONS AS IN A CALCULATOR.

WRITE MACRO DIGIT

MOV DL,DIGIT
MOV AH,02H
INT 21H
ENDM

KBREAD MACRO
MOV AH,01H
INT 21H
ENDM

DISPLAY MACRO MSG

MOV AH,09H
LEA DX,MSG
INT 21H
ENDM

DATA SEGMENT
ARR DB '0123456789+-*/=%CE'
M1 DB 0AH,0DH,'INVALID OPERATOR$'
OP1 DB ?
OP2 DB ?
OPR DB ?
RES DB ?
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DX,AX
MOV DX,9403H
MOV AL,90H
OUT DX,AL
CALL KEYSTRK
SUB AL,30H
MOV OP1,AL
KBREAD

34
 CALL KEYSTRK
SUB AL,30H
MOV OPR,AL
KBREAD
CALL KEYSTRK
SUB AL,30H
MOV OP2,AL
WRITE '='
MOV AL,OPR
CMP AL,'+'
JNZ SUBTRACT
MOV BL,OP1
ADD BL,OP2
CALL CONVERT
MOV RES,AL
JMP DISP
SUBTRACT: CMP AL,'-'
JNZ INVALID
MOV BL,OP1
SUB BL,OP2
JNS NEXT
WRITE '-'
NEXT: CALL CONVERT
MOV RES,AL
DISP: CALL WRES
JMP LAST
INVALID: DISPLAY M1
LAST: MOV AH,4CH
INT 21H
KEYSTRK PROC NEAR
LEA SI,ARR
BACK: MOV DX,9402H
MOV AL,01H
OUT DX,AL
MOV DX,9400H
IN AL,DX
CMP AL,00H
JNZ FIRST
MOV DX,9402H
MOV AL,02H
OUT DX,AL
MOV DX,9400H
IN AL,DX
CMP AL,00H
JNZ SECOND
JMP BACK
FIRST: ROR AL,01H
JC COL
INC SI
JMP FIRST
SECOND: ADD SI,08H
ROR AL,01H
JC COL
INC SI

35
 JMP SECOND
COL: MOV AL,[SI]
WRITE AL
RET
KEYSTRK ENDP

CONVERT PROC NEAR

MOV AL,00H
BACK1: ADD AL,01H
DAA
DEC BL
JNZ BACK1
RET
CONVERT ENDP

WRES PROC NEAR

MOV AL,RES
MOV DL,AL
AND DL,0F0H
MOV CL,04H
SHR DL,CL
ADD AH,30H
WRITE DL
AND AL,0FH
ADD AL,30H
WRITE AL
RET
WRES ENDP
CODE ENDS
END START
Output:

36
PROGRAM 12A: READ THE CURRENT TIME FROM THE SYSTEM & DISPLAY IT IN THE STANDARD
FORMAT ON THE SCREEN.

CLEAR MACRO
MOV AH,00H
MOV AL,03H
INT 10H
ENDM
WRITE MACRO DIGIT
MOV DL,DIGIT
MOV AH,02H
INT 21H
ENDM
DATA SEGMENT
HR DB ?
MIN DB ?
SEC DB ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AH,2CH
INT 21H
MOV HR,CH
MOV MIN,CL
MOV SEC,DH
MOV CL,HR
CALL HEXTODEC
MOV HR,AL
MOV CL,MIN
CALL HEXTODEC
MOV MIN,AL
MOV CL,SEC
CALL HEXTODEC
MOV SEC,AL
MOV BL,HR
CALL WRITENUM
WRITE ':'
MOV BL,MIN

37
 CALL WRITENUM
WRITE ':'
MOV BL,SEC
CALL WRITENUM
MOV AH,4CH
INT 21H
HEXTODEC PROC NEAR
MOV AL,00H
BACK: ADD AL,01H
DAA
DEC CL
JNZ BACK
RET
HEXTODEC ENDP

WRITENUM PROC NEAR

MOV BH,BL
AND BH,0F0H
MOV CL,04H
SHR BH,CL
ADD BH,30H
WRITE BH
AND BL,0FH
ADD BL,30H
WRITE BL
RET
WRITENUM ENDP
CODE ENDS
END START
CODE ENDS

Output:

38
PROGRAM 12B: Generate Sine Wave using DAC interface.

.MODEL SMALL
.DATA
A DB 00H,0BH,16H,20H,2BH,35H,3FH,48H,51H,59H,61H,68H,6DH
DB 73H,77H ,7AH, 7DH,7EH,7FH,7EH,7DH,7AH,77H,73H,6DH,68H
DB 61H,59H,51H,48H,3FH,35H ,2BH,20H,16H,0BH,00H
.CODE
MOV AX,@DATA
MOV DS,AX
MOV AL,80H
MOV DX,303H
OUT DX,AL
RPT: MOV CX,37D
MOV SI,0000H
NEXT: MOV AL,A[SI]
ADD AL,07FH
MOV DX,300H
OUT DX,AL
CALL DELAY
INC SI
LOOP NEXT
MOV CX,37D
MOV SI,0000H
NEXT1: MOV AL,07FH
SUB AL,A[SI]
MOV DX,300H
OUT DX,AL
CALL DELAY
INC SI
LOOP NEXT1
MOV AH,0BH
INT 21H
JMP RPT
MOV AH,4CH
INT 21H

DELAY PROC
PUSH CX
PUSH BX
MOV CX,10H
L2 : MOV BX,01FFH
L1 : DEC BX

39
 JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP
END

Output:
PROGRAM 13A: PROGRAM TO SIMULATE A DECIMAL UP-COUNTER TO DISPLAY 00-99.

CLEAR MACRO
MOV AH,00H
MOV AL,03H
INT 10H
ENDM

PLACE MACRO LOC

MOV AH,02H
MOV DX,LOC
MOV BH,00H
INT 10H
ENDM

WRITE MACRO
MOV AH,02H
INT 21H
ENDM

CODE SEGMENT
ASSUME CS:CODE
START: CLEAR
MOV CL,30H
BACK1: PLACE 0C28H
MOV DL,CL
WRITE
MOV BL,30H
BACK: PLACE 0C29H
MOV DL,BL
WRITE
CALL DELAY
INC BL
CMP BL,39H
JLE BACK
INC CL
CMP CL,39H
JLE BACK1
MOV AH,4CH
INT 21H
DELAY PROC NEAR
MOV AX,23F0H
BACK3: MOV DX,0FFFFH

40
 BACK2: DEC DX
JNZ BACK2
DEC AX
JNZ BACK3
RET
DELAY ENDP
CODE ENDS
END START

Output:

PROGRAM 13B: GENERATE A HALF RECTIFIED SINE WAVE FORM USING THE DAC INTERFACE.

.MODEL SMALL

.DATA
A DB 00H,0BH,16H,20H,2BH,35H,3FH,48H,51H,59H,61H,68H,6DH
DB 73H,77H ,7AH, 7DH,7EH,7FH,7EH,7DH,7AH,77H,73H,6DH,68H
DB 61H,59H,51H,48H,3FH,35H ,2BH,20H,16H,0BH,00H
.CODE
MOV AX,@DATA
MOV DS,AX
MOV AL,80H
MOV DX,303H
OUT DX,AL
RPT: MOV SI,0000H
MOV CX,37D
NEXT: MOV AL,A[SI]
ADD AL,07FH
MOV DX,300H
OUT DX,AL
CALL DELAY
INC SI
LOOP NEXT
MOV CX,37D
NEXT1: MOV AL,07FH
MOV DX,300H
OUT DX,AL
CALL DELAY
LOOP NEXT1
MOV AH,0BH
INT 21H
JMP RPT
MOV AH,4CH
INT 21H

DELAY PROC
PUSH CX
PUSH BX
MOV CX,10H
L2 : MOV BX,01FFH
L1 : DEC BX

41
 JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP
END

Output:

PROGRAM 14A: READ A PAIR OF INPUT CO-ORDINATES IN BCD & MOVE THE CURSOR TO THE
SPECIFIED LOCATION ON THE SCREEN.

CLEAR MACRO
MOV AH,00H
MOV AL,03H
INT 10H
ENDM

DISPLAY MACRO MSG

LEA DX,MSG
MOV AH,09H
INT 21H
ENDM

READ MACRO
MOV AH,01H
INT 21H
ENDM

PLACE MACRO XY
MOV AH,02H
MOV BH,00H
MOV DL,X
MOV DH,Y
INT 10H
ENDM

DATA SEGMENT
M1 DB 10,13,'ENTER X-CORDINATE$'
M2 DB 10,13,'ENTER Y-CORDINATE$'
X DB ?
Y DB ?
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
CLEAR
DISPLAY M1

42
 CALL BCDREAD
MOV X,AL
DISPLAY M2
CALL BCDREAD
MOV Y,AL
PLACE XY
READ
MOV AH,4CH
INT 21H
BCDREAD PROC NEAR
READ
SUB AL,30H
MOV BH,AL
READ
SUB AL,30H
MOV BL,AL
MOV AL,0AH
MUL BH
ADD AL,BL
RET
BCDREAD ENDP
CODE ENDS
END START

Output:

43
PROGRAM 14B: GENERATE A FULLY RECTIFIED SINE WAVEFORM USING THE DAC INTERFACE.

.MODEL SMALL

.DATA
A DB 00H,0BH,16H,20H,2BH,35H,3FH,48H,51H,59H,61H,68H,6DH
DB 73H,77H ,7AH, 7DH,7EH,7FH,7EH,7DH,7AH,77H,73H,6DH,68H
DB 61H,59H,51H,48H,3FH,35H ,2BH,20H,16H,0BH,00H

.CODE
MOV AX,@DATA
MOV DS,AX
MOV AL,80H
MOV DX,303H
OUT DX,AL
RPT: MOV SI,0000H
MOV CX,37D
NEXT: MOV AL,A[SI]
ADD AL,07FH
MOV DX,300H
OUT DX,AL
CALL DELAY
INC SI
LOOP NEXT
MOV AH,0BH
INT 21H
JMP RPT
MOV AH,4CH
INT 21H

DELAY PROC
PUSH CX
PUSH BX
MOV CX,10H
L2 : MOV BX,01FFH
L1 : DEC BX
JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP

44
END

Output:

PROGRAM 15A: PROGRAM TO CREATE A FILE (INPUT FILE) & TO DELETE AN EXISTING FILE.

CLEAR MACRO
MOV AH,00H
MOV AL,03H
INT 10H
ENDM

DISPLAY MACRO MSG

LEA DX,MSG
MOV AH,09H
INT 21H
ENDM

READ MACRO
MOV AH,01H
INT 21H
ENDM

DATA SEGMENT
S1 DB 30H DUP(?)
S2 DB 30H DUP(?)
M1 DB 10,13,'ENTER THE PATH NAME AND FILE NAME TO BE CREATED$'
M2 DB 10,13,'ENTER THE PATH NAME AND FILE NAME TO BE DELETED$'
M3 DB 10,13,'FILE IS CREATED$'
M4 DB 10,13,'FILE IS NOT CREATED$'
M5 DB 10,13,'FILE IS DELETED$'
M6 DB 10,13,'FILE IS NOT DELETED$'
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
CLEAR
DISPLAY M1
LEA SI,S1
CALL READSTR
LEA DX,S1
MOV CX,0002H
MOV AH,3CH

45
 INT 21H
JC NEXT
DISPLAY M3
JMP DEL
NEXT: DISPLAY M4
DEL : DISPLAY M2
LEA SI,S2
CALL READSTR
LEA DX,S2
MOV AH,41H
INT 21H
JC NEXT1
DISPLAY M5
JMP LAST
NEXT1: DISPLAY M6
LAST : MOV AH,4CH
INT 21H
READSTR PROC NEAR
BACK: READ
MOV [SI],AL
INC SI
CMP AL,0DH
JNZ BACK
MOV AL,00H
MOV [SI-1],AL
RET
READSTR ENDP
CODE ENDS
END START

Output:

46
PROGRAM 15B: DRIVE AN ELEVATOR INTERFACE IN THE FOLLOWING WAY:
INITIALLY THE ELEVATOR SHOULD BE IN THE GROUND FLOOR, WITH ALL REQUESTS IN OFF STATE.
WHEN A REQUEST IS MADE FROM A FLOOR, THE ELEVATOR SHOULD MOVE TO THAT FLOOR, WAIT
THERE FOR A COUPLE OF SECONDS & THEN COME DOWN TO GROUND FLOOR AND STOP. IF SOME
REQUESTS OCCUR DURING GOING UP OR COMING DOWN THEY SHOULD BE IGNORED.

.MODEL SMALL

.CODE
MOV DX,303H
MOV AL,82H
OUT DX,AL
MOV DX,300H
MOV AL,00H
OUT DX,AL
MOV AL,0F0H
OUT DX,AL
MOV DX,301H
MOV AH,01H
INT 21H
IN AL,DX
AND AL,0FH
CMP AL,0EH
JZ GROUND
CMP AL,0DH
JZ FIRST
CMP AL,0BH
JZ SECOND
JMP THIRD
GROUND:MOV AL,00H
MOV DX,300H
OUT DX,AL
JMP LAST
FIRST: MOV AL,00H
MOV DX,300H
BACK1: OUT DX,AL
CALL DELAY
CMP AL,03H
JZ NEXT1
INC AL

47
 JMP BACK1
SECOND:MOV AL,00H
MOV DX,300H
BACK2: OUT DX,AL
CALL DELAY
CMP AL,06H
JZ NEXT1
INC AL
JMP BACK2
THIRD: MOV AL,00H
MOV DX,300H
BACK3: OUT DX,AL
CALL DELAY
CMP AL,09H
JZ NEXT1
INC AL
JMP BACK3
NEXT1: OUT DX,AL
CMP AL,00H
JZ LAST
DEC AL
CALL DELAY
JMP NEXT1
LAST: MOV AH,4CH
INT 21H

DELAY PROC
PUSH CX
PUSH BX
MOV CX,0FFFH
L2 : MOV BX,0FFFFH
L1 : DEC BX
JNZ L1
LOOP L2
POP BX
POP CX
RET
DELAY ENDP
END

Output:

48