RIT Lab Manual MCMP

RAJALAKSHMI INSTITUTE OF TECHNOLOGY
CHENNAI - 600124
DEPARTMENT OF ELECTRONICS AND COMMUNICATION

ENGINEERING
CS 6412/IT6411- MICROPROCESSOR AND

MICROCONTROLLER LABORATORY
LAB MANUAL
Prepared by:
Mr. U.Maheswaran AP/ECE
Mr. K.A.Karthigeyan AP/ECE
Mr. G.Kalyan Kumar AP/ECE
Ms. S.Priyadharshini AP/ECE

INDEX
EXPERIMENTS PAGE NO. SIGANTURE

S.NO EXP.NO DATE
EXPERIMENTS PAGE NO. SIGANTURE
S.NO EXP.NO DATE
SYLLABUS
CS6412/IT4211 MICROPROCESSOR AND MICROCONTROLLER

LABORATORY
LT P C
0 0 3 2
OBJECTIVES:
The student should be made to:

 Introduce ALP concepts and features
 Write ALP for arithmetic and logical operations in 8086 and 8051
 Differentiate Serial and Parallel Interface
 Interface different I/Os with Microprocessors
 Be familiar with MASM
LIST OF EXPERIMENTS:
8086 Programs using kits and MASM
1. Basic arithmetic and Logical operations

2. Move a data block without overlap
3. Code conversion, decimal arithmetic and Matrix operations.
4. Floating point operations, string manipulations, sorting and searching
5. Password checking, Print RAM size and system date
6. Counters and Time Delay
Peripherals and Interfacing Experiments
7. Traffic light control

8. Stepper motor control
9. Digital clock
10. Key board and Display
11. Printer status
12. Serial interface and Parallel interface
13. A/D and D/A interface and Waveform Generation
8051 Experiments using kits and MASM
14. Basic arithmetic and Logical operations

15. Square and Cube program, Find 2‟s complement of a number
16. Unpacked BCD to ASCII
TOTAL: 45 PERIODS
CYCLE 1:
8086 MICROPROCESSOR
1. 16 BIT ADDITION AND SUBTRACTION.

2. 16 BIT MULTIPLICATION AND DIVISION
3. ASCENDING AND DESCENDING ORDER.
4. LARGEST AND SMALLEST NUMBER.
5. COPY OPERATION.
6. STRING MANIPULATION.
7. CODE CONVERSION.
8. LOGICAL OPERATIONS
9. MOVE A DATA BLOCK WITHOUT OVERLAP
10. 16 BIT DECIMAL OPERATIONS
11. PASSWORD CHECKING, PRINT RAM SIZE AND SYSTEM DATE
12. COUNTERS AND TIME DELAY
13. FIND AND REPLACE OF DATA.
14. ADDITION OF 3X3 MATRIX
CYCLE 2:
8051 MICRO CONTROLLER
1. 8-BIT AND 16-BIT ADDITION.

2. 8-BIT AND 16-BIT SUBTRACTION.
3. 8-BIT MULTIPLICATION.
4. 8-BIT DIVISION.
5. FIND A TWO‟S COMPLEMENT OF A NUMBER.
6. FIND A SQUARE OF A NUMBER.
7. FIND A CUBE OF A NUMBER.
CYCLE 3:
INTERFACING (8086&8051)
1. STEPPER MOTOR.
2. PARALLEL COMMUNICATION(8255)
3. DIGITAL TO ANALOG CONVERTOR (DAC).
4. COUNTER DESIGN.
5. KEYBOARD AND DISPLAY.
6. TRAFFIC LIGHT CONTROLLER.
7. DIGITAL CLOCK
8. PRINTER STATUS
9. SERIAL AND PARALLEL INTERFACE
EXECUTION PROCEDURE FOR 8086 (for registers)
i) Writing a alp program into processor:
Switch On Power Supply
Press A 2times
SG 0 press enter
DA starting address
Press enter
N
st
Then display shows @ here you have to write 1 mnemonic
Press enter
N (display displays address opcode mnemonic)
N
Then display shows @ here you have to write 2nd mnemonic
Press enter
N
N
-
-
Then display shows @ up to last mnemonic
Press enter
N
N
! Press
enter EX
press
enter
ii) Execution of program (for registers):
G enter starting address
Press enter
iii) Verify the CONCLUSION (for
registers): press R Press E.
EXECUTION PROCEDURE FOR 8086 (for memory locations)
i) Writing a alp program into processor:
Switch On Power Supply
Press A
A
SG 0
Press enter
DA starting address
Press enter
N
st
Then display shows @ here you have to write 1 mnemonic
Press enter
N(display displays address opcode mnemonic)
N
Then display shows @ here you have to write 2nd mnemonic
Press enter
N
N
-
-
-
-
Then display shows @ up to last mnemonic
Press enter
N
N
! Press
enter EX
press
enter E
(exam
byte)
st
Here you have to type SI address, give 1 data, 2nd data, -----,
nth data, Press enter
ii) Execution of program (for memory locations):
G enter starting address
Press enter
iii) Verify the CONCLUSION (for memory locations):
E
Then give DI address press, then display
st
shows the CONCLUSION of 1 8 bit data
nd
For 2 8 bit data again press, -------, nth data
Introduction to MASM /TASM
MASM: (Microsoft assembler)

To Create Source File: An editor is a program which allows you to create a file containing
the assembly language statements for your program. This file is called a source file.
Command to create a source file
C:\MASM\BIN> Edit filename. asm

The next step is to process the source file with an assembler. When you run the assembler,
it reads the source file of your program. On the first pass through the source program, the
assembler determines the displacement of named data items, the offset labels, etc. and puts
this information in a symbol table. On the second pass through the source program the
assembler produces the binary code for each instruction and inserts the offsets, etc. that it
calculated during first pass.
C:\MASM\BIN > Masm filename. asm X, Z

With this command assembler generates three files.
1. The first file (X) called the object file, is given the extension .OBJ
The object file contains the binary codes for the instructions and information about the
addresses of the instructions.
2. The third file (Z) generated by this assembler is called the cross-reference file and is
given the extension .CRF. The cross-reference file lists all labels and pertinent information
required for cross – referencing.
NOTE : The Assembler only finds syntax errors : It will not tell you whether program does
what it is supposed to do. To determine whether your program works, you have to run the
program and test it.
Next step is to process the object file with linker.
C:\MASM\BIN>LINK filename. obj
Run File [Filename1.exe] : “filename1.exe”
List file [nul.map]: NUL
Libraries [.lib]: library name
Definitions File [nul.def]:
Creation of Library: Refer Modular Programming Section
A Linker is a program used to join several object files into one layer object file.
NOTE: On IBM PC – type Computers, You must run the LINK program on your .OBJ file even
if it contains only one assembly module.
The linker produces a link file with the .EXE extension (an execution file)
Next Run C:\MASM\BIN> filename
8086
MICROPROCESSOR
16-BITADDITION & SUBTRACTION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform16-bit addition
and subtraction using 8086 microprocessor.
COMPONENTS REQUIRED:
S.NO COMPONENTS SPECIFICATION QUANTITY

1. Microprocessor kit 8086 kit 1
2. Power Supply +5 V dc 1
3. Key board - 1
4. MASM Software - 1
ALGORITHM:
STEP 1: Start the program.
STEP 2: Get the input data‟s and stored it in registers.
STEP 3: Addition and subtraction operation is performed using sequence of

instruction.
STEP 4: Store the CONCLUSIONs in separate memory locations
STEP 5: Stop the program

FLOW CHART:
I6-BIT ADDITION
PROGRAM:
MNEMONICS HEX
ADDRESS LABEL COMMENTS
OPCODE OPERAND CODE
1000 MOV BX,2000 BB
Initialize the memory
1001 00
pointer
1002 20
1003 MOV AX,[BX] 8B Move the first data from
1004 07 memory to AX
1005 INC BX 43 Increment memory
1007 MOV CX,[BX] 8B Move the second data
1008 0F from memory to CX
1009 MOV DL,00 B2
Clear DL register
100A 00
100B ADD AX,CX 01
Add AX with CX
100C C8
100D JNB 1011(XXX) 73
Jump if no carry occurs
100E 02
10OF INC DL FE
Increment carry
1010 C2
1011 XXX INC BX 43 Increment memory
1013 MOV [BX],AX 89 Store sum in memory
1014 07 location
1017 MOV [BX],DL 88 Store carry in memory
1018 17 location
1019 HLT F4 Stop the program
16 BIT ADDITION:
By using MASM:
Assume cs: code
Code segment
Start: MOV AX, 4343
MOV BX, 1111
ADD AX, BX
INT 3
Code ends
End start
SAMPLE INPUT AND OUTPUT

16-BIT ADDITION
WITHOUT CARRY
INPUT OUTPUT
ADDRESS DATA ADDRESS DATA
2000 2004
2001 2005
2002 2006
2003
WITH CARRY
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003
FLOW CHART:
I6-BIT SUBTRACTION
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV BX,2000 BB
1001 00
pointer
1002 20
1007 MOV DX,[BX] 8B Move the second data
1008 0F from memory to DX
1009 MOV CL,00 BL
Clear CL register
100A 00
100B SUB AX,DX 29
Subtract AX with DX
100C D0
100D JNB 1011(XXX) 73
Jump if no borrow occurs
100E 02
10OF INC CL FE
Increment carry
1010 C1
1011 XXX INC BX 43 Increment memory
1013 MOV [BX],AX 89 Store difference in
1014 07 memory
1017 MOV [BX],CL 89
Store borrow in memory
1018 0F
16-BIT SUBTRACTION
By using MASM:
Assume cs: code
Code segment
Start: MOV AX, 4343
MOV BX, 1111
SUB AX, BX
INT 3
Code ends
End start

16-BIT SUBTRACTION
WITHOUT BORROW
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003
WITH BORROW
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003
VIVA QUESTIONS
iii) Explain the logic behind the programs for arithmetic operations.
iv) What is the max size of memory that can be connected with 8086 microprocessor?
v) What are the general purposes registers available in 8086?
vi) What are the functional units in 8086 and state the purpose of each unit.
vii) Mention the index registers of 8086 and their use.
viii) What is the use of IP & base pointer register?
ix) What are the 8086 instructions used for BCD arithmetic?
CONCLUSION:
16-BIT MULTIPLICATION & DIVISION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform16-bit
multiplication and division using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 3: Multiplication and division operation is performed using sequence of

instruction.
STEP 4: Store the CONCLUSIONs in separate memory locations.

FLOW CHART:
16-BIT MULTIPLICATION
PROGARM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV BX,2000 BB
1001 00
pointer
1002 20
1003 MOV AX,[BX] 8B Move the first data
1004 07 from memory to AX
1009 MOV DX,00 BL
Clear DX register
100A 00
100B MUL CX 29
Multiply AX with CX
100C D0
100D INC BX 73 Increment memory
100E INC BX 02 Increment memory
10OF MOV [BX],AX FE Store product in
1010 C1 memory
1013 MOV [BX],DX 89
Store carry in memory
1014 07
1015 HLT 43 Stop the program
By using MASM:
Assume cs: code
Code segment
Start: MOV AX, 4343
MOV BX, 1111
MUL BX
INT 3
Code ends
End start

WITHOUT CARRY
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003 2007
WITH CARRY
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003 2007
FLOW CHART:
16-BIT DIVISION
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV BX,2000 BB
1001 00
pointer
1002 20
1009 MOV DX,00 BL
Clear DX register
100A 00
100B DIV CX 29
Divide AX with CX
100C D0
100D INC BX 73 Increment memory
100E INC BX 02 Increment memory
10OF MOV [BX],AX FE
Store quotient in memory
1010 C1
1013 MOV [BX],DX 89 Store remainder in
1014 07 memory
1015 HLT 43 Stop the program
16-BIT DIVISION
By using MASM:
Assume cs: code
Code segment
Start: MOV AX,4343
MOV BX,1111
MUL BX
INT 3
Code ends
End start

16-BIT DIVISION
WITHOUT REMAINDER
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003 2007
WITH REMAINDER
INPUT OUTPUT
2000 2004
2001 2005
2002 2006
2003 2007
CONCLUSION:
ASCENDING AND DESCENDING ORDER
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform ascending and
descending order using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 2: Load the count value in CX register.
STEP 3: Get the first two numbers.
STEP 4: Compare the numbers and exchange if necessary so that the two numbers
are in ascending order/descending order.
STEP 5: Decrement count value.
STEP 6: Get the third number from the array and repeat step no:4 until CX is 0.

FLOW CHART: ASCENDING:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV DX,0005 BA
Move count value into DX
1001 05
register
1002 00
1003 DEC DX 4A Decrement count value
1004 ZZZ MOV CX,DX 89
Move DX to CX
1005 D1
1006 MOV SI,3000 BE
1007 00 Initialize the memory
1008 30
1009 YYY MOV AX,[SI] 8B Move first data into
100A 04 accumulator
100B CMP AX,[SI+02] 3B Compare values of
100C 44 Accumulator and next value
100D 02 in the memory
100E JB 1015(XXX) 72
Jump if borrow occurs
10OF 05
1010 XCHG [SI+02],AX 87
Exchange the values of AX
1011 44
and memory
1012 02
1013 XCHG {SI],AX 87 Exchange the values of AX
1014 04 and memory
1015 XXX ADD SI,0002 83
Increment the memory
1016 C6
location address
1017 02
1018 LOOP 1009(YYY) E2 Unconditional jump to
1019 EF 1009
101A DEC DX 4A Decrement the count
101B JNE 1004(ZZZ) 75
Jump if not zero(or) equal
101C E7
101D HLT F4 Stop the program
ASCENDING ORDER
By using MASM:
ASSUME CS: CODE
CODE SEGMENT
START: MOV AX, 0000H
MOV CH, 0004H
DEC CH
UP1 : MOV CL, CH
MOV SI, 2000
UP: MOV AL, [SI]
INC SI
CMP AL, [SI]
JC DOWN
XCHG AL, [SI]
DEC SI
MOV [SI], AL
INC SI
DOWN: DEC CL
JNZ UP
DEC CH
JNZ UP1
INT 3
CODE ENDS
END START
ASCENDING ORDER
INPUT OUTPUT
3000 3000
3001 3001
3002 3002
3003 3003
3004 3004
3005 3005
3006 3006
3007 3007
3008 3008
3009 3009
FLOW CHART: DESCENDING:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV DX,0005 BA
Move count value into DX
1001 05
register
1002 00
1003 DEC DX 4A Decrement count value
1004 ZZZ MOV CX,DX 89
Move DX to CX
1005 D1
1006 MOV SI,3000 BE
1007 00 Initialize the memory
1008 30
1009 YYY MOV AX,[SI] 8B Move first data into
100A 04 accumulator
100B CMP AX,[SI+02] 3B Compare values of
100C 44 Accumulator and next value in
100D 02 the memory
100E JNB 1015(XXX) 73
Jump if not borrow occurs
10OF 05
1010 XCHG [SI+02],AX 87
Exchange the values of AX and
1011 44
memory
1012 02
1013 XCHG {SI],AX 87 Exchange the values of AX and
1014 04 memory
1015 XXX ADD SI,0002 83
Increment the memory location
1016 C6
address
1017 02
1018 LOOP 1009(YYY) E2
Unconditional jump to 1009
1019 EF
101A DEC DX 4A Decrement the count
101B JNE 1004(ZZZ) 75
Jump if not zero(or) equal
101C E7
101D HLT F4 Stop the program
DESCENDING ORDER
By using MASM:
ASSUME CS: CODE
CODE SEGMENT
START: MOV AX, 0000H
MOV CH, 0004H
DEC CH
UP1 : MOV CL, CH
MOV SI, 2000
UP: MOV AL, [SI]
INC SI
CMP AL, [SI]
JNC DOWN
XCHG AL, [SI]
DEC SI
MOV [SI], AL
INC SI
DOWN: DEC CL
JNZ UP
DEC CH
JNZ UP1
INT 3
CODE ENDS
END START
DESCENDING ORDER
INPUT OUTPUT
3000 3000
3001 3001
3002 3002
3003 3003
3004 3004
3005 3005
3006 3006
3007 3007
3008 3008
3009 3009
CONCLUSION:
LARGEST AND SMALLEST NUMBER
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform largest and
smallest number among N numbers using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 2: Load the count value in CX register.
STEP 3: Get the first two numbers.
STEP 4: Compare the numbers and exchange if the number is small/large.
STEP 5: Decrement count value.
STEP 6: Get the third number from the array and repeat step no:4 until CX is 0.
STEP 7: Stop the program.

FLOW CHART: LARGEST
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV AX,6000 B8,00,60 Move data segment value
1003 MOV DS,AX 8E,D8 Move AX to DS
1005 CLD FC Clear directional flag
1006 MOV CX,0005 B9
1007 05 Give count value to CX
1008 00
1009 MOV SI,4000 BE
100A 00 Initialize the input address
100B 40
100C MOV DI,5000 BF
100D 00 Initialize the output address
100E 50
100F MOV AX,[SI] 8B
Get the first data
1010 04
1011 YYY CMP AX,[SI+02] 3B
1012 44 Compare the two data
1013 02
1014 JNB 1019(XXX) 73
Jump if no borrow
1015 03
1016 XCHG [SI+02],AX 87
1017 44 Exchange the values
1018 02
1019 XXX INC SI 46 Increment memory
101A INC SI 46 Increment memory
101B LOOP 1011(YYY) E2
101C F4
101D MOV [DI],AX 89,05 Store the CONCLUSION
101F HLT F4 Stop the program
LARGEST NUMBER
INPUT OUTPUT
4000 5000
4001 5001
4002
4003
4004
4005
4006
4007
4008
4009
FLOW CHART: SMALLEST
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1006 MOV CX,0005 B9
1007 05 Give count value to CX
1008 00
1009 MOV SI,4000 BE
100A 00 Initialize the input address
100B 40
100C MOV DI,5000 BF
100D 00 Initialize the output address
100E 50
100F MOV AX,[SI] 8B
Get the first data
1010 04
1011 YYY CMP AX,[SI+02] 3B
1012 44 Compare the two data‟s
1013 02
1014 JB 1019(XXX) 72 Jump if no borrow go to
1015 03 1019
1016 XCHG [SI+02],AX 87
1017 44 Exchange the values
1018 02
1019 XXX INC SI 46 Increment memory
101A INC SI 46 Increment memory
101B LOOP 1011(YYY) E2
101C F4
101D MOV [DI],AX 89,05 Store the CONCLUSION
101F HLT F4 Stop the program
SMALLEST NUMBER
INPUT OUTPUT
4000 5000
4001 5001
4002
4003
4004
4005
4006
4007
4008
4009
CONCLUSION:
COPY OPERATION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform copy operation
using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 2: Initialize the data segment (DS).
STEP 3: Load the count value in DX register.
STEP 4: Initialize the start of source string in the SI.
STEP 5: Initialize the start of destination string in the DI.
STEP 6: Move the byte from SI to DI, till DX=0.

FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV AX,5000 B8
1001 00 Get the segment values
1002 50
1003 MOV DS,AX 8E Move AX values into data
1004 D8 segment
1005 MOV DX,0005 B9
Move count value in to DX
1006 05
register
1007 00
1008 MOV SI,2000 BE
Move source address into
1009 00
SI register
100A 20
100B MOV DI,3000 BE
Move destination address
100C 00
into DI register
100D 30
100E KKK MOV BL,[SI] 8A
Move SI to BL register
10OF 1C
1010 MOV [DI],BL 88
Move BL to DI
1011 1D
1012 INC SI 46 Increment SI
1013 INC DI 47 Increment DI
1014 DEC DX 4A Decrease the count value
1015 LOOP 100E(KKK) E2 Unconditional jump to
1016 F7 100E
INPUT OUTPUT
2000 3000
2001 3001
2002 3002
2003 3003
2004 3004
CONCLUSION:
STRING MANIPULATION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for string manipulation
using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 2: Set the SI to point the source array and DI at destination location.
STEP 3: Move the string size to CX register
STEP 4: Direction flag is cleared so that SI & DI will auto increment after each
loop.
STEP 5: Move the bytes of string using MOVSB instruction.

FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV SI,1100
Move the source address to
1001
SI
1002
1003 MOV DI,1200
Move the destination
1004
address to DI register
1005
1006 MOV CX,00FF
Set the length of array
1007
element
1008
1009 CLD Clear the direction flag
100A XXX MOVSB Move the string byte
100B LOOP 100A(XXX)
Unconditional loop
100C
100D HLT Stop the program
INPUT OUTPUT
1100 1200
TO TO
11FF 12FF
CONCLUSION:
CONVERSION OF BCD TO BINARY AND VICEVERSA
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to convert BCD to BINARY
and vice versa using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
BCD TO BINARY
STEP 2: Get the input data.
STEP 3: performing AND operation between input and F0.
STEP 4: Rotate right AL with CL.
STEP 5: performing multiplication operation between DH and 0A.
STEP 6: Store the CONCLUSION in memory.
BINARY TO BCD
STEP 3: compare and then subtract the value 100 from the input.
STEP 4: compare and then subtract the value 10 from the input.
STEP 5: performing rotate left operation with AL by 04.
STEP 6: Store the CONCLUSION in memory.
FLOW CHART:
PROGRAM:
BCD TO BINARY
MNEMONICS HEX
OPCODE OPERAND CODE
3000 MOV BX,1100 BB
3001 00 Initialize the memory pointer
3002 11
3003 MOV AL,[BX] 8A Move the data from memory
3004 07 to AL register
3005 MOV DL,AL 88
Move the data from AL to DL
3006 C2
3007 AND DL,0F 80 Logical AND between DL
3008 0F and data 0F
3009 AND AL,F0 24 Logical AND between AL
300A F0 and data F0
300B MOV CL,04 B1
Move data 04 to CL
300C 04
300D ROR AL,CL D2
Rotate right AL with CL
300E C8
300F MOV DH,0A B6
Move data 0A to DH
3010 0A
3011 MUL DH,0A F6
Multiply DH with data 0A
3012 E6
3013 ADD AL,DL 00 Add the content of AL with
3014 D0 DL
3015 MOV [BX+1],AL 88
Store the CONCLUSION in
3016 47
memory location
3017 01

BCD TO BINARY
INPUT OUTPUT
1100 1101
BINARY TO BCD
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV CL,00 B1
Move the data 00 to CL
1001 00
1002 MOV BL,CL 88 Move the content of CL to
1003 CB BL
1004 MOV SI,2000 BE
1005 00
pointer
1006 20
1007 MOV AL,[SI] 8A Get the input data from
1008 04 memory location
1009 RRR CMP AL,64 3C Compare AL with
100A 64 immediate data 64
100B JB 1013(KKK) 72
Jump if borrow
100C 06
100D SUB AL,64 2C Subtract AL with
100E 64 immediate data 64
100F INC AL FE
Increment AL
1010 C1
1011 JMP 1009(RRR) EB
Jump the program to 1009
1012 F6
1013 KKK CMP AL,0A 3C Compare AL with
1014 0A immediate data 0A
1015 JB 101D(SSS) 72
Jump if borrow
1016 06
1017 SUB AL,0A 2C Subtract AL with
1018 0A immediate data 0A
1019 INC BL FE
Increment BL
101A C3
MNEMONICS HEX
OPCODE OPERAND CODE
101B JMP 1013(KKK) EB
Jump the program to 1013
101C F6
101D SSS MOV DL,AL 88
Move data from AL to DL
101E C2
101F MOV AL,BL 88
Move data from BL to AL
1020 D8
1021 ROL AL,01 D0
Rotate left AL by 01
1022 C0
1023 ROL AL,01 D0
1024 C0
1025 ROL AL,01 D0
1026 C0
1027 ROL AL,01 D0
1028 C0
1029 ADD AL,DL 00
Add AL with DL
102A D0
102B MOV [SI+01],AL 88 Move the lower byte
102C 44 CONCLUSION in memory
102D 01 location
102E MOV [SI+02],CL 88 Move the higher byte
102F 44 CONCLUSION in memory
1030 02 location
BINARY TO BCD
INPUT OUTPUT
2001
2000
2002
CONCLUSION:
CONVERSION OF BINARY TO ASCII AND VICEVERSA
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to convert BINARY TO
ASCII and vice versa using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
BINARYTO ASCII
STEP 3: If the input data is greater than the data 0A add 37 from input otherwise
add 30 from the input.
STEP 4: Store the CONCLUSION in separate memory.
ASCII TO BINARY
STEP 3: If the input data is greater than the data 0Asubtract 37 from input
otherwise subtract 30 from the input.
STEP 4: Store the CONCLUSION in separate memory.

FLOWCHART: BINARY TO ASCII
PROGRAM: BINARY TO ASCII
MNEMONICS HEX
OPCODE OPERAND CODE
8400 MOV BX,2000 BB
8401 00
location
8402 20
8403 MOV AL,[BX] 8A Move the data from
8404 07 memory to AL register
8405 CMP AL,OA 3C
Compare AL with data 0A
8406 0A
8407 JB 840B(XXX) 72
8408 02
8409 ADD AL,07 04
Add AL with data 07
840A 07
840B XXX ADD AL,30 04
Add AL with data 30
840C 30
840D INC BX 43 Increment BX
840E MOV [BX],AL 88
Store the CONCLUSION
840F 07
BINARYTO ASCII
INPUT OUTPUT
2000 2001
FLOWCHART: ASCII TO BINARY
PROGRAM: ASCII TO BINARY
MNEMONICS HEX
OPCODE OPERAND CODE
1000 MOV BX,2000 B8
1001 00
location
1002 20
1003 MOV AL,[BX] 8A Move the data from
1004 07 memory to AL register
1005 CMP AL,OA 3C
Compare AL with data oA
1006 0A
1007 JB 100B(XXX) 72
1008 02
1009 SUB AL,07 2C
Subtract AL with data 07
100A 07
100B XXX SUB AL,30 2C
Subtract AL with data 30
100C 30
100D INC BX 43 Increment BX
100E MOV [BX],AL 88
Store the CONCLUSION
100F 07
ASCII TO BINARY
INPUT OUTPUT
2000 2001
CONCLUSION:
CONVERSION OF BINARY TO GRAY
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to convert BINARY TO
GRAY.

3. Key board - 1
ALGORITHM:
STEP 3: Rotate the input content to right and then store in another register.
STEP 4: Perform X-OR with shifted input and original input.
STEP 5: Store the CONCLUSION.

FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
6000 MOV SI,8200 BE
6001 00
pointer
6002 82
6003 MOV BL,[SI] 8A Move the input data from
6004 1C memory to BL register
6005 MOV AL,BL 88 Move the data from BL to
6006 D8 AL
6007 SHR AL,01 D0
Shift right AL by 01
6008 C8
6009 XOR AL,BL 30 Perform EX-OR operation
600A D8 between Al and BL
600B INC SI 46 Increment SI
600C MOV [SI],AL 88 Store the CONCLUSION in
600D 04 memory location
600E HLT F4 Stop the program
INPUT OUTPUT
8200 8201
CONCLUSION:
FIND AND REPLACE OF DATA
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to find the given element in
set of element and replace it with new value.

3. Key board - 1
ALGORITHM:
STEP 2: Read the count value.
STEP 3: Compare elements to be found with set of elements one by one until if
count becomes zero.
STEP 4: If found replace element it with new value.

FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
1006 MOV SI,3000 BE
Move the memory address
1007 00
to SI
1008 30
1009 MOV CX,[SI] 8B
Count value move to CX
100A 0C
100B INC SI 46 Increment memory location
100C MOV BL,[SI] 8A Move the data from [SI] to
100D 1C BL
100E MOV DI,2000 BF
Get the input memory
100F 00
address to DI
1010 20
1011 SSS CMP [DI],BL 38
Compare the data
1012 1D
1013 JE 101C(KKK) 74
Jump if equal go to 101C
1014 07
1016 LOOP 1011(SSS) E2
Jump the address 1011
1017 F9
1018 MOV [DI],0005 C6,05,00 Move count value to DI
101B HLT F4 Stop the program
101C KKK INC SI 46 Increment SI
101D MOV BL,[SI] 8A Move the data from [SI] to
101E 1C BL register
Move the data from BL to
101F MOV [DI],BL 88,1D
[DI]
1021 RET C3 Return the main program
INPUT OUTPUT
2000
2000
2001
2002 2001
2003
2002
2004
2003
3000
3001 2004
3002
CONCLUSION:
ADDITION OF TWO 3X3 MATRIX
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to add two 3x3 matrix using
8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 2: Get the input matrices.
STEP 3: Add the given two matrices.
STEP 4: Store the CONCLUSION in another memory locations.

FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
3000 MOV BX,1300 BB
Move the address of matrix
3001 00
one to BX register
3002 13
3003 MOV BP,1400 BD Move the address of
3004 00 second matrix to BP
3005 14 register
3006 MOV SI,0000 BE
Move the data 0000 to SI
3007 00
register
3008 00
3009 MOV DI,1501 BF
Move the output address to
300A 01
DI register
300B 15
300C MOV CL,09 B1 Move count value to CL
300D 09 register
300E XXX MOV AL,[BX+SI] 8A Move the content of [
300F 00 BX+SI] to AL register
3010 ADD AL,[BP+SI] 02 Add the content of [BP+SI]
3011 02 with AL register
3012 MOV [DI],AL 88 Store the CONCLUSION
3013 05 in memory
3014 INC SI 46 Increment SI
3016 LOOP 300E(XXX) E2
Go to loop 300E
3017 F6
INPUT
MATRIX A MATRIX B
1300
1400
1303
1403
1306
1406
OUTPUT
MATRIX C
ADDRESS DATA
1501
1504
1507
CONCLUSION:
PROGRAMS FOR LOGICAL OPERATIONS USING 8086
EX NO:
DATE:
OBJECTVE:
To write and execute an assembly language program for Logical AND, OR , NOT,
XOR, NAND using 8086
8086 Trainer kit, Key board, power supply ,MASM Software
PROGRAM:
a) LOGICAL AND:
ADDRESS LABEL MNEMONICS
START MOV SI,1200

MOV AL, [SI]
MOV BL, [SI+01]
AND AL, BL
MOV [SI+02],AL
END HLT
INPUT OUTPUT

By using MASM:
Logical AND:
CODE SEGMENT
ASSUME CS: CODE
START: MOV AL, 85H
MOV BL, 99H
AND AL, BL
INT 3H
CODE ENDS
END START
INPUT OUTPUT
b) LOGICAL OR:
1000 START MOV SI,1200
MOV AL, [SI]

MOV BL, [SI+01]
OR AL, BL
MOV [SI+02],AL
END HLT
INPUT OUTPUT
b) By using MASM:
LOGICAL OR:
CODE SEGMENT
ASSUMECS: CODE
START: MOV AL, 85H
MOV BL, 99H
OR AL, BL
INT 3H
CODE ENDS
END START
INPUT OUTPUT

C) LOGICAL XOR:
1000 START MOV SI,1200

MOV AL, [SI]
MOV BL, [SI+01]
XOR AL, BL
MOV [SI+02],AL
END HLT
By using MASM:
LOGICAL XOR:
CODE SEGMENT
ASSUMECS: CODE
START: MOV AL, 85H
MOV BL, 99H
XOR AL, BL
INT 3H
CODE ENDS
END START
d) LOGICAL NAND:
START
MOV SI,1200
MOV AL, [SI]
MOV BL, [SI+01]
1000
AND AL, BL
NOT AL
MOV [SI+02],AL
END HLT
By using MASM:
LOGICAL NAND:
CODE SEGMENT
ASSUMECS: CODE
START: MOV AL,85H
MOV BL,99H
AND AL,BL
NOT AL
INT 3H
CODE ENDS
END START
d) NOT OPERATION:
CODE SEGMENT
ASSUME CS:CODE
START: MOV AL, 85H
NOT AL
INT 3H
CODE ENDS
END START
VIVA QUESTIONS
i) Define logic gates.
ii) How do you differentiate different types of logic gates?
iii) What are the universal gates? Why it is called so?
iv) What are the logical instructions in 8086?
v) Draw the truth table for various logic gates?
CONCLUSION
PROGRAMS FOR MOVE A DATA BLOCK WITHOUT OVERLAP USING 8086
Exp. No:
DATE:
OBJECTVE:
To write and execute an assembly language program to move a block of data without
overlap using 8086
8086 Trainer kit, Key board, power supply, MASM Software
ALGORITHM
 Initialize counter
 Initialize source block pointer
 Initialize destination block pointer
 Get the byte from source block
 Store the byte in the destination block
 Increment source, destination pointers and decrement counter
 Repeat steps 4,5 and 6 unit counter equal to zero
 Stop
PROGRAM
1000 START MOV SI,1100H

MOV DI,1200H
MOV CX,COUNT
REP MOVSW
END HLT
PROGRAM USING MASM
TITLE Non Overlapped Block Transfer

SMAL
.MODEL L
.STACK 100
.DATA
ARRAY DB 12H,23H,26H,63H, 25H, 86H 2FH,33H ,10H, 35H
NEW_ARR DB 10 DUP (?)
.CODE
START: MOV AX,@data ; initialise
MOV DS, AX ; data segment and
MOV ES,AX ; extra segment
MOV CX,10 ;Initialise counter
LEA SI,ARRAY ;initialise source pointer
LEA DI,NEW_ARR ;initialise destination pointer
CLD ;clear direction flag to auto increment SI and DI
MOV AL,[SI] ;get the number
MOV [DI],AL ;and save number in new array
REP MOVSB ;decrement CX and MOVSB until CX will be 0
MOV AL,4CH ;
INT 21H ;
END
INPUT OUTPUT
VIVA QUESTIONS
1. What are the various segment registers in 8086?

2. Explain about “LEA”?
3. Explain about .MODEL SMALL?
4. What are the functional units available in 8086 architecture?
CONCLUSION:
PROGRAMS FOR 16 BIT DECIMAL OPERATIONS USING 8086
Exp. No
DATE:
a) ADDITION
OBJECTVE:
To write and execute an assembly language program for performing the decimal operation of
16 bit numbers with carry.
8086 Trainer kit, Key board, power supply
ALGORITHM:
Step1: Start
Step 2: Move the first data into the accumulator.
Step3: Move the second data in some register pair
Step 4: Initialize carry register.
Step 5: Add the contents of the two registers
Step 6: If carry is generated increment the carry register.
Step 7: Store the contents of accumulator and carry register in memory.
Step 8: Terminate the process

PROGRAM:
ADDRESS LABEL MNEMONICS COMMENTS
1000 START MOV SI, 1550H

MOV AX, [SI]
MOV CX, 0000H
ADD AX, [SI+02]
DAA
JNC L1
INC CX
L1 MOV SI, 1700H
MOV [SI], AX
MOV [SI+02], CX
END HLT
INPUT
OUTPUT
ADDRESS DATA
ADDRESS DATA
By using MASM:
VIVA QUESTIONS
iv) Explain about DAA instruction
v) What are Machine Control Instructions?
vi) What is an Opcode?
vii) What is an Operand?
CONCLUSION:
PASSWORD CHECKING, PRINT RAM SIZE AND SYSTEM DATE
EXPT NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for performing the
Arithmetic operation of two byte numbers
APPARATUS REQUIRED:
SL.N ITEM SPECIFICATION QUANTITY

O
PROGRAM:
;PASSWORD IS MASM1234
DATA SEGMENT
PASSWORD DB 'MASM1234'
LEN EQU ($-PASSWORD)
MSG1 DB 10,13,'ENTER YOUR PASSWORD: $'
MSG2 DB 10,13,'WELCOME TO ELECTRONICS WORLD!!$'
MSG3 DB 10,13,'INCORRECT PASSWORD!$'
NEW DB 10,13,'$'
INST DB 10 DUP(0)
DATA ENDS CODE
SEGMENT
ASSUME
CS:CODE,DS:DATA START:
MOV AX,DATA
MOV DS,AX
LEA DX,MSG1
MOV AH,09H
INT 21H
MOV SI,00
UP1:
MOV AH,08H
INT 21H CMP
AL,0DH JE
DOWN
MOV [INST+SI],AL
MOV DL,'*'
MOV AH,02H
INT 21H
INC SI
JMP UP1
DOWN:
MOV BX,00
MOV CX,LEN
CHECK:
MOV AL,[INST+BX]
MOV DL,[PASSWORD+BX]
CMP AL,DL
JNE FAIL
INC BX
LOOP CHECK
LEA DX,MSG2
MOV AH,09H
INT 21H
JMP FINISH
FAIL:
LEA DX,MSG3
MOV AH,009H
INT 21H
FINISH:
INT 3
CODE ENDS
END START
END
;Today.asm Display month/day/year.

; Feb 1st, 2012
;CIS 206 Ken Howard
.MODEL small
.STACK 100h
.DATA
mess1 DB 10, 13, 'Today is $' ; 10=LF, 13=CR
.CODE
Today PROC
MOV AX, @data
MOV DS, AX
MOV DX, OFFSET mess1 ; Move string to DX
MOV AH, 09h ; 09h call to display string (DX > AH > DOS)
INT 21H ; Send to DOS
; CX year, DH month, DL day
MOV AH, 2AH ; Get the date (appendix D)
PUSH CX ; Move year to the stack
MOV CX, 0 ; Clear CX
MOV CL, DL
PUSH CX ; Move day to stack
MOV CL, DH ; Move month > CL
PUSH CX ; Move month to stack
MOV DH, 0 ; Clear DH
; ************************** DISPLAY MONTH ************************
Set up for division
Dividend will be in DX/AX pair (4 bytes)
Quotient will be in AX
Remainder will be in DX
MOV DX, 0 ; Clear DX
POP AX ; Remove month from stack into AX
MOV CX, 0 ; Initialize the counter
MOV BX, 10 ; Set up the divisor
dividem:
DIV BX ; Divide (will be word sized)
PUSH DX ; Save remainder to stack
ADD CX, 1 ; Add one to counter
MOV DX, 0 ; Clear the remainder
CMP AX, 0 ; Compare quotient to zero
JNE dividem ; If quoient is not zero, go to "dividem:"
divdispm:
POP DX ; Remove top of stack into DX

ADD DL, 30h ; ADD 30h (2) to DL
MOV AH, 02h ; 02h to display AH (DL)
LOOP divdispm ; If more to do, divdispm again
; LOOP subtracts 1 from CX. If non-zero, loop.
MOV DL, '/' ; Character to display goes in DL
************************** DISPLAY DAY ************************
Set up for division
POP AX ; Remove day from stack into AX
divided:

JNE divided ; If quoient is not zero, go to "divided:"
divdispd:
POP DX ; Remove top of stack
LOOP divdispd ; If more to do, divdispd again
MOV DL, '/' ; Character to display goes in DL
************************** DISPLAY YEAR ************************
Set up for division
POP AX ; Remove month from stack into AX
dividey:
JNE dividey ; If quoient is not zero, go to "dividey:"
divdispy:
POP DX ; Remove top of stack into DX
LOOP divdispy ; If more to do, divdisp again
MOV al, 0 ; Use 0 as return code
MOV AH, 4ch ; Send return code to AH
INT 21H ; Send return code to DOS to exit.
Today ENDP ; End procedure

END Today ; End code. Start using "Today" procedure.
MVI A, 80H: Initialize 8255, port A and port B
OUT 83H (CR): in output mode
START: MVI A, 09H
OUT 80H (PA): Send data on PA to glow R1 and R2
MVI A, 24H
OUT 81H (PB): Send data on PB to glow G3 and G4
MVI C, 28H: Load multiplier count (40ıο) for delay
CALL DELAY: Call delay subroutine
MVI A, 12H
OUT (81H) PA: Send data on Port A to glow Y1 and Y2
OUT (81H) PB: Send data on port B to glow Y3 and Y4
MVI C, 0AH: Load multiplier count (10ıο) for delay
CALL: DELAY: Call delay subroutine
MVI A, 24H
OUT (80H) PA: Send data on port A to glow G1 and G2
MVI A, 09H
OUT (81H) PB: Send data on port B to glow R3 and R4
MVI C, 28H: Load multiplier count (40ıο) for delay
MVI A, 12H
OUT PA: Send data on port A to glow Y1 and Y2
OUT PB: Send data on port B to glow Y3 and Y4
MVI C, 0AH: Load multiplier count (10ıο) for delay
JMP START
Delay Subroutine:
DELAY: LXI D, Count: Load count to give 0.5 sec delay
BACK: DCX D: Decrement counter
MOV A, D
ORA E: Check whether count is 0
JNZ BACK: If not zero, repeat
DCR C: Check if multiplier zero, otherwise repeat
JNZ DELAY
RET: Return to main program
Ram size:
ORG 0000H
CLR PSW3
CLR PSW4
CPL A
ADD A, #01H
MOV A,R3
AGAIN: SJMP AGAIN
VIVA QUESTIONS
1. Explain the logic behind the programs for password checking.
2. What is the function of microprocessor in a system?
3. What are the modes in which 8086 can operate?
4. What is the data and address size in 8086?
CONCLUSION:
Counters and Time Delay
EXP.NO: DATE:
AIM:
To write an assembly language program in 8086 to Counters and Time Delay
APPARATUS REQUIRED:
SL.NO ITEM SPECIFICATION QUANTITY
1. Microprocessor kit 8086 1
2. Power Supply +5 V, dc,+12 V dc 1
3. Stepper Motor Interface board - 1
4. Stepper Motor - 1
PROGRAM:
.MODEL SMALL
.DATA
MSGIN DB 'Enter delay duration (0-50): $'

MSG1 DB 'This is Microprocessor!$'
DELAYTIME DW 0000H
.CODE
MOV DX,@DATA
MOV DS,DX
LEA DX,MSGIN
MOV AH,09H
INT 21H
IN1:
MOV AH,01H
INT 21H
CMP AL,0DH ;
JE NXT
SUB AL,30H
MOV DL,AL
MOV AX,BX
MOV CL,0AH
MUL CL
MOV BX,AX
AND DX,00FFH
ADD BX,DX
MOV DELAYTIME,BX
LOOP IN1
NXT: MOV CX,DELAYTIME
MOV DL,10
MOV AH,02H
INT 21H
LEA SI,MSG1
LP: PUSH DX
MOV DL,[SI]
CMP DL,'$'
JE NXT2
MOV AH,02H
INT 21H
ADD SI,1
POP DX
MOV DI,DELAYTIME
MOV AH, 0
INT 1Ah
MOV BX, DX
Delay:
MOV AH, 0
INT 1Ah
SUB DX, BX
CMP DI, DX
JA Delay
LOOP LP
NXT2: MOV AH,4CH

INT 21H
END
VIVA QUESTIONS
1. What is BCD Counter?

2. What are the application of counter?
3. What are different types of counters?
4. What is Ring counter?
CONCLUSION:
8051
MICROCONTROLLER
EXECUTION PROCEDURE FOR 8051
Writing a alp program into 8051:
Switch on kit
Press reset
Press A (give starting address)
Press enter
st
Enter 1 mnemonic
Press enter
Enter 2nd mnemonic
Press enter
---
---
---
Enter nth mnemonic
Press enter
Press enter
Press enter
Display: A D G M T S
To compile:
Press G (give starting address)
Press enter
Display: program executed
Result:
Press R
A, B, R0, -------, Rn
8-BIT AND 16-BIT ADDITION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform 8-bit and 16-bit
addition using 8051 micro controller.

1. Microcontroller kit 8051 kit 1
3. Key board - 1
ALGORITHM:
STEP 3: Addition operation is performed on given input data.

FLOW CHART:
PROGRAM:
8-BIT ADDITION (INTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
A100 MOV R0,#40 78 Move data 40 to R0
A101 40 register
A102 MOV R1,#41 79 Move data 40 to R0
A103 41 register
A104 MOV A,@R0 E6 Move R0 t0 accumulator
A105 ADD A,@R1 27 Add accumulator with R1
register
A106 INC R1 09 Increment R1
A107 MOV @R1,A E7 Move A to memory
A108 LCALL 00BB 12 Call subroutine to the
A109 00 address 00BB
A10A BB
8-BIT ADDITION-INTERNAL MEMORY

INPUT OUTPUT
40
42
41
8-BIT ADDITION (EXTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
9000 MOV R4,#00 7C Move the data 00 to R4
9001 00
9002 MOV DPTR,#8100 90 Initialize the memory
9003 00 pointer to DPTR
9004 81
9005 MOVX A,@DPTR E0 Move DPTR to A
9006 INC DPTR A3 Increment DPTR
9007 MOV R0,A F8 Move A to R0
9008 MOVX A,@DPTR E0 Move DPTR to A
9009 ADD A,R0 28 Add A and R0
900A JNC 900D(AA) 05 Jump to 900D if no carry
900B 80 occurs
900C INC R4 0C Increment R4
900D AA INC DPTR A3 Increment DPTR
900E MOVX @DPTR,A F0 Move A to DPTR
900F INC DPTR A3 Increment DPTR
9010 MOV A,R4 EC Move r4 to A
9011 MOVX @DPTR,A F0 Move A to DPTR
9012 SJMP 9000 80 Short jump to 9000
9013 EC
SAMPLE INPUT OUTPUT
8-BIT ADDITION-EXTERNAL MEMORY

INPUT OUTPUT
8100 8102
8101 8103
16-BIT ADDITION
MNEMONICS HEX
OPCODE OPERAND CODE
9500 MOV A,#2F 74 Move the data to
9501 2F accumulator
9502 MOV R1,#2F 79
Move the data to R1 reg
9503 2F
9504 MOV R2,#02 7A
9505 02
9506 MOV R3,#12 7B
9507 12
9508 ADD A,R2 2A Add A and R2 reg
9509 MOV DPTR,#8500 90
Initialized memory pointer
950A 00
by data pointer
950B 85
950C MOVX @DPTR,A E0 Move A t0 DPTR
950D MOV A,R1 E9 Move R1 to Accumulator
950E ADD A,R3 2B Add A and R3 reg
950F INC DPTR A3 Increment DPTR
9510 MOVX @DPTR,A E0 Move A t0 DPTR
9511 SJMP 9500 80 Short jump to the address
9512 ED 9500
16-BIT ADDITION
INPUT OUTPUT
IMMEDIATE DATA ADDRESS DATA
DATA 1 8500
DATA2 8501
BY USING MASM:
16 BIT ADDITION
$MOD51
ORG 0000H
MOV DPTR, #0101H
MOVX A,@DPTR
MOV B, A
DEC DPL
MOV A,@DPTR
ADD A, B
INC DPTR
INC DPTR
MOVX @DPTR, A
CLR A
ADDC A, #00H
INC DPTR
MOVX @DPTR, A
STOP: SJMP STOP
END
CONCLUSION:
8-BIT AND 16-BIT SUBTRACTION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform 8-bit and 16-bit
subtraction using 8051 micro controller.

3. Key board - 1
ALGORITHM:
STEP 3: Subtraction operation is performed on given input data.

FLOW CHART:
PROGRAM: 8-BIT SUBTRACTION (INTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV A,#55 74 Move the data to
8001 55 accumulator
8002 MOV B,#22 75
Move the data to B
8003 F0
register
8004 22
8005 SUBB A,B 95 Subtract B from the
8006 F0 content of accumulator
8007 MOV 40,A F5
Move A content to 40
8008 42
8009 LCALL 00BB 12
Call subroutine to the
800A 00
address 00BB
BB
SAMPLE INPUT/OUTPUT
8-BIT SUBTRACTION-INTERNAL MEMORY

INPUT OUTPUT
DATA 1
40
DATA 2
8-BIT SUBTRACTION (EXTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
A300 MOV A,#24 74 Move the data to
A301 24 accumulator
A302 MOV R3,#02 7B Move the data to R3
A303 02 register
SUBB A,R3 9B Subtract R3 from the
A304
content of accumulator
A305 MOV DPTR,#8100 90
A306 00
by data pointer
A307 81
A308 MOVX @DPTR,A F0 Move A to DPTR
A309 SJMP A300 80
Short jump to A300
A30A F5
SAMPLE INPUT/OUTPUT
8-BIT SUBTRACTION-EXTERNAL MEMORY

INPUT OUTPUT
DATA 1
8100
DATA 2
16-BIT SUBTRACTION:
MNEMONICS HEX
OPCODE OPERAND CODE
A900 MOV A,#2F 74 Move the data to
A901 2F accumulator
A902 MOV R1,#2F 79
Move the data to R1 register
A903 2F
A904 MOV R2,#02 7A Move the data to R2
A905 02 register
A906 MOV R3,#12 7B Move the data to R3
A907 12 register
A908 SUBB A,R2 9A Subtract A and R2 register
A909 MOV DPTR,#9300 90
A90A 00
by data pointer
A90B 93
A90C MOVX @DPTR,A E0 Move A to DPTR
A90D MOV A,R1 E9 Move R1 to Accumulator
A90E SUBB A,R3 9B Subtract A and R3
A90F INC DPTR A3 Increment DPTR
A910 MOVX @DPTR,A E0 Move A t0 DPTR
A911 SJMP A900 80 Short jump to the address
A912 ED 9500
16-BIT SUBTRACTION
INPUT OUTPUT
DATA 1 9300
DATA 2 9301
BY USING MASM:
16 BIT SUBTRACTION
$MOD51
ORG 0000H
MOV DPTR, #0101H
MOVX A,@DPTR
MOV B, A
DEC DPL
MOVX @DPTR, A
CLR C
SUBB A,B
INC DPTR
INC DPTR
MOVX @DPTR, A
CLR A
ADDC A, #00H
INC DPTR.
MOVX @DPTR,A
STOP: SJMP STOP
END
CONCLUSION:
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform 8-bit multiplication
using 8051 micro controller.

3. Key board - 1
ALGORITHM:
STEP 3: Multiplication operation is performed on given input data.

FLOW CHART:
8-BIT MULTIPLICATION (INTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
9000 MOV R0,#40 78
Move the data to R0
9001 40
9002 MOV R1,#41 79
Move the data to R1
9003 41
9004 MOV A,@R0 E6 Move R0 to Accumulator
9005 MOV B,@R1 87
Move R1 to B
9006 F0
9007 MUL AB A4 Multiply A and B
9008 INC R1 09 Increment R1
9009 MOV @R1,A F7 Move A to memory
900A INC R1 09 Increment R1
900B MOV @R1,B A7
Move B to memory
900C F0
900D LCALL 00BB 12
Long call to the address
900E 00
00BB
900F BB
8-BIT MULTIPLICATION-INTERNAL MEMORY

INPUT OUTPUT
40 42
41 43
8-BIT MULTIPLICATION (EXTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
8001 55 accumulator
8002 MOV B,#04 75
8003 04 Move the data to B
8004 0B
8005 MUL AB A4 Multiply A and B
8006 MOV DPTR,#8100 90
8007 00
by data pointer
8008 81
8009 MOVX @DPTR,A F0 Move A t0 DPTR
800A INC DPTR A3 Increment DPTR
800B MOV A,B E5
Move B to A
800C F0
800D MOVX @DPTR,A E0 Move A t0 DPTR
800E SJMP 8000 80 Short jump to the address
800F F0 8000
8-BIT MULTIPLICATION-EXTERNAL MEMORY

INPUT OUTPUT

DATA 1 8100
DATA 2 8101
BY USING MASM:
.MULTIPLICATION
$MOD51
ORG 0000H
MOV DPTR, # 0101H
MOVX A,@DPTR
MOV B, A
DEC DPL
MOVX A, @DPTR
MUL AB
INC DPTR
INC DPTR
MOVX @DPTR, A
MOV A, B
INC DPTR
MOVX @DPTR, A
STOP: SJMP STOP
END
CONCLUSION:
8-BIT DIVISION
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform 8-bit division using
8051 micro controller.

3. Key board - 1
ALGORITHM:
STEP 3: Division operation is performed on given input data.

FLOW CHART:
8-BIT DIVISION (INTERNAL MEMORY
MNEMONICS HEX
OPCODE OPERAND CODE
9000 MOV R0,#40 78
Move the data to R0
9001 40
9002 MOV R1,#41 79
Move the data to R1
9003 41
9004 MOV A,@R0 E6 Move R0 to Accumulator
9005 MOV B,@R1 87
Move R1 to B
9006 F0
9007 DIV AB 84 Divide A and B
9008 INC R1 09 Increment R1
9009 MOV @R1,A F7 Move A to memory
900A INC R1 09 Increment R1
900B MOV @R1,B A7
Move B to memory
900C F0
900D LCALL 00BB 12
Long call to the address
900E 00
00BB
900F BB
8-BIT DIVISION-INTERNAL MEMORY

INPUT OUTPUT
40 42
41 43
8-BIT DIVISION (EXTERNAL MEMORY)
MNEMONICS HEX
OPCODE OPERAND CODE
8001 55 accumulator
8002 MOV B,#04 75
8003 04 Move the data to Breg

8004 0B
8005 DIV AB 84 Divide A and B

8006 MOV DPTR,#8100 90
Initialized memory
8007 00
pointer by data pointer
8008 81
8009 MOVX @DPTR,A F0 Move A t0 DPTR

800A INC DPTR A3 Increment DPTR
800B MOV A,B E5
Move B to A
800C F0
800D MOVX @DPTR,A E0 Move A t0 DPTR
800E SJMP 8000 80 Short jump to the
800F F0 address 8000
8-BIT DIVISION-EXTERNAL MEMORY

INPUT OUTPUT
DATA 1 8100
DATA 2 8101
BY USING MASM:
D.DIVISION
$MOD51
ORG 0000H
MOV DPTR, # 0101H
MOV X A,@DPTR
MOV B, A
DEC DPL
MOVX A, @DPTR
DIV AB
INC DPTR
INC DPTR
MOVX @DPTR, A
MOV A, B
INC DPTR
MOVX @DPTR, A
STOP: SJMP STOP
END
VIVA QUESTIONS
1. Explain the logic behind the programs for arithmetic operations using 8051.
2. What is a Micro controller? What is the difference between microprocessor & micro
controller?
3. List the addressing modes of 8051?
4. List the salient features of 8051 microcontroller?
5. What is the function of program counter in 8051?
6. What are program and data memory?
7. List different special function registers and their functions
CONCLUSION:
FIND TWO’S COMPLEMENT OF A NUMBER
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to perform two‟s complement
of a number using 8051 micro controller.

3. Key board - 1
ALGORITHM:
STEP 3: Complement the input data and then add with 01.
STEP 4: Perform addition operation with input and complemented one.

FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV A,#03 74 Move immediate data to
8001 03 Accumulator
CPL A F4 Complement
8002
Accumulator
8003 ADD A,#01 24 Add with A and
8004 01 immediate data 01
8005 MOV DPTR,#8100 90 Move the
8006 00 CONCLUSION address
8007 81 to DPTR
MOVX @DPTR,A F0 Store the CONCLUSION
8008 in corresponding memory
location
8009 SJMP 8000 80 Short jump
800A F5
INPUT OUTPUT
IMMEDIATE
ADDRESS DATA
DATA
8100
BY USING MASM:
CONCLUSION:
FIND SQUARE OF A NUMBER
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to find square of a number
using 8051 microcontroller.

3. Key board - 1
ALGORITHM:
STEP 3: Set the count value.
STEP 4: Add the input data with data 00.
STEP 5: Decrement the count value.
STEP 6: Repeat the process until count equals zero.

FLOWCHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV DPTR,#8100 Get the input from memory
8001 location
8002
MOVX A,@DPTR Move data from memory to
8003
A
8004 MOV B,A Move the content of A to B
MOV R0,A Move the content of A to
8005
R0
8006 MOV A,#00 Move the immediate data
8007 00 to Accumulator
XXX ADD A,B Add the content of A with
8008
B
8009 DEC RO Decrement the count value
800A JNZ 8008(XXX) Jump if not zero
800B
800C INC DPTR Increment memory pointer
800D MOVX @DPTR,A Store the CONCLUSION.
800E SJMP 8000 Stop the program
800F

INPUT OUTPUT
8100 8101
BY USING MASM:
CONCLUSION:
.
FIND CUBE OF A NUMBER
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) to find cube of a number using
8051 microcontroller.

3. Key board - 1
ALGORITHM:
STEP 3: Set the count value.
STEP 4: Add the input data with data 00.
STEP 5: Decrement the count value.
STEP 6: Repeat the process until count equals zero.

FLOWCHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV A,#00 Clear the accumulator
8001 content
8002 MOV B,#03 Move the input to B
8003 register
8004 XXX ADD A,#03 Add accumulator content
8005 with immediate data
8006 DEC B Decrement count value
8007 JNZ 8004(XXX) Jump if no zero
8008
8009 MOV R0,A Move data from A to R0
800A MOV B,#02 Move the data to B register
800B
YYY ADD A,R0 Add the content of A with
800C
R0
800D DEC B Decrement B register
800E JNZ 800C(YYY) Jump if no zero to
800F mentioned address
8010 MOV DPTR,#8100 Initialize the output
8011 memory address
8012
8013 MOVX @DPTR,A Store the CONCLUSION
8014 SJMP 8000 Short jump to address
8015
INPUT OUTPUT
DATA 8100
BY USING MASM:
CONCLUSION:
8086 INTERFACING
STEPPER MOTOR INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing stepper motor
Using 8086 microprocessor.

3. Key board - 1
4. Stepper motor card - 1
5. Stepper motor power 1
+5 V dc
supply
ALGORITHM:

STEP 2: Move the data 66 to Accumulator.
STEP 3: Send the data in Acc to I/O port.
STEP 4: Wait for some time (small delay).
STEP 5: Rotate the Acc contents left/right by one bit.
STEP 6: Repeat from step 2.
90° PHASE SHIFT:
STEP 1Move the data 66 to Accumulator.

STEP 2: Move the count for 90 degree to AH register. (Count=Angle to be
rotated/Angle for one step for motor)
STEP 4: Wait for some time (small delay).
FLOW CHART:
CLOCKWISE DIRECTION: ANTI-CLOCKWISE
DIRECTION
90° PHASE SHIFT:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
CLOCKWISE DIRECTION
5000 MOV DX,00C0 BA
Move the port address to
5001 C0
DX register
5002 00
5003 MOV AL,66 B0 Store data to energise
5004 66 phase2 and phase3
Data moved into port
5005 SSS OUT DX,AL EE
address
5006 CALL 500D(XXX) E8
5007 04 Delay between two steps
5008 00
5009 ROR AL,1 D0 Rotate right the content of
500A C8 the accumulator
500B JMP 5005(SSS) E8 Repeat the above process
500C F8 for ever
DELAY PROGRAM
500D XXX MOV CX,0500 B9
Move the count value to
500E 00
CX register
500F 05
5010 GGG DEC CX 49 Decrement CX value
5011 JNE 5010(GGG) 75 Jump if the value of CX is
5012 FD not equal (or)zero
5013 RET C3 Return
MNEMONICS HEX
OPCODE OPERAND CODE
ANTI-CLOCKWISE DIRECTION
5050 MOV DX,00C0 BA
5051 C0
DX register
5052 00
Data moved into port
5055 KKK OUT DX,AL EE
address
5056 CALL 500D(XXX) E8
5057 04 Delay between two steps
5058 00
5059 ROL AL,1 D0 Rotate left the content of
505A C8 the accumulator
505B JMP 5055(KKK) E8 Repeat the above process
505C F8 for ever
90° PHASE SHIFT
5100 MOV AH,32 B4 Move count value 32 to
5101 32 AH register
5102 MOV DX,00C0 B4
5103 C0
DX register
5104 00
5107 DDD OUT DX,AL EE The value sent to port
5108 CALL 5108 E8
Delay between two steps
5109 02
MNEMONICS HEX
OPCODE OPERAND CODE
510A FF
510B ROL AL,1 D0 Rotate left the value of
510C C0 AL
510D DEC AH FE Decrement the count
510E CC value
510F JNE 5107(DDD) 75
Jump if not equal
5110 F6
5111 RRR NOP 90 No operation
5112 JMP 5111(RRR) EB
Jump program to 5111
5113 FD
CONCLUSION:
8255 INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of 8255
3. Key board - 1
4. 8255interface card - 1
ALGORITHM:
STEP 2: Initialize the 8255 ports by sending the control word 82.
STEP 3: Set port B as input port by proper jumper settings.
STEP 4: Set port A as output port by proper jumper settings.
STEP 5: Read the switches at port B.
STEP 6: Display the reading port A.
JUMPER SETTINGS:
1. Short the pins P2 and P11 0f J1 and short pins P3 and P10, so that port B input buffer
is enabled.
2. Short the pins P1 and P12 of J2 and short pins P4 and P9, so that Port A output buffer
is enabled.
FLOW CHART:
CONTROL WORD FORMAT:

PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
5000 XXX MOV DX,00C6 BA
Move the control word
5001 C6
address to DX register
5002 00
5003 MOV AL,82 B0 Move the count value 82
5004 82 to the accumulator
5005 OUT DX,AL EE Count value sent to port
5006 MOV DX,00C2 BA
5007 C2 Set port B as input port
5008 00
Input port value to
5009 IN AL,DX EC
accumulator
500A MOV DX,00C0 BA
500B C0 Set port A as output port
500C 00
Accumulator value to
500D OUT DX,AL EE
output port
500E JMP 5000(XXX) EB Jump the program to 5000
CONCLUSION:
DAC INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of DAC

3. Key board - 1
4. DAC interface card - 1
5. CRO - 1
ALGORITHM:
SQUARE WAVE:
STEP 2: Load accumulator with 00 and send it to the D/A convertor.
STEP 3: Call a delay of 1ms which is the off-time delay.
STEP 4: Initialize D/A convertor by sending FF to the output port.
STEP 5: Call a delay of 1ms which is the on-time delay

.
STEP 6: Repeat the loop.
TRIANGULAR WAVE:
STEP 3: Increment the data and send it to the accumulator.
STEP 4: Repeat the loop until Accumulator reaches 00.
STEP 5: Load accumulator with FF and send it to the D/A convertor.
STEP 6: Decrement the data and send it to the accumulator.
STEP 7: Repeat the loop until Accumulator reaches 00.
STEP 8: Repeat the process again and again.
SAWTOOTH WAVE:
STEP 4: Repeat the process unconditionally.

FLOW CHART:
SQUARE WAVE
SAWTOOTH WAVE:
TRIANGULAR WAVE:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
SQURE WAVE GENERATION
5100 MOV AX,0000 B8
Move the value 0000 to
5101 00
AX register
5102 00
5103 MOV DS,AX 8E Move the value from Ax to
5104 D8 DS
5105 MOV DX,00C0 BA
5106 C0
DX register
5107 00
5108 KKK MOV AL,00 B0 Data to be set DAC output
5109 00 to 0 level
510A OUT DX,AL EE Send data to DAC
510B CALL 525F(XXX) E8
510C 51 Off time delay
510D 01
510E MOV AL,FF B0 Data to be set DAC output
510F FF to 1 level
5110 OUT DX,AL EE Send data to DAC
5111 CALL 525F(XXX) E8
5112 4B On time delay
5113 01
5114 JMP 5108(KKK) EB
Repeat process
5115 F2
MNEMONICS HEX
OPCODE OPERAND CODE
TRIANGULAR WAVE GENERATION
5150 MOV AX,0000 B8
Move the value 0000 to AX
5151 00
register
5152 00
5154 D8 DS
5155 MOV DX,00C0 BA
5156 C0
DX register
5157 00
5158 DDD MOV AL,00 B0
Start DAC output from 0V
5159 00
515A SSS OUT DX,AL EE Send data to DAC
515B INC AL FE
Increment AL
515C C0
515D JNE 515A(SSS) 75
Repeat until AL becomes 0
515E FB
515F MOV AL,FF B0 Move the value FF to AL
5160 FF register
5161 KKK OUT DX,AL EE Send data to DAC
5162 DEC AL FE
Decrement AL value
5163 C8
5164 JNE 5161(KKK) 75
Repeat until AL becomes 0
5165 FB
5166 JMP 5158(DDD) EB Repeat process
5167 F3
MNEMONICS HEX
OPCODE OPERAND CODE
SAW TOOTH WAVE GENERATION
5200 MOV AX,0000 B8
Move the value 0000 to AX
5201 00
register
5202 00
5204 D8 DS
5205 MOV DX,00C0 BA
5206 C0
DX register
5207 00
5208 MOV AL,00 B0 Move the value 00 to AL
5209 00 register
520A ABC OUT DX,AL EE Send data to DAC
520B INC AL FE
Increment AL
520C C0
520D JMP 520A(ABC) EB
Repeat process
520E FB
DELAY PROGRAM
525F MOV CX,00FF B9
5260 FF Move the count value to CX
5261 00
5262 MMM DEC CX 49 Decrement CX
5263 JNE 5262(MMM) 75
Jump if not equal
5264 FD
5265 RET C3 Return the program
OBSERVATION
S.No TIME PERIOD(msec) AMPLITUDE (volts)
CONCLUSION:
COUNTER DESIGN 8253 INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of counter
using8086 microprocessor .

3. Key board - 1
4. 8253 interface card - 1
5. CRO - 1
ALGORITHM:
STEP 2: Set a control word for counter 2 in mode -3(Square wave generation).
STEP 3: Give the lower byte of count value
STEP 4:Give the higher byte of count value.
FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
5050 MOV DX,00C6 BA
5051 C6
DX register
5052 00
5053 MOV AL,B6 B0 Move count value to AL
5054 B6 register
5055 OUT DX,AL EE Move AL value to DX
5056 MOV DX,00C4 BA
5057 C4
DX register
5058 00
5059 MOV AL,E8 B0 Move lower byte of count
505A E8 value to AL register
505B OUT DX,AL EE Move AL value to DX
505C MOV AL,03 B0 Move higher byte of count
505D 03 value to AL register
505E OUT DX,AL EE Move AL value to DX
505F XXX NOP 90 No operation
5060 JMP 505F(XXX) EB
Jump program
5061 FD
OBSERVATION
CONCLUSION:
KEYBOARD AND DISPLAY INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of keyboard and
display Using 8086 microprocessor.

3. Key board - 1
ALGORITHM:
STEP 2: Initialize 8279 with 8 digits of display by sending command (00) to port.
STEP 3: Locate the first digit address with auto increment mode by sending
command(90) to port..
STEP 4:Send seven- segment code(3F)for ”0”.
STEP 5: Send seven- segment code(3F)for ”1”..
STEP 8: stop the program.
FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
5000 MOV DX,00C2 BA
5001 C2
DX register
5002 00
5003 MOV AL,00 B0
Move 00 to AL register
5004 00
5005 OUT DX,AL EE Move AL to 00C2
5006 MOV AL,90 B0
Move 90 to AL register
5007 90
5009 MOV DX,00C0 BA
500A C0
DX register
500B 00
500C MOV AL,3F B0 Move 3F to AL register to
500D 3F display”0”
500E OUT DX,AL EE Move AL to 00C0
500F MOV AL,06 B0 Move 06 to AL register to
5010 06 display”1”
5012 MOV AL,5B B0 Move 5B to AL register to
5013 5B display”2”
5015 MOV AL,4F B0,4F Move 4F to AL register to display”3”

5018 JMP 5108 EB,FE Jump to address 5108
SEVEN SEGMENT DISPLAY:
Control word format:
CONCLUSION:
TRAFFIC LIGHT CONTROLLER (TLC) INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of traffic light
controller using8086 microprocessor .

3. Key board - 1
4. TLC card - 1
ALGORITHM:
STEP 2: Initialize all the three ports of 8255 as output ports.
STEP 3: Turn on DON‟T WALK signals in all the roads.
STEP 4: Turn on GO signal in road 1.
STEP 5: Turn on READY signal in road 2 and STOP signal in all other roads.
STEP 7: Turn on READY signal in road 3 and STOP signal in all other roads.
STEP 9: Turn on READY signal in road 4 and STOP signal in all other roads
STEP 10: Turn on GO signal in road 4
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
5000 MOV BX,5029 BB
Initialize BX with BIT
5001 29
PATTERNS
5002 50
5003 MOV CX,09 B9
5004 09 Move the count value
5005 00
5006 MOV AL,80 B0
Initialize all ports
5007 80
5008 MOV DX,0046 BA
5009 46 Control port address
500A 00
500B OUT DX,AL EE Set all the ports
500C MOV AL,[BX] 8A
Get the bit patterns
500D 07
500E MOV DX,0040 BA
500F 40 Move the port A address
5010 00
5011 OUT DX,AL EE
5012 INC BX 43
5013 MOV AL,[BX] 8A
5014 07
5015 INC DX 42
5016 INC DX 42
5017 OUT DX,AL EE
MNEMONICS HEX
OPCODE OPERAND CODE
5018 INC BX 43
5019 MOV AL,[BX] BA,07
501B INC DX 42
501C INC DX 42
501D OUT DX,AL EE
501E INC BX 43
501F MOV AL,[BX] 8A
Get the bit for time delay
5020 07
5021 CALL 504D E8
5022 29 Delay routine for 1 sec
5023 00
5024 INC BX 43
5025 LOOP 500C E2
Repeat up to 9 cycles
5026 E5
5027 JMP 5000 EB
5028 D7 Repeat from cycle 1
Save the BX register

504D PUSH BX 53
counters
Save the CX register
504E PUSH CX 51
counters
504F ADD AL,01 04 Add the data bit for time
5050 01 with 01
5051 DAA 27
5052 MOV CL,AL 8A Save the value in CL

MNEMONICS HEX
OPCODE OPERAND CODE
5053 C8
5054 MOV BL,00 B3
5055 00
5056 PUSH CX 51
5057 MOV CX,04 B9
5058 04
5059 00
505A PUSH CX 51
505B MOV CX,FFFF B9
505C FF
505D FF
505E LOOP 505E E2
505F FE
5060 POP CX 59
5061 LOOP 505A E2
5062 F7
5063 POP CX 59
5064 MOV AL,BL 8A
5065 C3
5066 ADD AL,01 04
5067 01
5068 DAA 27
5069 CMP AL,CL 38
Compare the values
506A C8
MNEMONICS HEX
OPCODE OPERAND CODE
506B MOV BL,AL 8A Update BL register
506C D8 contents
506D JNE 5056 75
Repeat the delay
506E E7
506F POP CX 59
5070 POP BX 5B
5071 RET C3 Return
BIT PATTERNS
5029 B4 60 09 20
502D 9C 40 0B 05
5031 96 40 0B 20
5035 E4 40 0B 05
5039 A4 41 0B 20
503D B4 40 0E 05
5041 B4 40 1A 20
5045 31 12 23 10
5049 B4 C0 09 05
CONCLUSION:
PRINTER STATUS
EXP.NO:
DATE:
AIM:
To display the Printer in the display
Status
PROGRAM:
CONCLUSION
8051 INTERFACING
STEPPER MOTOR INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing stepper motor
using 8051 micro controller.

3. Key board - 1
4. Stepper motor card - 1
5. Stepper motor power 1
+5 V dc
supply
ALGORITHM:
STEP 2: Move the data 66 to Accumulator.
STEP 4:Wait for some time (small delay).
90° PHASE SHIFT:

STEP 1Move the data 66 to Accumulator.
STEP 2:Move the count for 90 degree to R2 register.(count=Angle to be
rotated/Angle for one step for motor)
STEP 4:Wait for some time (small delay).
FLOW CHART:
CLOCKWISE DIRECTION: ANTI-CLOCKWISE

DIRECTION
90° PHASE SHIFT:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
CLOCKWISE DIRECTION
8000 MOV DPTR,#FFC0 90
Move port address to DX
8001 FF
register
8002 C0
8003 MOV A,#66 74 Store data to energise
Move Accumulator value to
8005 AAA MOVX @DPTR,A F0
DPTR
8006 ACALL 800B(XXX) 11
8007 0B
8008 RR A 03 Rotate right “A”
8009 SJMP 8005(AAA) 80 Repeat the above process
800A FA for ever
DELAY PROGRAM
800B XXX MOV R0,#0A 78 Move immediate data 0A to
800C 0A R0 register
800D MOV R1,#FF 79 Move immediate data FF to
800E FF R1 register
800F DJNZ R1,800F D9 Decrement Jump if not zero
8010 FE to 800F
8011 DJNZ R0,800D D8 Decrement Jump if not zero
8012 FA to 800D
8013 RET 22 Return
MNEMONICS HEX
OPCODE OPERAND CODE
ANTI-CLOCK WISE DIRECTION
Move port address to DX
8041 FF
register
8042 C0
8045 BBB MOVX @DPTR,A F0 Move A value to DPTR
8046 ACALL 800B(XXX) 11
8047 0B
8048 RL A 23 Rotate Left “A”
Repeat the above process
8049 SJMP 8045(BBB) 80,FA
for ever
90° PHASE SHIFT
8060 MOV DPTR,#FFC0 90,FF,C0 Move port address to DX
8065 MOV R2,#32 7A Move count value to R2 for
8066 32 90° shift
8067 MOVX @DPTR,A F0 Move „A‟value to DPTR
8068 ACALL 800B(XXX) 11
8069 0B
806A RL A 23 Rotate Left “A”
806B DJNZ R2,8067 DA Decrement Jump if not
806C FA zero to 800F
Repeat the above process
806D SJMP 806D 80,FE
for ever
CONCLUSION:
8255 INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of 8255
Using8051 microcontroller.
3. Key board - 1
4. 8255interface card - 1
ALGORITHM:
STEP 1: Start the program.STEP 2: Initialize the 8255 ports by sending the control
word 82.STEP 3: Set port B as input port by proper jumper settings.STEP 4:Set port A
as output port by proper jumper settings.STEP 5: Read the switches at port B. STEP 6:
Display the reading port A.
JUMPER SETTINGS:
1. Short the pins P2 and P11 0f J1 and short pins P3 and P10,so that port B input
buffer is enabled.
2. Short the pins P1 and P12 of J2 and short pins P4 and P9 ,so that Port A output
buffer is enabled.
FLOW CHART:

PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV A,#82 74 Move the control word to
8001 82 accumulator
8003 FF
the DPTR
8004 C6
8005 MOVX @DPTR,A F0 Move A to DPTR
Move port B address to
8007 FF
DPTR
8008 C2
8009 MOVX A,@DPTR F0 Set port B as input
800A MOV DPTR,#FFC0 90
Move port A address to
800B FF
DPTR
800C C0
800D MOVX @DPTR,A F0 Set port A as output
800E SJMP 800E 80 Short jump to address
800F FE 800E
CONCLUSION:
DAC INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of DAC
Using 8051 microcontroller.

3. Key board - 1
4. DAC interface card - 1
5. CRO - 1
ALGORITHM:
SQUARE WAVE:
STEP 3: Call a delay of 1ms which is the off-time delay.
STEP 4:Initialize D/A convertor by sending FF to the output port.
STEP 5: Call a delay of 1ms which is the on-time delay.
STEP 6: Repeat the loop.
TRIANGULAR WAVE:
STEP 4:Repeat the loop until Accumulator reaches 00.
STEP 5: Load accumulator with FF and send it to the D/A convertor.
STEP 6: Decrement the data and send it to the accumulator.
STEP 7:Repeat the loop until Accumulator reaches 00.
STEP 8:Repeat the process again and again.
SAWTOOTH WAVE:
STEP 4:Repeat the process unconditionally.
FLOW CHART:
SQUARE WAVE
SAWTOOTH WAVE:
TRIANGULAR WAVE:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
SQUARE WAVE GENERATION
Move port address to data
8201 FF
pointer
8202 C0
8203 MOV A,#00 74 Data to set DAC output to
8204 00 0 level
8205 MOVX @DPTR,A F0 Move data from A to port
8206 MOV R0,#FF 78
Off time delay
8207 FF
8208 DJNZ R0,8208 D8 Decrement and jump not
8209 FE zero
820A MOV A,#FF 74 Data to set DAC output to
820B FF 1 level
820C MOVX @DPTR,A F0 Move data from A to port
820D MOV R0,#FF 78
On time delay
820E FF
820F DJNZ R0,820F D8 Decrement and jump not
8210 FE zero
8211 SJMP 8203 80
Repeat process
8212 F0
TRIANGULAR WAVE GENERATION
8241 FF
pointer
8242 C0
MNEMONICS HEX
OPCODE OPERAND CODE
8243 MOV A,#00 74
Start DAC output from 0V
8244 00
8246 INC A 04 Increment A
8247 CJNE A,#FF,8245 B4
Repeat until A becomes
8248 FF
FF
8249 FB
824A MOVX @DPTR,A F0 Move data from A to port
824B DEC A 14 Decrement A
824C CJNE A,#00,824A B4
Repeat until A becomes
824D 00
00
824E FB
824F SJMP 8243 80,F2 Repeat process
SAWTOOTH WAVE GENERATION
8261 FF
pointer
8262 C0
8263 KKK MOV A,#00 74 Move data 00 to
8264 00 accumulator
8266 INC A 04 Increment A
8267 SJMP 8265(KKK) 80
Repeat process
8268 FC
OBSERVATION
CONCLUSION:
COUNTER DESIGN 8253 INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of counterusing
8051microcontroller.

3. Key board - 1
5. CRO - 1
ALGORITHM:
STEP 2: Set a control word for counter 2 in mode -3(Square wave generation).
STEP 3: Give the lower byte of count value
STEP 4:Give the higher byte of count value.
FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV A,#B6 74 Move control word value
8001 B6 to A register
8003 FF
DPTR
8004 C6
Move the content of A to
8005 MOVX @DPTR,A F0
DPTR
8007 FF
DPTR
8008 C4
8009 MOV A,#E8 74 Move the lower byte
count value to
800A E8
Accumulator
800B MOVX @DPTR,A F0
DPTR
800C MOV A,#03 74 Move the higher byte
count value to
800D 03
Accumulator
800E MOVX @DPTR,A F0
DPTR
800F SJMP 8000 80
Short jump to 8000
8010 EF
OBSERVATION
CONCLUSION:
KEYBOARD AND DISPLAY INTERFACING
EX NO:
DATE:
OBJECTIVE:
To write an Assembly Language Program (ALP) for interfacing of keyboard and
display using8051microcontroller.

3. Key board - 1
ALGORITHM:
STEP 2: Initialize 8279 with 8 digits of display by sending command (00) to port.
STEP 3: Locate the first digit address with auto increment mode by sending
command (90) to port.
STEP 4:Send seven- segment code(3F)for ”0”.
STEP 5: Send seven- segment code(3F)for ”1”.
STEP 8: stop the program.
FLOW CHART:
PROGRAM:
MNEMONICS HEX
OPCODE OPERAND CODE
8000 MOV A,#00 74 Move data 00 to
8001 00 accumulator
8003 FF
pointer
8004 01
8006 MOV A,#90 74 Move data 90 to
8007 90 accumulator
800A FF
pointer
800B 00
800C MOV A,#3F 74 Move data 3F to
800D 3F accumulator
800E MOVX @DPTR,A F0 Move data from A to port
800F MOV A,#06 74 Move data 06 to
8010 06 accumulator
Move data 5B to
8012 MOV A,#5B 74,5B
accumulator
Move data 4F to
8015 MOV A,#4F 74,4F
accumulator
8018 SJMP 8000 80,FE Short jump to address
SEVEN SEGMENT DISPLAY:
CONCLUSION:
DIGITAL CLOCK
EXP NO.:
DATE:
OBJECTIVE :
To display the digital clock specifically by displaying the hours, minutes and seconds
using 8086 kits
COMPONENTS required :
1. Microprocessor kit 8086

2. Power Supply 5V
CONCLUSION:
SERIAL INTERFACE AND PARALLEL INTERFACE
EXP NO.:
DATE:
OBJECTIVE: To connect two 8086 microprocessor kits and to serially communicate with
each other by considering transmitter and receiver kits.
Procedure
1. Take two no of 8086 microprocessor kits.
2. Enter the transmitter program in transmitter kit.
3. Enter the receiver program in receiver kit.
4. Interface the two kits with 9-9 serial cable in the serial port of the microprocessor kits. (LCD kit means
PC-PC cable. LED kit means kit-kit cable)
5. Enter the data in transmitter kit use the memory location 1500.
6. Execute the receiver kit.
7. Execute the transmitter kit.
8. Result will be available in receiver kit memory location 1500.

TRANSMITTER PROGRAM:
RECEIVER PROGRAM:
CONCLUSION:

RIT Lab Manual MCMP

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

RIT Lab Manual MCMP

Hochgeladen von

Copyright:

Verfügbare Formate

RAJALAKSHMI INSTITUTE OF TECHNOLOGY

DEPARTMENT OF ELECTRONICS AND COMMUNICATION

CS 6412/IT6411- MICROPROCESSOR AND

Mr. U.Maheswaran AP/ECE

Mr. K.A.Karthigeyan AP/ECE

Mr. G.Kalyan Kumar AP/ECE

Ms. S.Priyadharshini AP/ECE

EXPERIMENTS PAGE NO. SIGANTURE

CS6412/IT4211 MICROPROCESSOR AND MICROCONTROLLER

The student should be made to:

8086 Programs using kits and MASM

1. Basic arithmetic and Logical operations

Peripherals and Interfacing Experiments

7. Traffic light control

8051 Experiments using kits and MASM

14. Basic arithmetic and Logical operations

1. 16 BIT ADDITION AND SUBTRACTION.

8051 MICRO CONTROLLER

1. 8-BIT AND 16-BIT ADDITION.

MASM: (Microsoft assembler)

C:\MASM\BIN> Edit filename. asm

C:\MASM\BIN > Masm filename. asm X, Z

S.NO COMPONENTS SPECIFICATION QUANTITY

STEP 1: Start the program.

STEP 2: Get the input data‟s and stored it in registers.

STEP 3: Addition and subtraction operation is performed using sequence of

STEP 4: Store the CONCLUSIONs in separate memory locations

STEP 5: Stop the program

SAMPLE INPUT AND OUTPUT

SAMPLE INPUT AND OUTPUT

S.NO COMPONENTS SPECIFICATION QUANTITY

STEP 1: Start the program.

STEP 2: Get the input data‟s and stored it in registers.

STEP 3: Multiplication and division operation is performed using sequence of

STEP 4: Store the CONCLUSIONs in separate memory locations.

STEP 5: Stop the program

SAMPLE INPUT AND OUTPUT

SAMPLE INPUT AND OUTPUT

S.NO COMPONENTS SPECIFICATION QUANTITY

STEP 1: Start the program.

STEP 2: Load the count value in CX register.

STEP 3: Get the first two numbers.

STEP 5: Decrement count value.

STEP 7: Stop the program

S.NO COMPONENTS SPECIFICATION QUANTITY

STEP 1: Start the program.

STEP 2: Load the count value in CX register.

STEP 3: Get the first two numbers.

STEP 4: Compare the numbers and exchange if the number is small/large.

STEP 5: Decrement count value.

STEP 7: Stop the program.

S.NO COMPONENTS SPECIFICATION QUANTITY

STEP 1: Start the program.

STEP 2: Initialize the data segment (DS).

STEP 3: Load the count value in DX register.

STEP 4: Initialize the start of source string in the SI.

STEP 5: Initialize the start of destination string in the DI.

STEP 6: Move the byte from SI to DI, till DX=0.

STEP 7: Stop the program.

S.NO COMPONENTS SPECIFICATION QUANTITY

STEP 1: Start the program.

STEP 3: Move the string size to CX register

STEP 5: Move the bytes of string using MOVSB instruction.

STEP 6: Stop the program.