Ghani Khan Choudhury Institute of

Engineering & Technology

A Centrally Funded Technical Institute (CFTI) under Ministry of Education Govt of India

Lab Manual

Programme B. Tech
Course Affiliated by MAKAUT
Laboratory Name Microprocessor &
Microcontroller
Course Code PC-EE 692
Year & Semester 2nd Yr. 4th Sem
List of Experiment to be performed as per the latest
Syllabusby MAKAUT

1. Programs for 16-bit arithmetic operations for 8086 (using

variousaddressing modes)
2. Program for sorting an array for 8086
3. Program for searching for a number or character in a string for 8086
4. Program for String manipulations for 8086
5. Program for digital clock design using 8086.
6. Interfacing ADC and DAC to 8086.
7. Parallel communication between two microprocessors using 8255.
8. Serial communication between two microprocessor kits using 8251.
9. Interfacing to 8086 and programming to control stepper motor.
10. Programming using arithmetic, logical and bit
manipulationinstructions of 8051
11. Program and verify Timer/Counter in 8051.
12. Program and verify interrupt handling in 8051.
13. UART operation in 8051.
14. Interfacing LCD to 8051.
15. Interfacing matrix or keyboard to 8051.
16. Data transfer from peripheral to memory through DMA
controller 8237/8257
 EXPERIMENT NO. 01
Programs for 16-bit arithmetic operations for 8086
AIM: Write an ALP to 8086 to perform 16-bit arithmetic operations in various Addressing
Modes.

TOOLS: PC installed with MASM

ALGORITHM:

Step I : Initialize the Data segment memory.

Step II : Initialize the Extra segment memory.
Step III : Load the first number into AX register.
Step IV : Add two numbers.
Step V : Store the result in Extra segment.
Step VI : Terminate the program
Step VII : Stop.

FLOW CHART: START

INITIALIZATION OF DATA
& EXTRA SEGMENT

AXOPR1

AXAX+OPR2
SUMAX

STOP

PROGRAM:
(A) 16-bit addition using different addressing modes
ASSUME CS: CODE, DS: DATA, ES: EXTRA
DATA SEGMENT
OPR1 DW 5169H
OPR2 DW 1000H
DATA ENDS
EXTRA SEGMENT
SUM DW ?
EXTRA ENDS CODE
SEGMENT START:
MOV AX, DATA
MOV DS, AX ; REGISTER ADDRESIING MODE
MOV AX, OPR1 ; DIRECT ADDRESSING MODE
ADD AX, OPR2 ; DIRECT ADDRESSING MODE
MOV SUM, AX ; DIRECT ADDRESSING MODE
INT 03H
CODE ENDS
END START
END
(B)16-bit subtraction using different addressing modes
ALGORITHM:

Step I : Initialize the data & extra segment memory.

Step II : Load the first number into AX register.
Step IV : Sub AX from OPR2.
Step V : Store result in extra segment
Step VI : verify the result.
Step VII : Stop.

FLOW CHART:
START

INITIALIZATION OF DATA
SEGMENT

AXOPR1

AXAX-OPR2
DIFFAX

STOP
PROGRAM:
ASSUME CS:CODE, DS:DATA,ES:EXTRA
DATA SEGMENT
OPR1 DW 5169H
OPR2 DW 1000H
DATA ENDS EXTRA
SEGMENT
DIFF DW ?
EXTRA ENDS
CODE SEGMENT
START:
MOV AX, DATA
MOV DS, AX ;REGISTER ADDRESIING MODE
MOV AX, EXTRA
MOV ES, AX ;REGISTER ADDRESIING MODE
MOV BX, OFFSET OPR1 ;DIRECT ADDRESSING MODE
MOV AX, [BX] ; BASE ADDRESSING MODE/
SUB AX, OPR2 ;DIRECT ADDRESSING MODE
MOV DIFF , AX ;DIRECT ADDRESSING MODE
INT 03H
CODE ENDS
END START
END
(C) 16-bit Multiplication using different addressing modes
ALGORITHM:

Step I : Initialize the data & extra segment memory.

Step II : Load the first number into AX register.
Step III : Load the second number into BX register.
Step IV : Multiply AX with BX.
Step V : store lower word in accumulator into extra segment.
Step VI : Store Upper word in DX register into extra segment
Step VII : Verify the result.
Step VIII : Stop.
FLOW CHART: START

INITIALIZATION OF
DATA &
EXTRASEGMENT

AXOPR1
BXOPR2

MULTIPLY THE TWO

NUMBERS & STORE THE
RESULT IN EXTRA
SEGMENT

STOP

PROGRAM:
ASSUME CS: CODE, DS: DATA, ES: EXTRA
DATA SEGMENT
OPR1 DW 5169H
OPR2 DW 1000H
DATA ENDS
EXTRA SEGMENT
RES DW 2 DUP(0)
EXTRA ENDS
CODE SEGMENT
START:
MOV AX, DATA
MOV DS, AX ; REGISTER ADDRESIING MODE
MOV AX, EXTRA
MOV ES, AX ; REGISTER ADDRESIING MODE
MOV SI, OFFSET OPR1
MOV AX, [SI] ; INDEXED ADDRESSING MODE
 MOV BX,OPR2 ; DIRECT ADDRESSING MODE
MUL BX ; REGISTER ADDRESSING MODE
MOV RES, AX ; DIRECT ADDRESSING MODE
MOV RES+2, DX ; DIRECT ADDRESSING MODE
INT 03H
CODE ENDS
END START
END

(D)16-bit Division using different addressing modes

ALGORITHM:
Step I : Initialize the data & extra segment memory.
Step II : Load the first number into DX:AX register pair.
Step III : Load the second number into BX register.
Step IV : Divide DX:AX pair by BX.
Step V : store the Quotient in AX register into extra segment.
Step VI : Store the reminder in DX register into extra segment.
Step VII : Verify the result.
Step VIII : Stop.
START
FLOW CHART:

INITIALIZATION OF DATA &EXTRA SEGMENT

LOAD THE NUMBERS INTO RESPECTIVE REGISTERS

DIVISION OF DX:AX BY BX

STORE THE RESULT INTO THE EXTRA SEGMENT

STOP
PROGRAM:

ASSUME CS: CODE, DS:DATA, ES:EXTRA

DATA SEGMENT

OPR1 DD 74105169H

OPR2 DW 7875H

DATA ENDS

EXTRA SEGMENT

DIVQ DW ?

DIVR DW ?

EXTRA ENDS

CODE SEGMENT

START:MOV AX, DATA

MOV DS, AX ; REGISTER ADDRESIING MODE

MOV AX, EXTRA
MOV ES, AX ; REGISTER ADDRESIING MODE

MOV SI, OFFSET OPR1

MOV AX, [SI] ; INDEXED ADDRESSING MODE/

MOV DX, [SI+2] ; INDEXED ADDRESSING MODE

MOV BX, OPR2 ; DIRECT ADDRESSING MODE

DIV BX ; REGISTER ADDRESSING MODE

MOV DIVQ , AX

MOV DIVR , DX

INT 03H

CODE ENDS

END START

END
Result:
UNSIGNED NUMBERS
INPUT: OPR1 =
OPR2 =
OUTPUT: ALL RESULTS ARE STORED IN EXTRA SEGMENT (ES)
SUM =
DIFF=
MUL=
MUL+2=
DIVQ=
DIVR=
 EXPERIMENT NO. 02
Program for sorting an array for 8086
AIM: Write and execute an ALP to 8086 processor to sort the given 16-bit numbers in
Ascending and Descending order.

TOOLS: PC installed with MASM 6.11

ALGORITHM:

Step I: Initialize the data segment memory.

Step II: Initialize the number of elements counter
Step III : Initialize the comparisons counter..
Step IV: Load the numbers into respective registers
Step V: Compare the elements. If first element < second element goto step VII
Else go to next step.
Step VI: Swap the numbers in the memory..
Step VII: Increment memory pointer & Decrement the comparison counter.
Step VIII: Is count = 0 ? if yes go to next step else go to step IV.
Step IX: decrement the element counter.
Step X: Is count not 0 ? go Step III else go to next step
Step IX: Stop & terminate the program.
FLOW CHART: START

INITIALIZATION OF
DATA SEGMENT

DXCOUNT-1

BACK : CXDX

SIOFFSET
ADDRESS OF LIST

AX[SI]

TRUE
IF
AX < [SI+2]

FALSE

EXCHANGE
[SI] &[SI+2]

INCREMENT SI BY 2

FALSE
IF
CX=0

TRUE

DECREMENT DX

FALSE
IF
DX=0

TRUE

STOP
 Program:
ASCENDING ORDER

ASSUME CS: CODE, DS: DATA

DATA SEGMENT
LIST DW 0125H,0144H,3001H,0003H,0002H
COUNT EQU 05H
DATA ENDS
CODE SEGMENT
START:MOV AX,DATA
MOV DS,AX
MOV DX,COUNT-1
BACK: MOV CX,DX
MOV SI, OFFSET LIST
AGAIN: MOV AX,[SI]
CMP AX,[SI+2]
JC GO
XCHG AX,[SI+2]
XCHG AX,[SI]
GO:INC SI
INC SI
LOOP AGAIN
DEC DX
JNZ BACK
INT 03H
CODE ENDS
END START
END
Result:

INPUT: (DS: 0000H) = 25H,01H,44H,01H,01H,30H,03H,00H,02H,00H

OUTPUT: (DS: 0000H) =
 DESCENDING ORDER
ALGORITHM:

Step I: Initialize the data segment memory.

Step II: Initialize the number of elements counter
Step III : Initialize the comparisons counter..
Step IV: Load the numbers into respective registers
Step V: Compare the elements. If first element > second element go to step VII
Else go to next step.
Step VI: Swap the numbers in the memory..
Step VII: Increment memory pointer & Decrement the comparison counter.
Step VIII: Is count = 0 ? if yes go to next step else go to step IV.
Step IX: decrement the element counter.
Step X: Is count not 0 ? go Step III else go to next step

Step IX: Stop & terminate the program.

FLOW CHART:
START

INITIALIZATION OF
DATA SEGMENT

DXCOUNT-1

BACK : CXDX

SIOFFSET ADDRESS
OF LIST

AGAIN: AX[SI]

TRUE
IF
AX > [SI+2]

FALSE
EXCHANGE
[SI] &[SI+2]

INCREMENT SI BY 2

FALSE
IF
CX=0 ?

TRUE
DECREMENT DX

FALSE
IF
DX=0 ?
TRUE

STOP
 DESCENDING ORDER

PROGRAM:
ASSUME CS: CODE, DS:DATA
DATA SEGMENT
LIST DW 0125H,0144H,3001H,0003H,0002H
COUNT EQU 05H
DATA ENDS
CODE SEGMENT
START:MOV AX,DATA
MOV DS,AX
MOV DX,COUNT-1
BACK:MOV CX,DX
MOV SI,OFFSET LIST
AGAIN:MOV AX,[SI]
CMP AX,[SI+2]
JAE GO
XCHG AX,[SI+2]
XCHG AX,[SI]
GO:INC SI
INC SI
LOOP AGAIN
DEC DX
JNZ BACK
INT 03H
CODE ENDS
END START
END

Result:
INPUT: (DS: 0000H) = 25H,01H,44H,01H,01H,30H,03H,00H,02H,00H
OUTPUT: (DS: 0000H) =
 EXPERIMENT NO: 03
Program for searching for a number or character in a string for 8086
AIM: Write an ALP for searching for a number or character in a string for 8086.
TOOLS: PC installed with MASM 6.11
ALGORITHM:

Step I : Initialize the Data segment (DS) & Extra segment(ES)

Step II : Load the offset address of the string into SI .
Step III : Load the number of elements in the string into CX register
Step IV : Move the character to be searched into the AL register
Step V : Scan for the character in ES. If the character is not found go to step VII else go
to next step.
Step VI : Display the message that character found and go to step VIII
Step VII : Display the message that character not found
Step VII : Stop.& Terminate the program
START
FLOW CHART:

INITIALIZATION OF DATA
&EXTRA SEGMENT

ALCHARACTER CXCOUNT,
SI, OFFSET LIST

NO
SEARCH FOR
CHARACTER

YES

DISPLAY THE MESSAGE

“CHARACTER FOUND”

DISPLAY THE MESSAGE

“CHARACTER NOT FOUND”

TERMINATE THE
PROGRAM

STOP
Program:

ASSUME CS: CODE, DS: DATA

DATA SEGMENT
STRING DB 'MRCET$'
SLEN EQU ($-STRING)
CHAR DB 'E'
MSG1 DB 'THE CHARACTER IS FOUND$'
MSG2 DB 'THE CHARACTER IS NOT FOUND$'
DATA ENDS
CODE SEGMENT
START: MOV AX, DATA
MOV DS, AX
MOV ES, AX
LEA SI, STRING
MOV CX, LEN
MOV AL, CHAR
CLD
REPNE SCASB
JNZ EXIT
LEA DX, MSG1
MOV AH, 09H
INT 21H
JMP GOTOEND
EXIT: LEA DX, MSG2
MOV AH, 09H
INT 21H
GOTOEND: MOV AH, 4CH
INT 21H
CODE ENDS
END START
RESULT: INPUT: OUTPUT:
 EXPERIMENT NO. 04
Program for String manipulations for 8086
AIM: To write an assembly language program to move the block of data from a source
BLOCK to the specified destination BLOCK.

TOOLS: PC installed with MASM 6.11

A) BLOCK TRANSFER
ALGORITHM:

Step I : Initialize the Data segment (DS) & Extra segment(ES)

Step II : Load the offset address of source and destination the string into SI and DI.
Step III : Load the number of elements of the string into Count register(CL)
Step IV : Clear Direction flag(DF) to make SI and DI into auto increment mode
Step V : move the character by character from source to destination till the end
Step VI : Stop & Terminate the program

Flow chart: START

INITIALIZATION OF DATA &EXTRA SEGMENT

Load the offset address of source and destination

the string into SI and DI.

Load the number of elements of the string into

Count register(CL) Clear Direction flag(DF)

Move the character by character from source to

destination till the end

STOP
PROGRAM:
ASSUME CS: CODE, DS: DATA
DATA SEGMENT
STRING DB „MICROPROCESSOR$‟
COUNT EQU ($-STRING)
ORG 0070H
DATA ENDS
EXTRA SEGMENT
ORG 0010H
STRING1 DB ?
EXTRA ENDS
CODE SEGMENT
START:
MOV AX,DATA
MOV DS,AX
MOV AX, EXTRA
MOV ES,AX
MOV SI,OFFSET STRING
MOV DI,OFFSET STRING1
MOV CL,COUNT
CLD
REP MOVSB
INT 03H
CODE ENDS
END START
END
RESULT:
INPUT: (DS: 0000H) = MICROPROCESSOR
OUTPUT: (ES: 0010H) = MICROPROCESSOR
 B) REVERSE STRING

AIM: To write an assembly language program to reverse the given string.

TOOLS: PC installed with MASM 6.11

ALGORITHM:

Step I : Initialize the Data segment (DS) & Extra segment(ES)

Step II : Load the offset address of source and destination the string into SI and DI.
Step III : Load the number of elements of the string into Count register(CX)
Step IV : Add CX to DI to Point to last location of the memory
Step V : move the character by character from source to destination till the end
Step VI : Stop & Terminate the program

START

INITIALIZATION OF DATA &EXTRA SEGMENT

Load the offset address of source and destination

the string into SI and DI.

Load the number of elements of the string into

Count register(CX)
Add CX to DI to Point to last location of the

Move the character by character from source to

destination till the end

STOP
PROGRAM:

ASSUME CS: CODE, DS: DATA ,ES:EXTRA

DATA SEGMENT
STRING1 DB 'MICROPROCESSOR$'
STRLEN EQU ($-STRING1)
DATA ENDS
EXTRA SEGMENT
STRING2 DB ?
EXTRA ENDS
CODE SEGMENT
START: MOV AX, DATA
MOV DS, AX
MOV AX, EXTRA
MOV ES, AX
MOV SI, OFFSET STRING1
MOV DI, OFFSET STRING2

MOV CX, STRLEN-1

ADD DI, CX
MOV DL,'$'
MOV ES:[DI],DL
AGAIN: DEC DI
MOV AL,DS:[SI]
MOV ES:[DI],AL
INC SI
DEC CX
JNZ AGAIN
INT 3H
RESULT:
INPUT: ' MICROPROCESSOR‟

OUTPUT: „ROSSECORPORCIM‟
C) LENGTH OF THE STRING

AIM: To write an assembly language program to find the length of the given string.

TOOLS: PC installed with MASM 6.11

ALGORITHM:

Step I : Initialize the data segment(DS)

Step II : Initialize the counter CL with 0
Step III : Move stating address of the string to SI register
Step IV : Move the each character from memory to to Accumulator(AL)
Step V : Compare AL with last character of the string i.e $ and increment CL Until ZF=0
Step VII : Store the result
Step VIII : Stop. START

Initialization of Data Segment

Initialize the counter CL with 0

Move stating address of the string to SI register

Move the each character from memory to to

Accumulator(AL) and Increment CL

Compare AL with last character of the string i.e $

and increment CL Until ZF=0

NO
ZF=0 ?

YES

Decrement CL

STOP
PROGRAM:

ASSUME CS:CODE, DS:DATA

DATA SEGMENT
STRING1 DB 'MICROPROCESSOR AND INTERFACING LAB$'
SLENGTH DB 0
DATA ENDS
CODE SEGMENT
START: MOV AX, DATA
MOV DS, AX
SUB CL, CL
MOV SI, OFFSET STRING1
CLD
BACK: LODSB
INC CL
CMP AL,'$'
JNZ BACK
DEC CL
MOV SLENGTH, CL
INT 03H
CODE ENDS
END START

RESULT: INPUT: 'MICROPROCESSOR AND INTERFACING LAB

OUTPUT:

D) STRING COMPARISON

AIM: Write an ALP to 8086 to compare the given strings.

TOOLS: PC installed with MASM 6.11

ALGORITHM:

Step I : Initialize the data segment (DS) & extra Segment as per requirement
Step II : Load the offset address of source and destination of the string into SI and DI.
Step III : Initialize the counter register CX with length of source string
Step IV : Clear Direction flag (DF) to make SI and DI into auto increment mode
Step V : Compare source string with destination string until the characters are not equal
or up to last last character
Step VII : If ZF=0 the strings are equal or otherwise the strings are not equal
Step VIII : Stop.

START

Initialization of data & extra segment

Load the offset address of source and destination the

string into SI and DI.

Initialize the counter register CX with length of

source string

Clear Direction flag(DF) to make SI and DI into

auto increment mode

Compare source string with destination string until

the characters are not equal or up to last character

NO
ZF=0

YES

The strings are equal

The strings are NOT equal

START
Program:
ASSUME CS: CODE, DS:DATA, ES:EXTRA
DATA SEGMENT
STRING1 DB 'MRCET'
STRLEN EQU ($-STRING1)
SNOTEQUAL DB 'STRINGS ARE UNEQUAL$'
SEQUAL DB 'STRINGS ARE EQUAL$'
DATA ENDS
EXTRA SEGMENT
STRING2 DB 'MRCET'
EXTRA ENDS
CODE SEGMENT
START: MOV AX,DATA
MOV DS,AX
MOV AX,EXTRA
MOV ES,AX
MOV SI,OFFSET STRING1
MOV DI,OFFSET STRING2
CLD
MOV CX,STRLEN
REPZ CMPSB
JZ FORW
MOV AH, 09H
MOV DX, OFFSET SNOTEQUAL
INT 21H
JMP EXITP
FORW: MOV AH,09H
MOV DX, OFFSET SEQUAL
INT 21H
EXITP: MOV AH, 4CH
INT 03H
CODE ENDS
END START
RESULT: INPUT:

OUTPUT:

(E) STRING INSERTION

AIM: To Write and execute an Assembly language Program (ALP) to 8086 processor to insert
or delete a character/ number from the given string.

TOOLS: PC installed with MASM 6.11

ALGORITHM:

Step I :Initialize the data segment (DS) & extra segment (ES)
Step II :Load the offset address of source and destination of the string into SI and DI.
Step III :Initialize the counter register CX with length of first part of source string
Step IV : Copy the first part of STRING1 in to STRING3 of extra segment
Step V : Load the offset address of STRING2 in to SI
Step VI : Copy the STRING2 in to STRING3 of extra segment after first string of STRING1
Step VII: Load the new offset address of source of the STRING1 into SI
Step VIII: Copy the second part of STRING1 in to extra segment
Step IX: Stop

Program:
ASSUME CS: CODE, DS:DATA,ES:EXTRA
DATA SEGMENT
STRING1 DB 'MICROPROCESSOR INTERFACING LAB$'
STRING2 DB „AND ‟
STRLEN EQU ($-STRING1)
ORG 0070H
DATA ENDS
EXTRA SEGMENT
ORG 0010H
STRING3 DB 38 DUP(0)
EXTRA ENDS
CODE SEGMENT
START: MOV AX, DATA
FLOW CHART:
START

Initialization of data & extra segment

Load the offset address of source and destination

string into SI and DI.

Initialize the counter register CX with length of first

part of source string

Clear Direction flag(DF) to make SI and DI into

auto increment mode

Copy the first part of STRING1 in to STRING3

of extra segment

Load the offset address of STRING2 in to SI

Copy the STRING2 in to STRING3 of extra

segment after first string of STRING1

Load the new offset address of source of the

STRING1 into SI

Load the new offset address of source of the

STRING1 into SI

Copy the second part of STRING1 in to extra

segment

STOP
MOV DS, AX
MOV AX, EXTRA
MOV ES, AX
MOV SI, OFFSET STRING1
MOV DI, OFFSET STRING3
CLD
MOV CX, 15
REP MOVSB

CLD
MOV SI, OFFSET STRING2
MOV CX,4
REP MOVSB

MOV SI, OFFSET STRING1

ADD SI,15
MOV CX, 15
REP MOVSB
INT 3H
CODE ENDS
END START

RESULT:
INPUT: STRING1: 'MICROPROCESSOR INTERFACING LAB'
STRING2:„AND ‟
OUTPUT: STRING3: „MICROPROCESSOR AND INTERFACING LAB
(F) STRING DELETION

ASSUME CS: CODE, DS:DATA, ES:EXTRA

DATA SEGMENT
STRING1 DB 'MICROPROCESSOR AND INTERFACING LAB$'
ORG 0070
DATA ENDS
EXTRA SEGMENT
ORG 0010H
STRING2 DB 40 DUP (0)
EXTRA ENDS
CODE SEGMENT
START: MOV AX, DATA
MOV DS, AX
MOV AX, EXTRA
MOV ES, AX
MOV SI, OFFSET STRING1
MOV DI, OFFSET STRING2
CLD
MOV CX, 15
REP MOVSB
CLD
MOV SI, OFFSET STRING1
ADD SI, 19
MOV CX, 15
REP MOVSB
INT 03H
CODE ENDS
END START

RESULT:
INPUT: STRING1: MICROPROCESSOR AND INTERFACING LAB'
OUTPUT: STRING2: 'MICROPROCESSOR INTERFACING LAB'
 EXPERIMENT NO. 05
Program for digital clock design using 8086

AIM: Write an ALP for digital clock design using 8086

TOOLS:
i. UXASM
ii. TKUP
iii. TKUP86 KIT
iv. FRC CABLE

PROGRAM:

; CONNECT BH4 (PORT A) TO CNLED

#INCLUDE "TKUP86.DEF"

;******* INCLUDE EXTERNS NOW

;******* START CODING HERE
;
ORG 0FFFF0H
JMPF 0F000H,0F000H ; the basic reset jump

ORG 0FF000H
START: MOV SP,STKPTR ; load stack pointer
CALL INIT8255 ; initialize 8255
MOV AL,0CH
MOV [0200H], AL
MOV AL, 00H
NXTHR: MOV CX, 003CH
NXTMNT: MOV BX,003CH
NXTSEC: CALL SECDLY
MOV DX,PA8255
MOV AL, 07H
OUT DX,AL
 DEC BX
JNE NXTSEC
MOV DX,PA8255
MOV AL,38H
OUT DX,AL
DEC CX
JNE NXTMNT
MOV DX, PA8255
MOV AL, 0C0H
OUT DX, AL
MOV AX,[0200H]
DEC AX
MOV [0200H], AX
JNE NXTHR

SECDLY: PUSH AX
PUSH BX
PUSH CX
PUSH DX
MOV CX, 1234H
DLY: NOP
NOP
LOOP DLY
POP DX
POP CX
POP BX
POP AX
RET

;******* initialize 8255

INIT8255
MOV AL,080H
MOV DX, CMD8255
 OUT DX,AL
MOV AL,00H
MOV DX,PA8255
OUT DX,AL
MOV DX,PB8255
OUT DX,AL
MOV DX,PC8255
OUT DX,AL
RET

RESULT: INPUT:

OUTPUT:
 EXPERIMENT NO: 06
Interfacing ADC and DAC to 8086

AIM: Write an ALP for interfacing ADC to 8086

TOOLS:
i. UXASM
ii. TKUP
iii. TKUP86 KIT
iv. FRC CABLE
v. ADC KIT

PROGRAM:
CONNECT BH4 (PORT A) TO DAC BH1A
CONNECT BH5 (PORTB) TO DAC BH2B
CONNECT CRO PROBES TO CND1_1 OF DAC

#INCLUDE "TKUP86.DEF"
DATA SEGMENT

PORTA EQU 9000H

PORTC EQU 9004H

CNTLPRT EQU 9006H

MEM DW 2000H

DATA ENDS

CODE SEGMENT

ASSUME CS: CODE, DS: DATA

START: MOV AX, DATA

MOV DS, AX

MOV DX, CNTLPRT

MOV AL, 98H

OUT DX, AL
 MOV AL, 01H

OUT DX, AL

MOV AL, 00

OUT DX, AL

MOV DX, PORTC

CHK: IN AL, DX

AND AL, 80H

JZ CHK

MOV DX, PORTA

IN AL, DX

MOV MEM, AL

INT 03H

CODE ENDS

END START

RESULT: INPUT :

OUTPUT :
 INTERFACING DAC TO 8086

AIM: Write an ALP for interfacing DAC to 8086

TOOLS:
i. UXASM
ii. TKUP
iii. TKUP86 KIT
iv. FRC CABLE
v. DAC KIT

PROGRAM:

; CONNECT BH4 (PORT A) TO DAC BH1A

; CONNECT BH5 (PORTB) TO DAC BH2B
; CONNECT CRO PROBES TO CND1_1 OF DAC

#INCLUDE "TKUP86.DEF"
ORG 0FFFF0H
JMPF 0F000H,0F000H
ORG 0FF000H
MOV AL,080H
MOV DX,CMD8255
OUT DX,AL
MOV AL,00H
MOV DX,PA8255
OUT DX,AL
MOV DX,PB8255
OUT DX,AL
MOV DX,PC8255
OUT DX,AL
RPT: MOV AL,00H
MOV AL,0FFH
AGAIN: MOV DX, PA8255
OUT DX, AL
CALL DELAY
CALL DELAY
CALL DELAY
 CALL DELAY
CALL DELAY
CALL DELAY
INC AX
JNE AGAIN
JMP RPT

DELAY: MOV CX, 0FF00H

NXT2: MOV BX, 1234H
NXT: NOP
NOP
NOP
NOP
NOP
DEC BX
JNE NXT
RET

RESULT: INPUT :

OUTPUT :
 EXPERIMENT NO: 07
Parallel communication between two microprocessors using 8255
AIM: Write an ALP for parallel communication between two microprocessors using 8255

TOOLS:
i. UXASM
ii. TKUP
iii. TKUP86 KIT
iv. FRC CABLE

PROGRAM: FOR DATA IN KIT

#INCLUDE "TKUP86.DEF"
ORG 0FFFF0H
JMPF 0F000H,0F000H
ORG 0FF000H
MOV AL,080H
MOV DX,CMD8255
OUT DX,AL
MOV AL,00H
MOV DX,PA8255
OUT DX,AL
MOV DX,PB8255
OUT DX,AL
MOV DX,PC8255
OUT DX,AL
RPT: MOV AL,47H
MOV DX,PA8255
OUT DX,AL
MOV DX,PB8255
OUT DX,AL
MOV DX,PC8255
OUT DX,AL
JMP RPT
PROGRAM: FOR DATA OUT KIT

#INCLUDE "TKUP86.DEF
ORG 0FFFF0H
JMPF 0F000H,0F000H

ORG 0FF000H
MOV AL,090H
MOV DX,CMD8255
OUT DX,AL
MOV AL,00H
MOV DX,PA8255
OUT DX,AL
MOV DX,PB8255
OUT DX,AL
MOV DX,PC8255
OUT DX,AL
RPT: MOV DX,PA8255
IN AL,DX
MOV [0200H],AL
MOV DX,PB8255
OUT DX,AL
MOV DX,PC8255
OUT DX,AL
` JMP RPT

RESULT:
 EXPERIMENT NO: 08
Interfacing to 8086 and programming to control stepper motor

(A) ROTATE THE STEPPER MOTOR IN ANTICLOCKWISE DIRECTION

; Connect 8255 Ports A to CNLED

;**** INCLUDE DEFINATION FILES NOW

#INCLUDE "TKUP86.DEF"

;**** START CODING HERE

ORG 0FFFF0H
JMPF 0F000H,0F000H; the basic reset jump

ORG 0FF000H
START MOV SP,STKPTR; load stack pointerCALL
INIT8255; initialize 8255
LP1 MOV AL,01H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL;
CALL DELAY; call delay
MOV AL,02H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL
CALL DELAY; call delay
MOV AL,04H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL
CALL DELAY; call delay
MOV AL,08H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL
CALL DELAY; call delayJMP START ;
restart again

;******* Delay module

DELAY NOP;
MOV CX,03500H ; load Delay count = 0x3500NOP
;
DLY1 NOP ;
LOOP DLY1 ;
RET ; end of delay

;******* initialize 8255

INIT8255
 MOV AL,080H; make all ports output
MOV DX, CMD8255;
OUT DX,AL; write to command registerMOV
AL,00H; clear all ports
MOV DX,PA8255;OUT
DX,AL;
MOV DX,PB8255;OUT
DX,AL;
MOV DX,PC8255;
OUT DX,AL;
RET;

(B) ROTATE THE STEPPER MOTOR IN CLOCKWISE DIRECTION

;***** START CODING HERE

ORG 0FFFF0H
JMPF 0F000H,0F000H; the basic reset jump

ORG 0FF000H
START MOV SP,STKPTR; load stack pointerCALL
INIT8255; initialize 8255
LP1 MOV AL,08H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL;
CALL DELAY; call delay
MOV AL,04H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL
CALL DELAY; call delay
MOV AL,02H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL
CALL DELAY; call delay
MOV AL,01H; use num1 for led count valueMOV
DX,PA8255;
OUT DX,AL
CALL DELAY; call delayJMP START ;
restart again

;******* Delay module

DELAY NOP;
MOV CX,03500H; load Delay count = 0x3500NOP ;
DLY1 NOP ;
LOOP DLY1 ;
 RET ; end of delay

;******* initialize 8255

INIT8255
MOV AL,080H ; make all ports output
MOV DX, CMD8255 ;
OUT DX,AL ; write to command register
MOV AL,00H ; clear all ports
MOV DX,PA8255 ;
OUT DX,AL ;
MOV DX,PB8255 ;
OUT DX,AL ;
MOV DX,PC8255 ;
OUT DX,AL ;
RET ;

RESULT: INPUT:

OUTPUT:
 EXPERIMENT NO: 10

ARITHMETIC, LOGICAL AND BIT MANIPULATION INSTRUCTIONS OF 8051

AIM: Write an ALP for Arithmetic, logical and bit manipulation operations in 8051

TOOLS:
i. UXASM
ii. TKUP
iii. TKUP86 KIT
iv. FRC CABLE

A) PROGRAM: FOR ARITHMETIC INSTRUCTIONS OF 8051

;Connect P1 to CNLED1

#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN MOV SP,#50H
MOV R0,#20H
MOV R1,#07H
MOV A,R0
ADD A,R1
MOV P1,A
LCALL DELAY
MOV A,R0
SUBB A,R1
MOV P1,A
LCALL DELAY
MOV A,R0
MOV 0F0H,R1
MUL AB
MOV P1,A
LCALL DELAY
MOV P1,0F0H
 LCALL DELAY
MOV A,R0
MOV 0F0H,R1
DIV AB
MOV P1,A
LCALL DELAY
MOV P1,0F0H
LCALL DELAY
LJMP MAIN
DELAY NOP

MOV R4,#020H
DLY3 MOV R3,#0FFH
DLY2 MOV R2,#0FFH
NOP
DLY1 NOP
NOP
NOP
NOP
DJNZ R2,DLY1
DJNZ R3,DLY2
DJNZ R4,DLY3
RET ;

B) PROGRAM: FOR LOGICAL INSTRUCTIONS OF 8051

i) ;Connect P1 to CNLED1

#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN MOV SP,#50H
MOV A,#35H
 ANL A,#0FH
MOV P1,A
ACALL DLY
MOV A,#04H
ORL A,#30H
MOV P1,A
ACALL DLY
MOV A,#54H
XRL A,#78H
MOV P1,A
ACALL DLY
MOV A,#55H
CPL A
MOV P1,A
ACALL DLY
DLY NOP
NOP
MOV R4,#020H
DLY3 MOV R3,#0FFH
DLY2 MOV R2,#0FFH
NOP
DLY1 NOP
NOP
NOP
NOP
DJNZ R2,DLY1
DJNZ R3,DLY2
DJNZ R4,DLY3
RET
ii) ;Connect P1 to CNLED1

#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
 ORG 0150H
MAIN: MOV SP,#060H
MOV A,#0A5H
MOV P1,A
LCALL SFTDL
RR A
MOV P1,A
LCALL SFTDL
SWAP A
MOV P1,A
LCALL SFTDL
RL A
MOV P1,A
LCALL SFTDL
SETB C
RLC A
MOV P1,A
LCALL SFTDL
RRC A
MOV P1,A
LCALL SFTDL
LJMP MAIN

SFTDL MOV R4,#50H

DL3 MOV R5,#0FFH
DL2 MOV R6,#0FFH
DL1 DJNZ R6,DL1
DJNZ R5,DL2
DJNZ R4,DL3
RET
C) PROGRAM: FOR BIT MANIPULATION INSTRUCTIONS OF 8051
; Connect P1 to CNLED1
#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN MOV SP,#50H
MOV P1,#00H
MOV C,00H
SETB C
MOV P1_7,C
LCALL SFTDL
CLR C
ANL C,00H
MOV P1_7,C
LCALL SFTDL
CPL C
MOV P1_3,C
LCALL SFTDL
ORL C,00H
MOV P1_7,C
LCALL SFTDL
LJMP MAIN
SFTDL MOV R4,#50H
DL3 MOV R5,#0FFH
DL2 MOV R6,#0FFH
DL1 DJNZ R6,DL1
DJNZ R5,DL2
DJNZ R4,DL3
RET

RESULT: INPUT :

OUTPUT:
 EXPERIMENT NO: 11
Program and verify Timer/Counter in 8051

AIM: Write an ALP to verify timer/counter operation in 8051

TOOLS: i) UXASM
ii)TKUP
iii)TKUP86 KIT
iv)FRC CABLE

PROGRAM:
;Connect P1 to CNLED1
#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN: MOV SP,#060H
MOV TMOD,#01H
BACK: MOV TL0,#075H
MOV TH0,#0B8H
MOV P1,#0AAH
LCALL SFTDL
ACALL DELAY
MOV TL0,#00H
MOV TH0,#00H
MOV P1,#055H
ACALL DELAY
LCALL SFTDL
SJMP BACK
ORG 300H
DELAY: SETB TCON4
AGAIN: JNB TCON5,AGAIN
CLR TCON4
CLR TCON5
 RET

SFTDL MOV R4,#10H

DL3 MOV R5,#0FFH
DL2 MOV R6,#0FFH
DL1 DJNZ R6,DL1
DJNZ R5,DL2
DJNZ R4,DL3
RET

RESULT: INPUT :

OUTPUT:
 EXPERIMENT NO: 12
Program and verify interrupt handling in 8051
AIM: Write an ALP to verify the interrupt handling in 8051

TOOLS: i) UXASM
ii)TKUP
iii)TKUP86 KIT
iv)FRC CABLE
PROGRAM:

#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN MOV SP,#50H
MOV IE,#85H
HERE MOV P1,#7EH
SJMP HERE
ORG 0003H ;INT0 ISR
MOV P1,#0AAH
LCALL DELAY
LCALL DELAY
LCALL DELAY
RETI
ORG 0013H ;INT1 ISR
MOV P1,#0A5H
LCALL DELAY
LCALL DELAY
RETI
DELAY NOP
MOV R4,#020H
DLY3 MOV R3,#0FFH
DLY2 MOV R2,#0FFH
DLY1 NOP
 NOP
DJNZ R2,DLY1
DJNZ R3,DLY2
DJNZ R4,DLY3
RET

RESULT: INPUT :

OUTPUT :
 EXPERIMENT NO: 13
UART operation in 8051

AIM: To observe the UART operation in 8051

TOOLS: i) UXASM
ii) TKUP
iii) TKUP86 KIT
iv) FRC CABLE

PROGRAM:

; CONNECT THE RS232 FROM PC TO TKUP51 KIT

;CONNECT THE Tx PIN OF 8051 TO Rx OF MAX232 AND VICE VERSA
;CONNECT PORT1 TO CNLED

#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN: MOV SP,#060H
MOV IE,#85H
MOV TMOD,#20H
MOV TH1,#0FAH
MOV SCON,#50H
SETB TCON6
RPT: MOV SBUF,#'Y'
HERE: JNB SCON1,HERE
CLR SCON1
MOV A,#'A'
MOV P1,A
SJMP RPT

RESULT: INPUT :

OUTPUT :
 EXPERIMENT NO: 14
Interfacing LCD to 8051

AIM: Write an ALP for interfacing LCD to 8051

TOOLS: i)UXASM
ii)TKUP
iii)TKUP86 KIT
iv)FRC CABLE

PROGRAM:

;CONNECT BH4 TO CNLCDC

;CONNECT BH6 TO CNLCDD

#INCLUDE "TKUP52.DEF"

ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN MOV SP,#060H
LCALL INIT8255
LOOP MOV DPTR,#CMDTBL
LCALL INIT_LCD
MOV DPTR,#STRTBL
LP1 MOV A,#0
MOVC A,@A+DPTR
CJNE A,#00,LP2
LCALL DELAY
LCALL DELAY
LCALL DELAY
LJMP MAIN
LP2 LCALL WR_DAT
INC DPTR
LCALL SDELAY
 LJMP LP1

;******* LCD init module

INIT_LCD
MOV A,#0
MOVC A,@A+DPTR
CJNE A,#00,IL2
RET
IL2 LCALL WR_CMD
INC DPTR
LJMP INIT_LCD

;******* LCD Write CMD module

WR_CMD PUSH DPH
PUSH DPL
MOV DPTR,#PB8255
LCALL WRPORT
LCALL SDELAY
MOV A,#04
MOV DPTR,#PA8255
LCALL WRPORT
LCALL SDELAY
MOV A, #00
MOV DPTR,#PA8255
LCALL WRPORT
LCALL SDELAY
POP DPL
POP DPH
RET

;******* LCD Write Data module

WR_DAT PUSH DPH
PUSH DPL
 MOV DPTR,#PB8255
LCALL WRPORT
LCALL SDELAY
MOV A,#05H
MOV DPTR,#PA8255
LCALL WRPORT
LCALL SDELAY
MOV A,#01H
MOV DPTR,#PA8255
LCALL WRPORT
LCALL SDELAY
POP DPL
POP DPH
RET

;******Write Port
WRPORT CLR P1_7
MOVX @DPTR,A
SETB P1_7
RET

;****** Read Port

RDPORT CLR P1_7
MOVX A,@DPTR
SETB P1_7
RET

;******* Delay module

SDELAY NOP
MOV R0,#0FFH
MOV R1,#01H
LJMP DLY1
NOP
DELAY NOP
MOV R0,#0FFH
MOV R1,#055H
NOP
DLY1 DJNZ R0,DLY1
MOV R0,#0FFH
DJNZ R1,DLY1
RET

;******* initialize 8255

INIT8255
MOV A,#080H
MOV DPTR,#CMD8255
LCALL WRPORT
RET

ORG 0500H
;******* initialize seven segment table
CMDTBL HEX 38,0E,02,01,00
STRTBL ASCII "HELLO ADM - TKUP"
ENDTBL HEX 00,00

RESULT: INPUT :

OUTPUT :
 EXPERIMENT NO: 15
Interfacing matrix or keyboard to 8051
AIM: Write an ALP for interfacing Matrix/keyboard to 8051

TOOLS: i) UXASM
ii) TKUP
iii) TKUP86 KIT
iv)FRC CABLE

PROGRAM:

;******* 8255_KBD

;******* INCLUDE DEFINATION FILES NOW

; 1. Connect 8255 PA0-7 to CNMUX of L1C peripheral board
; 2. Connect 8255 PC0-7 to CNKEY of L1C peripheral board
; 3. Connect 8255 PB0-7 to CNSEG of L1C peripheral board
; 4. Moitor one segment showing 0000->0001->....->000F->0000 (keypress)

#INCLUDE "TKUP52.DEF"
ORG 0000H
START: LJMP MAIN
ORG 0150H
MAIN MOV SP,#060H
LCALL INIT8255
MOV DPTR,#NUM1
LCALL CLRMEM
MOV DPTR,#NUM2
LCALL CLRMEM
MOV DPTR,#NUM3
LCALL CLRMEM
NOP
LOOP LCALL SCANKBD
MOV DPTR,#NUM3
MOVX A,@DPTR
 MOV DPTR,#SEGTBL
MOVC A,@A+DPTR
MOV DPTR,#PB8255
LCALL WRPORT
MOV A,#070H
MOV DPTR,#PA8255
LCALL WRPORT
LJMP LOOP

;******* MATRIX KBD SCAN module

;******* Output either E0,D0,B0,70 for Row 1,2,3,4
;******* Read PC port anded with 0x0F, expect 0F,0E,0D,0B,07

SCANKBD MOV A,#00H

SKLOOP MOV DPTR,#NUM1
MOVX @DPTR,A
MOV DPTR,#KBDTBL
MOVC A,@A+DPTR
CJNE A,#00,SKL1
RET
SKL1 MOV DPTR,#PC8255
LCALL WRPORT
MOV DPTR,#PC8255
LCALL RDPORT
ANL A,#0FH
CJNE A,#0FH,SKL2
MOV DPTR,#NUM1
MOVX A,@DPTR
INC A
LJMP SKLOOP
SKL2 LJMP GETKEY

;******* GETKEY module

GETKEY MOV DPTR,#NUM2
MOVX @DPTR,A
MOV DPTR,#RETTBL
MOVC A,@A+DPTR
MOV R0,A
MOV DPTR,#NUM1
MOVX A,@DPTR
MOV DPTR,#ROWTBL
MOVC A,@A+DPTR
ADD A,R0
MOV DPTR,#NUM3
MOVX @DPTR,A
RET

;****** Clear memory location

CLRMEM MOV A,#0
MOVX @DPTR,A
RET
WRPORT CLR P1_7
MOVX @DPTR,A
SETB P1_7
RET

;****** Read Port

RDPORT CLR P1_7
MOVX A,@DPTR
SETB P1_7
RET

;******* Delay module

SDELAY NOP
MOV R0,#0FFH
 MOV R1,#01H
LJMP DLY1
NOP
DELAY NOP
MOV R0,#0FFH ; load lsb of delay=0x34FF
MOV R1,#055H ; load msb
NOP
DLY1 DJNZ R0,DLY1
MOV R0,#0FFH ; decrement msb count
DJNZ R1,DLY1
RET ; end of delay

;******* initialize 8255

INIT8255
MOV A,#081H ; make all ports output
MOV DPTR,#CMD8255 ; write to command register
LCALL WRPORT
RET

ORG 0500H
;******* initialize seven segment table
SEGTBL HEX 3F,06,5B,4F,66,6D,7D,07,7F,6F,77,7C,39,5E,79,71,00
KBDTBL HEX E0,D0,B0,70,00
RETTBL HEX 00,00,00,00,00,00,00,03,00,00,00,02,00,01,00,00,00
ROWTBL HEX 00,04,08,0C,00

RESULT: INPUT

OUTPUT