Ex. No.

16-BIT ARITHMETIC OPERATIONS

Date:

Aim:
To write an assembly language program to perform an addition, subtraction,
multiplication and division of two 16-bit numbers using 8086 microprocessor kit.

Algorithm:
16-Bit Addition

Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: Clear CL register to store the carry condition.
Step 3: Add the contents of BX to AX register and store the result in AX.
Step 4: Check carry flog, If CF = 0 then go to step 6.
Step 5: Increment CL register by 1.
Step 6: Store the contents of sum and carry to output memory locations.
Step 7: Stop the execution.

16-Bit Subtraction
Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: Clear CL register to store the carry condition.
Step 3: Subtract the contents of AX from BX register and store the result in AX.
Step 4: Check carry flog, If CF = 0 then go to step 6.
Step 5: Increment CL register by 1.
Step 6: Store the contents of sum and carry to output memory locations.
Step 7: Stop the execution.
16-Bit Multiplication
Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: Clear DX register to store the higher order product.
Step 3: Multiply the contents of BX with AX register and store the product in DX and AX.
Step 4: Store the contents of product to output memory locations.
Step 5: Stop the execution.
16-Bit Division
Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: Clear DX register to store the reminder.
Step 3: Divided the contents of BX from AX register and store the quotient in AX.
Step 4: Store the contents of reminder and quiescent to output memory locations.
Step 5: Stop the execution.

1
 16 Bit Addition
Memory Address Label Mnemonics Opcodes Comments
←
1000 H MOV AX, [1100 H] A1 (AX) [1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102 H] 8B (BX) ← [1102 H]
1004 H 1E
1005 H 02
1006 H 11
1007 H MOV CL, 00H B1 (CL) ← 00H
1008 H 00
1009 H ADD AX, BX 03 (AX) ← (AX) + (BX)
100A H C3
100B H JNC loop-1 73 If CF=0, then go to loop-1
100C H 02
100D H INC CL FE (CL) ← (CL) + 1
100E H C1
100F H loop-1 MOV [1200 H], AX A3 [1200 H] ← (AX)
1010 H 00
1011 H 12
1012 H MOV [1202 H], CL 88 [1202 H] ← (CL)
1013 H 0E
1014 H 02
1015 H 12
1016 H HLT F4 Stop the execution

16 Bit Subtraction
Memory Address Label Mnemonics Opcodes Comments
1000 H MOV AX, [1100 H] A1 (AX) ← [1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102 H] 8B (BX) ← [1102 H]
1004 H 1E
1005 H 02
1006 H 11
1007 H MOV CL, 00H B1 (CL) ← 00H
1008 H 00
1009 H SUB AX, BX 2B (AX) ← (AX) + (BX)
100A H C3
100B H JNC loop-1 73 If CF=0, then go to loop-1
100C H 02
100D H INC CL FE (CL) ← (CL) + 1
100E H C1
100F H loop-1 MOV [1200 H], AX A3 [1200 H] ← (AX)
1010 H 00
1011 H 12
1012 H MOV [1202 H], CL 88 [1202 H] ← (CL)
1013 H 0E
1014 H 02
1015 H 12
1016 H HLT F4 Stop the execution

2
 16 Bit Multiplication
Memory Address Label Mnemonics Opcodes Comments
←
1000 H MOV AX, [1100 H] A1 (AX) [ 1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102 H] 8B (BX) ← [ 1102 H]
1004 H 1E
1005 H 02
1006 H 11
1007 H MOV DX, 0000H BA (DX) ←0000H
1008 H 00
1009 H 00
100A H MUL BX F7 (DX:AX) ← (AX) * (BX)
100B H E3
100C H MOV [1200 H], AX A3 [1200 H] ← (AX)
100D H 00
100E H 12
100F H MOV [1202 H],DX 89 [1202 H] ← (DX)
1010 H 16
1011 H 02
1012 H 12
1013 H HLT F4 Stop the execution

16 Bit Division
Memory Address Label Mnemonics Opcodes Comments
1000 H MOV AX, [1100 H ] A1 (AX)←[ 1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102 H] 8B (BX) ← [ 1102 H]
1004 H 1E
1005 H 02
1006 H 11
1007 H MOV DX, 0000H BA (DX) ←0000H
1008 H 00
1009 H 00
100A H DIV BX F7 (DX:AX) ← (AX) / (BX)
100B H F3
100C H MOV [1200 H], AX A3 [1200 H] ← (AX)
100D H 00
100E H 12
100F H MOV [1202 H],DX 89 [1202 H] ← (DX)
1010 H 16
1011 H 02
1012 H 12
1013 H HLT F4 Stop the execution

3
 16 Bit Addition
INPUT OUTPUT
Address Data Address Data
1100H
1200 H
1101 H
1201 H
1102 H
1202 H
1103 H

16 Bit Subtraction
INPUT OUTPUT
Address Data Address Data
1100 H
1200 H
1101 H
1201 H
1102 H
1202 H
1103 H

16 Bit Multiplication
INPUT OUTPUT
Address Data Address Data
1100 H 1200 H
1101 H 1201 H
1102 H 1202 H
1103 H 1203 H

16 Bit Division
INPUT OUTPUT
Address Data Address Data
1100 H 1200 H
1101 H 1201 H
1102 H 1202 H
1103 H 1203 H

Result:

The above programs were successfully executed and results were verified.

4
 Ex. No.
16-BIT LOGICAL OPERATIONS
Date:

Aim:
To write an assembly language program to perform an an AND, OR, XOR and NOT
operations using 8086 microprocessor kit.

Algorithm:
16-Bit AND

Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: The contents of BX is AND with AX register and store the result in AX.
Step 3: Store the contents of AX to output memory location.
Step 4: Stop the execution

16-Bit OR

Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: The contents of BX is AND with AX register and store the result in AX.
Step 3: Store the contents of AX to output memory location.
Step 4: Stop the execution

16-Bit XOR

Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: The contents of BX is AND with AX register and store the result in AX.
Step 3: Store the contents of AX to output memory location.
Step 4: Stop the execution

16-Bit NOT

Step 1: Get two 16-bit data from the input memory locations to AX and BX registers.
Step 2: The content of AX is complimented with NOT operation and result is stored in AX
register
Step 3: Store the contents of AX to output memory location.
Step 4: Stop the execution

5
 16-Bit AND

Memory Address Label Mnemonics Opcodes Comments

1000 H MOV AX, [1100 H] A1 (AX) ← [1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102H] 8B (BX) ← [1102H]
1004 H 1E
1005 H 02
1006 H 11
1007 H AND AX, BX 23 (AX) ← (AX) ANDed (BX)
1008 H C3
1009 H MOV [1200 H], AX A3 [1200 H] ← (AX)
100A H 00
100B H 12
100C H HLT F4 Stop the execution

16-Bit OR

Memory Address Label Mnemonics Opcodes Comments

1000 H MOV AX, [1100 H] A1 (AX) ← [1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102H] 8B (BX) ← [1102H]
1004 H 1E
1005 H 02
1006 H 11
1007 H OR AX, BX 0B (AX) ← (AX) ORed (BX)
1008 H C3
1009 H MOV [1200 H], AX A3 [1200 H] ← (AX)
100A H 00
100B H 12
100C H HLT F4 Stop the execution

6
 16-Bit XOR

Memory Address Label Mnemonics Opcodes Comments

1000 H MOV AX, [1100 H] A1 (AX) ← [1100 H]
1001 H 00
1002 H 11
1003 H MOV BX, [1102H] 8B (BX) ← [1102H]
1004 H 1E
1005 H 02
1006 H 11
1007 H XOR AX, BX 33 (AX) ← (AX) XORed (BX)
1008 H C3
1009 H MOV [1200 H], AX A3 [1200 H] ← (AX)
100A H 00
100B H 12
100C H HLT F4 Stop the execution

16-Bit NOT

Memory Address Label Mnemonics Opcodes Comments

1000 H MOV AX, [1100 H] A1 (AX) ← [1100 H]
1001 H 00
1002 H 11
1003 H NOT AX F7 (AX) ← 1’s compliment of AX
1004 H D0
1005 H MOV [1200 H], AX A3 [1200 H] ← (AX)
1006 H 00
1007 H 12
1008 H HLT F4 Stop the execution

7
 16 Bit AND
INPUT OUTPUT
Address Data Address Data
1100H 1200 H
1101 H 1201 H
1102 H
1103 H

16 Bit OR
INPUT OUTPUT
Address Data Address Data
1100 H 1200 H
1101 H 1201 H
1102 H
1103 H

16 Bit XOR
INPUT OUTPUT
Address Data Address Data
1100 H 1200 H
1101 H 1201 H
1102 H
1103 H

16 Bit NOT
INPUT OUTPUT
Address Data Address Data
1100 H 1200 H
1101 H 1201 H
1102 H
1103 H

Result:

The above programs were successfully executed and results were verified.

8
 Ex. No.
MOVE A DATA BLOCK WITHOUT OVERLAP
Date:

Aim:
To write an assembly language program to move a data block without overlap using 8086
microprocessor kit.

ALGORITHM:

1. Initialize the pointer to memory where data to be transformed.

2. Load the al register with the data from memory

3. Initialize destination pointer to memory where data to be stored

4. Store data from al register.

PROGRAM:

ADDRESS LABEL OP CODE MNEMONICS COMMENTS

1000 B1 08 MOV CL,08 NUMBER OF BYTES TO BE
MOVED IN CL
1002 BE 00 14 MOV SI,1400 ADDRESS IN SI AS 1400 FOR
STORING DATA
1005 BF 50 14 MOV DI,1450 ADDRESS IN DI AS 1450 FOR
STORING RESULT
1008 loop: AC LODSB LOAD THE DATA IN AL
REGISTER
1009 88 05 MOV [DI],AL STORE THE RESULT IN
SPECIFIED LOCATION
100B 47 INC DI INCREMENT THE POINTER

100C FE C9 DEC CL DECREMENT THE COUNTER

100E 75 F8 JNE 1008 LOOP CONTINUES UNTIL

COUNTER IS ZERO
1010 CC INT 3 BREAKPOINT

9
INPUT:

ADDRESS INPUT DATA

1400 01
1401 02
1402 03
1403 04
1404 05
1405 06
1406 07
1407 08

OUTPUT:

ADDRESS INPUT DATA

1450 01
1451 02
1452 03
1453 04
1454 05
1455 06
1456 07
1457 08

Result:

The above programs were successfully executed and results were verified.

10
 Ex. No. CODE CONVERSION
Date:

Aim:
To write an assembly language program to code conversions between different number
systems using 8086 microprocessor kit.

HEXADECIMAL TO ASCII CODE

ALGORITHM:

1. Load the data in al register

2. Subtract 30h with al
3. If data is less than or equal to 16 terminate the program
4. Else subtract 7 from al
5. Result in al register

PROGRAM:

ADDRESS OP CODE MNEMONICS COMMENTS

0100 B0 31 MOV AL,31 GET DATA IN AL

0102 2C 30 SUB AL,30 SUBTRACT 30 WITH THE AL

0104 3C 10 CMP AL,10 IF DATA IS LESS THAN OR

EQUAL TO 16 GO TO 010C
0106 72 04 JB 010C CF=1,THEN JUMP 010C

0108 74 02 JZ 010C ZF=1,THEN JUMP 010C

010A 2C 07 SUB AL,07 ELSE SUBTRACT 7 FROM AL

010C CC INT3 BREAK POINT

INPUT:

AL = 31(HEX VALUE)

OUTPUT:

31 hexadecimal values 01 is the corresponding ASCII value

AX = 0001(ASCII VALUE)

11
 BCD TO HEXADECIMAL CONVERSION

ALGORITHM:

1. Load data in al register.

2. Separate higher nibble and lower nibble.
3. Get the higher nibble in lower nibble position.
4. Multiply al by 10
5. Add lower nibble
6. Store the result

PROGRAM:

ADDRESS OP CODE MNEMONICS COMMENTS

0100 B0 10 MOV AL,10 LOAD REGISTER AL WITH THE
DATA
0102 88 C4 MOV AH,AL AL VALUE MOVES TO AH

0104 80 E4 0F AND AH,0F MASK HIGHER BITS

0107 88 E3 MOV BL,AH AH VALUE MOVES TO BL

0109 24 F0 AND AL,F0 MASK LOWER BITS

010B B1 04 MOV CL,04 LOAD REGISTER CL WITH THE

DATA
010D D2 C8 ROR AL,CL ROTATE THE DATA FROM LAST
4BITS TO FIRST 4BITS
010F B7 0A MOV BH,0A 0A VALUE MOVES TO BH

0111 F6 E7 MUL BH MULTIPLY BY 10

0113 00 D8 ADD AL,BL ADD LOWER NIBBLE TO THE

MULTIPLIED DATA
0115 CC INT 3 BREAK POINT

INPUT:
10 is input value.
AL = 10.

OUTPUT:
The output value is stored in AX. AX = 000A.

12
 ASCII CODE TO HEXADECIMAL

ALGORITHM:

1. Load al with the data

2. If (al<=9) add 30
3. Else add 7 and 30
4. Result in al

PROGRAM:

ADDRESS OP CODE MNEMONICS COMMENTS

0100 B0 09 MOV AL,09 LOAD THE AL REGISTER WITH
DATA
0102 3C 09 CMP AL,09 IF DATA LESS THAN 9 ADD 30
TO THE DATA
0104 74 04 JZ 010A ZF=1,THEN JUMP 010A

0106 72 02 JB 010A ELSE ADD 7 AND ADD 30

WITH THE DATA
0108 04 07 ADD AL,07 AL<-AL+07

010A 04 30 ADD AL,30 AL<-AL+30

010C CC INT 3 BREAK POINT

INPUT:

AL = 09(ASCII VALUE) Input data

OUTPUT:

AX =0039(HEXADECIMAL VALUE) Output data.

13
 GRAY CODE CONVERSION (LOOK UP TABLE)

ALGORITHM:

1. Load the memory with truth table of gray codes.

2. Initialise pointer to memory for data and result
3. Load al with the data from memory
4. Convert gray code for that data
5. Store the result

ADDRESS OPCODE MNEMONICS COMMENTS

1000 BB 00 12 MOV BX,1200 ADDRESS IN BX AS 1200 FOR GRAY CODE
TABLE
1003 BE 50 11 MOV SI,1150 ADDRESS IN SI AS 1150 FOR STORING DATA

1006 AC LODSB LOAD THE ACCUMULATOR WITH THE

DATA
1007 D7 XLAT CHECK GRAYCODE FOR THAT DATA

1008 BF 51 11 MOV DI,1151 ADDRESS IN DI AS 1151 FOR STORING

RESULT
100B 88 05 MOV [DI],AL STORE THE GRAY CODE OF THE GIVEN
DATA
100D CC INT 3 BREAK POINT

INPUT: Data in 1150

OUTPUT: Result in 1151

LOOKUP TABLE: Starts from 1200

The look up table is provided by ex or of two bits in a byte

the value ranges from 00 to 0f

1200 00 01 03 02 06 07 05 04 0c 0d 0f 0e 0a 0b 09 08

Result:

The above programs were successfully executed and results were verified.

14
 Ex. No. DECIMAL ADDITION
Date:

Aim:
To write an assembly language program to perform decimal addition and subtraction ,
matrix addition and subtraction using 8086 microprocessor kit.

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1000 BE 00 11 MOV SI,1100 LOAD THE DATA INTO 16 BIT REG
AX FROM THE MEMORY 2000
1003 B1 00 MOV CL,00 00 MOVES TO CL
1005 8B 04 MOV AX,[SI] [SI] MOVES TO AX
1007 8B 5C 02 MOV BX,[SI+2] [SI+2] MOVES TO BX
100A 02 C3 ADD AL,BL AL<-AL+BL
100C 27 DAA DECIMAL ADJUST FOR ADDITION
100D 8A D0 MOV DL,AL AL VALUE MOVES TO DL
100F 8A C4 MOV AL,AH AH VALUE MOVES TO AL
1011 12 C7 ADC AL,BH AL<-AL+BH+CF
1013 27 DAA DECIMAL ADJUST FOR ADDITION

1014 8A F0 MOV DH,AL AL VALUE MOVES TO DH

1016 73 02 JNB 101A IF CF=0,THEN GO TO 101A

1018 FE C1 INC CL INCREMENT CL

101A AHEAD 89 54 04 MOV [SI+4],DX DX MOVES TO [SI+4]

101D 88 4C 06 MOV [SI+6],CL CL MOVES TO [SI+6]

1020 F4 HLT TERMINATE THE PROGRAM

15
RESULT:

INPUT:

DATA 1=

DATA 2=

OUTPUT:

DATA=

INPUT: OUTPUT:

MEMORY DATA MEMORY DATA

1100 1104
LOCATION
1101 LOCATION
1105
1102 1106
1103

16
 DECIMAL SUBTRACTION:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1000 BE 00 11 MOV SI,1100 LOAD THE DATA INTO 16 BIT REGISTER
SI FROM THE MEMORY 1100
1003 B1 00 MOV CL,00 00 MOVES TO CL
1005 8B 04 MOV AX,[SI] [SI] MOVES TO AX
1007 8B 5C 02 MOV BX,[SI+2] [SI+2] MOVES TO BX
100A 2A C3 SUB AL,BL AL= AL-BL
100C 2F DAS DECIMAL ADJUST FOR SUBTRACTION
100D 8A 00 MOV DL,AL AL VALUE MOVES TO DL
100F 8A C4 MOV AL,AH AH VALUE MOVES TO AL
1011 1A C7 SBB AL,BH BH VALUE MOVES TO AL
1013 2F DAS DECIMAL ADJUST FOR SUBTRACTION

1014 8A F0 MOV DH,AL AL VALUE MOVES TO DH

1016 73 02 JNC AHEAD IF CF=0,THEN GO TO 101A

1018 FE C1 INC CL INCREMENT CL

101A AHEAD 89 54 04 MOV [SI+4],DX DX MOVES TO [SI+4]

101D 88 4C 06 MOV [SI+6],CL CL MOVES TO [SI+6]

1020 F4 HLT TERMINATE THE PROGRAM

RESULT:
INPUT OUTPUT
INPUT: MEMORY DATA MEMORY DATA
DATA 1= 1100 1104
DATA 2= LOCATION
1101 LOCATION
1105
1102 1106
OUTPUT:
1103
DATA=

17
 MATRIX ADDITION:

ADDRESS LABEL OPCODE MNEMONICS

1000 BB 00 13 MOV BX,1300
1003 BD 00 14 MOV BP,1400
1006 BE 01 00 MOV SI,0001
1009 BF 01 15 MOV DI,1501
100C B1 09 MOV CL,09
100E REPEAT 8A 00 MOV AL,[BI+SI]
1010 02 02 ADD AL,[BP+SI]
1012 88 05 MOV [DI],AL
1014 46 INC SI
1015 47 INC DI
1016 E2 F6 LOOP REPEAT
1018 F4 HLT

18
INPUT:

MATRIX 1: MATRIX 2:

MEMORY DATA MEMORY DATA

1301
LOCATION 1401
1302 LOCATION
1402
1303 1403
1304 1404
1305 1405
1306 1406
1307 1407
1308 1408
1309 1409

OUTPUT:

MEMORY DATA
1501
LOCATION
1502
1503
1504
1505
1506
1507
1508
1509

19
 MATRIX SUBTRACTION:

ADDRESS LABEL OPCODE MNEMONICS

1000 BB 00 13 MOV BX,1300
1003 BD 00 14 MOV BP,1400
1006 BE 01 00 MOV SI,0001
1009 BF 01 15 MOV DI,1501
100C B1 09 MOV CL,09
100E REPEAT 8A 00 MOV AL,[BI+SI]
1010 1A 02 SBB AL,[BP+SI]
1012 88 05 MOV [DI],AL
1014 46 INC SI
1015 47 INC DI
1016 E2 F6 LOOP 100E
1018 F4 HLT

20
INPUT

MATRIX 1: MATRIX 2:

MEMORY DATA MEMORY DATA

1301 01 1401 F0
LOCATION
1302 02 LOCATION
1402 E1
1303 03 1403 D2
1304 04 1404 C3
1305 05 1405 B4
1306 06 1406 A5
1307 07 1407 96
1308 08 1408 87
1309 09 1409 78

OUTPUT:

MEMORY DATA
1501 11
LOCATION
1502 20
1503 30
1504 40
1505 50
1506 60
1507 70
1508 80
1509 90

Result:

The above programs were successfully executed and results were verified.

21
Ex. No.
SORTING
Date:

Aim:
To write an assembly language program to perform sorting and searching and string
manipulation using 8086 microprocessor kit.

ASCENDING ORDER

ALGORITHM:

1. Get the first data and compare with the second data
2. If the two data are in ascending order then no swap
3. Else swap the data byte by ascending order and then
again compare the other data bytes up to the count.

4. Do the above comparison as many times as the count.

5. Finally the array is arranged in ascending order.
INPUT: Enter the count in location 1200h

Enter the data in location starting from 1201h

OUTPUT: Result in ascending order in the location 1201h

22
 PROGRAM:

ADDRESS LABEL OP CODE MNEMONICS COMMENTS

1000 BE 00 12 MOV SI,1200H INPUT STORE IN 1200 MEMORY
LOCATION
1003 8A 0C MOV CL,[SI] NUMBER OF COMPARISONS IN CL

1005 JUMP4 BE 00 12 MOV SI,1200H INPUT STORE IN 1200 MEMORY

LOCATION
1008 8A 14 MOV DL,[SI] GET THE COUNT

100A 46 INC SI INCREMENT SI

100B 8A 04 MOV AL,[SI] FIRST DATA IN AL

100D JUMP3 46 INC SI INCREMENT SI

100E 8A 1C MOV BL,[SI] SECOND DATA IN BL

1010 38 D8 CMP AL,BL COMPARE AL ANDBL

1012 73 07 JNB 101B IF AL < BL GOTO JUMP1

1014 4E DEC SI DECREMENT SI

1015 88 04 MOV [SI],AL STORE THE SMALLEST DATA

1017 88 D8 MOV AL,BL BL MOVES TO THE AL

1019 EB 03 JMP 101E JUMP TO 001F

101B JUMP1 4E DEC SI DECREMENT SI

101C 88 1C MOV [SI],BL STORE THE GREATEST DATA IN

MEMORY
101E JUMP2 46 INC SI INCREMENT SI

101F FE CA DEC DL DECREMENT DL

1021 75 EA JNE 100D ZF=0,THEN GOTO 100D

1023 88 04 MOV [SI],AL AL VALUE MOVES TO THE [SI]

1025 FE C9 DEC CL DECREMENT CL

1027 75 DC JNE 1005 ZF=0,THEN GOTO 1005

1029 F4 HLT TERMINATE THE PROGRAM

23
RESULT:

MEMORY DATA
INPUT: 1200 06
LOCATION
1201 06
1202 05
1203 04
1204 03
1205 02
1206 01

OUTPUT:

MEMORY DATA
1200 06
LOCATION
1201 01
1202 02
1203 03
1204 04
1205 05
1206 06

24
 DESCENDING ORDER

ALGORITHM:

1. Get the first data and compare with the second data
2. If the two data are in descending order then no swap
3. Else swap the data byte by descending order and then
again compare the other data bytes up to the count.

4. Do the above comparison as many times as the count.

5. Finally the array is arranged in descending order.

INPUT: Enter the count in location 1200h

Enter the data in location starting from 1201h

OUTPUT: Result in descending order in the location 1201h

25
PROGRAM:

ADDRESS LABEL OP CODE MNEMONICS COMMENTS

1000 BE 00 12 MOV SI,1200H INPUT STORE IN 1200 MEMORY
LOCATION
1003 8A 0C MOV CL,[SI] NUMBER OF COMPARISONS IN CL

1005 JUMP4 BE 00 12 MOV SI,1200H INPUT STORE IN 1200 MEMORY

LOCATION
1008 8A 14 MOV DL,[SI] GET THE COUNT

100A 46 INC SI INCREMENT SI

100B 8A 04 MOV AL,[SI] FIRST DATA IN AL

100D JUMP3: 46 INC SI INCREMENT SI

100E 8A 1C MOV BL,[SI] SECOND DATA IN BL

1010 38 D8 CMP AL,BL COMPARE AL ANDBL

1012 72 07 JB 101B IF AL > BL GOTO JUMP1

1014 4E DEC SI DECREMENT SI

1015 88 04 MOV [SI],AL STORE THE GREATEST DATA

1017 88 D8 MOV AL,BL BL MOVES TO THE AL

1019 EB 03 JMP 101E JUMP TO 001F

101B JUMP1: 4E DEC SI DECREMENT SI

101C 88 1C MOV [SI],BL STORE THE SMALLEST DATA IN

MEMORY
101E JUMP2: 46 INC SI INCREMENT SI

101F FE CA DEC DL DECREMENT DL

1021 75 EA JNE 100D ZF=0,THEN GOTO 100D

1023 88 04 MOV [SI],AL AL VALUE MOVES TO THE [SI]

1025 FE C9 DEC CL DECREMENT CL

1027 75 DC JNE 1005 ZF=0,THEN GOTO 1005

1029 F4 HLT INTERRUPT

26
RESULT:

INPUT: OUTPUT:

MEMORY DATA MEMORY DATA

1200 06 1200 06

LOCATION
1201 01 LOCATION
1201 06

1202 02 1202 05

1203 03 1203 04

1204 04 1204 03

1205 05 1205 02

1206 06 1206 01

27
 SEARCHING

ALGORITHM:

1. Initialize pointer to memory for storing data and result.

2. Load dl with search byte

3. Load cl with count

4. Load al with data from memory

5. Compare al with dl if its equal store the result

else decrement counts go to step2

6. Store the result.

INPUT: Search the byte 0A in 50 location from 1200.

OUTPUT: Store the byte in 1300

28
 PROGRAM:

ADDRESS LABEL OP CODE MNEMONICS COMMENTS

1500 BF 00 13 MOV DI,1300 ADDRESS IN DI AS 1300 FOR STORING RESULT

1503 BE 00 12 MOV SI,1200 ADDRESS IN SI AS 1200 FOR STORING DATA

1506 B1 50 MOV CL,50 LOAD CL REGISTER WITH THE COUNT

1508 B2 0A MOV DL,0AH SEARCHING FOR A STRING 0A

150A LOOP1: AC LODSB LOAD WITH THE DATA IN AL

150B 38 C2 CMP DL,AL COMPARE AL ANDBL

150D 74 05 JE 1514 ZF=1,THEN GO TO 1514

150F FE C9 DEC CL IF THE SEARCH IS SUCCESSFUL STORE THE

BYTE
1511 75 F7 JNE 150A ZF=0,THEN GO TO 150A

1513 F4 HLT TERMINATE THE PROGRAM

1514 BREAK 88 05 MOV[DI],AL AL VALUE MOVES TO THE [DL]

1516 : 4E DEC SI DECREMENT SI

1517 89 F3 MOV BX,SI STORE THE MEMORY POSITION

1519 47 INC DI INCREMENT DI

151A 88 1D MOV [DI],BL AL VALUE MOVES TO THE [DI]

151C 47 INC DI INCREMENT DI

151D 88 3D MOV[DI],BH BH VALUE MOVES TO THE [DI]

151F CC INT 3 INTERRUPT

INPUT: OUTPUT:

ADDRESS DATA ADDRESS DATA

1200 91 1300 0A
1201 02
1202 0A
1203 04
1204 09

29
 STRING MANIPULATION

MOVING BLOCK OF DATA FROM ONE MEMORY LOCATION TO ANOTHER

MEMORY LOCATION:

ADDRESS OPCODE MNEMONICS COMMENTS

1000 BE 00 20 MOV SI,2000 LOAD THE DATA INTO 16 BIT REGISTER
AX FROM THE MEMORY 2000
1003 BF 08 20 MOV DI,2008 LOAD THE DATA INTO 16 BIT REGISTER
AX FROM THE MEMORY 2008
1006 B9 08 00 MOV CX,0008 PUTS VALUE 0008 ON REGISTER CX
1009 FC CLD CLEAR DIRECTION FLAG

100A F3 A4 REP MOVSB MOVE BYTE AT ADDRESS DS:(E)SI TO

ADDRESS ES:(E)DI
100A CC INT3 BREAKPOINT

RESULT:

INPUT: OUTPUT:

ADDRESS DATA ADDRESS DATA

2000 01 2008 01
2001 02 2009 02
2002 03 200A 03
2003 04 200B 04
2004 05 200C 05
2005 06 200D 06
2006 07 200E 07
2007 08 200F 08

30
REVERSE OF A DATA:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1000 BE 00 20 MOV SI,2000 LOAD THE DATA INTO 16 BIT
REGISTER AX FROM THE
1003 BF 08 20 MOV DI,2008 MEMORY
LOAD THE2000
DATA INTO 16 BIT
REGISTER AX FROM THE
1006 B9 08 00 MOV CX,0008 MEMORY
PUTS 20080008 ON REGISTER
VALUE
CX
1009 83 C6 07 ADD SI,07 SI<-SI+07

100C UP 8A 04 MOV AL,[SI] [SI] MOVES TO AL

100E 88 05 MOV [DI],AL AL MOVES TO [DI]
1010 4E DEC SI DECREMENT SI
1011 47 INC DI INCREMENT DI
1012 49 DEC CX DECREMENT CX

1013 75 F7 JNE 100C IF ZF=0,GO TO 100C

1015 CC INT3 BREAKPOINT

RESULT:

INPUT: OUTPUT:

MEMORY DATA MEMORY DATA

2000 01 2008 08
LOCATION
2001 02 LOCATION
2009 07
2002 03 200A 06
2003 04 200B 05
2004 05 200C 04
2005 06 200D 03
2006 07 200E 02
2007 08 200F 01

31
PASSWORD CHECKING PROGRAM:

ADDRESS OPCODE MNEMONICS COMMANDS

2000 B0 05 MOV AL,05 05 Moves To AL

2002 B3 05 MOV BL,05 05 Move To BL

2004 38 D8 CMP AL,BL Compare The AL And BL

2006 74 02 JE 200A AL,BL Equal Jump To 200A

2008 EB F6 JMP 2000 Not Equal Jump To 2000

200A B8 02 00 MOV AX,0002 0002 Move To AX

200D BB 04 00 MOV BX,0004 0004 Move To BX

2010 01 D8 ADD AX,BX Add AX And BX Result Will Be Stored

In AX
2012 CC INT 3 Break Point

Enter your password in 2001 location.

Re enter your password in 2003 location.

If the give password is same in the both locations then the addition program will be executed

and the output is stored in AX register.

The output is AX=0006.

If the give password is not equal then the program will be not executed.

32
 COUNTERS AND TIME DELAY PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS

1000 START BE 00 12 MOV SI,1200
1003 BA FF 0F MOV DX,0FFF
1006 B4 0F MOV AH,0F
1008 LOOP1 42 INC DX
1009 8A 04 MOV AL,[SI]
100B 46 INC SI
100C 38 C4 CMP AH,AL
100E 73 F8 JNB 1008
1010 89 16 00 11 MOV [1100],DX
1014 CC INT 3

RESULT: OUTPUT:

MEMORY DATA
1200
LOCATION 01
MEMORY DATA
1201 02
1100
LOCATION 05
1202 03
1203 04
1204 06

Result:

The above programs were successfully executed and results were verified.

33
 Ex. No.
TRAFFIC LIGHT CONTROLLER
Date:

Aim:
To write an assembly language program for traffic light controller.

TRAFFIC LIGHT PROGRAM IN 8086:

ADDRESS LABEL OPCODE MNEMONICS

1000 B0 80 MOV AL,80
1002 BA 26 FF MOV DX,FF26
1005 EE OUT DX,AL

FOR STARTING VEHICLES IN N-S DIRECTION (STRAIGHT) AND PEDESTRAIN

STOPPING:

ADDRESS LABEL OPCODE MNEMONICS

1006 B0 0F MOV AL,0F
1008 BA 22 FF MOV DX,FF22
100B EE OUT DX,AL
100C B0 4D MOV AL,4D
100E BA 20 FF MOV DX,FF20
1011 EE OUT DX,AL
1012 E8 75 00 CALL 108A
1015 E8 65 00 CALL 107D

34
FOR STOPPING VEHICLES IN N-S DIRECTION AND STARTING IN E-W DIRECTION:

ADDRESS LABEL OPCODE MNEMONICS

1018 B0 8B MOV AL,8B
101A BA 20 FF MOV DX,FF20
101D EE OUT DX,AL
101E E8 69 00 CALL 108A
1021 E8 59 00 CALL 107D

FOR RIGHT TURN IN N-S SIDES AND STOPPING E-W SIDES:

ADDRESS LABEL OPCODE MNEMONICS

1024 B0 49 MOV AL,49
1026 BA 20 FF MOV DX,FF20
1029 EE OUT DX,AL
102A B0 01 MOV AL,01
102C BA 24 FF MOV DX,FF24
102F EE OUT DX,AL
1030 E8 57 00 CALL 108A
1033 B0 00 MOV AL,00
1035 BA 24 FF MOV DX,FF24
1038 EE OUT DX,AL
1039 E8 41 00 CALL 107D

35
STOPPING RIGHT TURN IN N-S SIDES AND STARTING RIGHT TURN IN E-W SIDES:

ADDRESS LABEL OPCODE MNEMONICS

103C B0 89 MOV AL,89
103E BA 20 FF MOV DX,FF20
1041 EE OUT DX,AL
1042 B0 02 MOV AL,02H
1044 BA 24 FF MOV DX,FF24
1047 EE OUT DX,AL
1048 E8 3F 00 CALL 108A
104B B0 00 MOV AL,00
104D BA 24 FF MOV DX,FF24
1050 EE OUT DX,AL
1051 B0 30 MOV AL,30
1053 BA 20 FF MOV DX,FF20
1056 EE OUT DX,AL
1057 B9 04 00 MOV CX,0004
105A E8 34 00 CALL 1091

36
FOR STARTING PEDESTRAIN:

ADDRESS LABEL OPCODE MNEMONICS

105D B0 C0 MOV AL,C0
105F BA 20 FF MOV DX,FF20
1062 EE OUT DX,AL
1063 B0 F0 MOV AL,F0
1065 BA 22 FF MOV DX,FF22
1068 EE OUT DX,AL
1069 B9 10 00 MOV CX,0010
106C E8 22 00 CALL 1091
106F B0 30 MOV AL,30
1071 BA 20 FF MOV DX,FF20
1074 EE OUT DX,AL
1075 B9 08 00 MOV CX,0008
1078 E8 16 00 CALL 1091
107B EB 89 JMP 1006

AMBER:

ADDRESS LABEL OPCODE MNEMONICS

107D B0 39 MOV AL,39
107F BA 20 FF MOV DX,FF20
1082 EE OUT DX,AL
1083 B9 08 00 MOV CX,0008
1086 E8 08 00 CALL 1091
1089 C3 RET

37
DELAY:

ADDRESS LABEL OPCODE MNEMONICS

108A DELAY B9 40 00 MOV CX,0040
108D E8 01 00 CALL 1091
1090 C3 RET

DELAY SUBROUTINE:

ADDRESS LABEL OPCODE MNEMONICS

1091 BB FF 00 MOV BX,00FF
1094 B8 FF 00 MOV AX,00FF
1097 90 NOP
1098 48 DEC AX
1099 75 FC JNE 1097
109B 4B DEC BX
109C 89 D8 MOV AX,BX
109E 75 F4 JNE 1094
10A0 09 C8 OR AX,CX
10A2 74 00 JE 10A4
10A4 49 DEC CX
10A5 75 EA JNE 1091
10A7 C3 RET

Result:

The above programs were successfully executed and results were verified.

38
 Ex. No.
STEPPER MOTOR INTERFACE
Date:

Aim:
To write an assembly language program for stepper motor interface.

8086 STEPPER MOTOR PROGRAM

MAIN: CLOCK WISE DIRECTION:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

Load The Dx With The
1000 BA 26 FF MOV DX,FF26
Add Cntr.Reg
Control Word For
1003 B0 80 MOV AL,80
Enabling The Ports
Move The Control Word
1005 EE OUT DX,AL
Cntr.Reg
Move The Address Of
1006 LOOP1 BA 20 FF MOV DX,FF20
Port A To Dx
1009 B0 05 MOV AL,05 1st Sequence Data
100B EE OUT DX,AL Out It In Port A
100C E8 F1 00 CALL 1100 Call Delay Subroutine
100F B0 07 MOV AL,07 2nd Sequence Data
1011 EE OUT DX,AL Out It In Port A
1012 E8 EB 00 CALL 1100 Call Delay Subroutine
1015 B0 06 MOV AL,06 3rd Sequence Data
1017 EE OUT DX,AL Out It In Port
1018 E8 E5 00 CALL 1100 Call Delay Subroutine
101B B0 04 MOV AL,04 4th Sequence Data
101D EE OUT DX,AL Out It In Port A
101E E8 DF 00 CALL 1100 Call Delay Subroutine
1021 EB E3 JMP 1006(LOOP1) Jump To Start

39
ANTI CLOCK WISE DIRECTION:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

Load The Dx With The
2000 BA 26 FF MOV DX,FF26
Add Cntr.Reg
Control Word For
2003 B0 80 MOV AL,80
Enabling The Ports
Move The Control Word
2005 EE OUT DX,AL
Cntr.Reg
Move The Address Of
2006 LOOP2 BA 20 FF MOV DX,FF20
Port A To Dx
2009 B0 04 MOV AL,04 1st Sequence Data
200B EE OUT DX,AL Out It In Port A
200C E8 F1 F0 CALL 1100 Call Delay Subroutine
200F B0 06 MOV AL,06 2nd Sequence Data
2011 EE OUT DX,AL Out It In Port A
2012 E8 EB F0 CALL 1100 Call Delay Subroutine
2015 B0 07 MOV AL,07 3rd Sequence Data
2017 EE OUT DX,AL Out It In Port
2018 E8 E5 F0 CALL 1100 Call Delay Subroutine
201B B0 05 MOV AL,05 4th Sequence Data
201D EE OUT DX,AL Out It In Port A
201E E8 DF F0 CALL 1100 Call Delay Subroutine
2021 EB E3 JMP 2006(LOOP2) Jump To Start

40
DELAY SUBROUTINE:

ADDRESS LABEL OPCODE MNEMONICS

1100 BB 10 00 MOV BX,0010

1103 LOOP3 B0 FF MOV AL,FF

1105 LOOP4 90 NOP
1106 90 NOP
1107 90 NOP
1108 90 NOP
1109 FE C8 DEC AL
110B 75 F8 JNE 1105(LOOP4)
110D 4B DEC BX
110E 75 F3 JNE 1103(LOOP3)
1110 C3 RET

Result:

The above programs were successfully executed and results were verified.

41
 Ex. No.
DIGITAL CLOCK
Date:

Aim:
To write an assembly language program for digital clock.

DIGITAL CLOCK PROGRAM IN 8086: MAIN PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS

1000 BA 26 FF MOV DX,FF26
1003 B4 00 MOV AH,00
1005 B0 80 MOV AL,80
1007 EE OUT DX,AL
1008 L1 B5 00 MOV CH,00
100A B1 00 MOV CL,00
100C L2 BA 22 FF MOV DX,FF22
100F 88 C8 MOV AL,CL
1011 EE OUT DX,AL
1012 BA 20 FF MOV DX,FF20
1015 88 E8 MOV AL,CH
1017 EE OUT DX,AL
1018 E8 E5 0F CALL 2000(SECONDS)
101B FE C1 INC CL
101D 88 C8 MOV AL,CL
101F E8 DE 01 CALL 1200(CON IN MIN)
1022 3C 60 CMP AL,60
1024 73 02 JNB 1028(L3)
1026 EB E4 JMP 100C(L2)
1028 L3 FE C5 INC CH

42
 102A B1 00 MOV CL,00
102C 88 E8 MOV AL,CH
102E E8 DF 01 CALL 1210(CON IN HRS)
1031 3C 24 CMP AL,24
1033 73 D3 JNB 1008(L1)
1035 EB D5 JMP 100C(L2)

PROGRAM IN SECONDS:

ADDRESS LABEL OPCODE MNEMONICS

2000 B2 00 MOV DL,00
2002 LOOP1 E8 FB F0 CALL 1100
2005 FE C2 INC DL
2007 88 D0 MOV AL,DL
2009 3C 60 CMP AL,60
200B 73 02 JNB 200F(LOOP2)
200D EB F3 JMP 2002(LOOP 1)
200F LOOP 2 C3 RET

DECIMAL CONVERTER PROGRAM IN MINUTES:

ADDRESS LABEL OPCODE MNEMONICS

1200 2C 01 SUB AL,01
1202 04 01 ADD AL,01
1204 27 DAA
1205 88 C1 MOV CL,AL
1207 C3 RET

43
DECIMAL CONVERTER PROGRAM IN HOURS:

ADDRESS LABEL OPCODE MNEMONICS

1210 2C 01 SUB AL,01
1212 04 01 ADD AL,01
1214 27 DAA
1215 88 C5 MOV CH,AL
1217 C3 RET

DELAY PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS

1100 BB FF 01 MOV BX,01FF
1103 LOOP 3 B0 DF MOV AL,DF
1105 LOOP 4 90 NOP
1106 90 NOP
1107 90 NOP
1108 90 NOP
1109 FE C8 DEC AL
110B 75 F8 JNE 1105(LOOP 4)
110D 4B DEC BX
110E 75 F3 JNE 1103(LOOP 3)
1110 C3 RET

Result:

The above programs were successfully executed and results were verified.

44
 Ex. No.
KEYBOARD AND DISPLAY INTERFACE
Date:

Aim:
To write an assembly language program for keyboard and display interface

INTERFACING HEX KEYBOARD WITH 8086 KIT:

This program is used to interface an external hex keypad with MP-86L kit. Input clock to 8279 is
3MHZ. The program waits for a key to be entered from the keypad and the row and column
matrix of the depressed key is stored in Acc register.

16 Keys are arranged in 4 X 4 matrix. Their scan codes are as follows

21H 22H 23H 24H

19H 1AH 1BH 1CH
11H 12H 13H 14H
09H 0AH 0BH OCH

I/O PORT ADDRESSES FOR 8279 :

FF50H - Data Register

FF52H - Status Register

OUTPUT: scan code of the depressed key is at Acc

45
8086 KEYBOARD PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1000 B0 12 MOV AL,12H Control Word
1002 BA 52 FF MOV DX,FF52H Control & Status Reg
1005 EE OUT DX,AL Out To 8279
1006 B0 3E MOV AL,3EH For Freq Division
1008 EE OUT DX,AL Out To 8279
1009 B0 A0 MOV AL,A0H Display/Write Inhibit
100B EE OUT DX,AL Out To 8279
100C L1 EC IN AL,DX Read Status Of 8279
100D 24 01 AND AL,01H Fifo Empty?
100F 74 FB JE 100CH(L1) If Yes Loop Back
1011 BA 50 FF MOV DX,FF50H Character Is Available
1014 EC IN AL,DX Read Code From Data Port
1015 24 3F AND AL,3FH Supress Unwanted Bits
1017 CC INT 3 Break Point

46
INTERFACING 7 SEGMENT DISPLAY WITH 8086 KIT

This program is will display the character for the given 7 segment code on all the digits of the display.

INPUT: Enter the seven segment code at 2000h.

For example - 2000: BA (seven segment code for 2)

I/O PORT ADDRESSES FOR 8279 :

FF52H - Data Register

FF50H - Status Register

7 SEGMENT CODES FOR 0 TO F:

FC 60 BA F2 66 D6 DE 70 FE 76 7E CE 9C EA 9E 1E

7 SEGMENT CODE FORMAT:

Char D C B A E F G H Hex code

0 1 1 1 1 1 1 0 0 FC
1 0 1 1 0 0 0 0 0 60
a

f b

e c

d .h

47
8086 DISPLAY PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1050 B0 12 MOV AL,12H Control Word
1052 BA 52 FF MOV DX,FF52H Control & Status Reg
1055 EE OUT DX,AL Out To 8279
1056 B0 3E MOV AL,3EH For Freq Division
1058 EE OUT DX,AL Out To 8279
1059 B0 A0 MOV AL,A0H Display/Write Inhibit
105B EE OUT DX,AL Out To 8279
105C B4 08 MOV AH,08H Count Of 8 For Clearing Dis.
105E BA 50 FF MOV DX,FF50H Data Register Address
1061 B0 00 MOV AL,00H Data =0
1063 L1 EE OUT DX,AL Out To 8279
1064 FE CC DEC AH Decrement Loop Count
1066 75 FB JNE 1063H(L1) Wait Till Zero
1068 L2 BA 52 FF MOV DX,FF52H Status Register Address
106B EC IN AL,DX Read Status Of 8279
106C L3 24 01 AND AL,01H Fifo Empty?
106E 74 FC JE 106CH(L3) If Yes Loop Back
1070 BA 50 FF MOV DX,FF50H Data Register Address
1073 BB 00 20 MOV BX,2000H Data I/P Address
1076 8A 07 MOV AL,[BX] Read The Input Code
1078 EE OUT DX,AL To 8279 Data Register
1079 EB ED JMP 1068H(L2) Jmp L2

Result:

The above programs were successfully executed and results were verified.

48
 Ex. No.
PRINTER INTERFACE
Date:

Aim:
To write an assembly language program for printer interface.

8086 PRINTER PROGRAM

LOOP1:
ADDRESS OPCODE MNEMONICS COMMENTS
1000 BE 00 20 MOV SI,2000H Start Address Of Message String
1003 B8 00 00 MOV AX,0000H Initialize The Ds To 0000h
1006 8E D8 MOV DS, AX
1008 BA 26 FF MOV DX, FF26H Control Register Address
100B B0 82 MOV AL, 82H Initialize 8255 With Port A & Port C
100D EE OUT DX, AL As Output And Port B As Input
100E BA 24 FF MOV DX, FF24H Port C Address
1011 B0 07 MOV AL, 07H For Making Strobe, Auto feed And Int
High
1013 EE OUT DX, AL To Port C
1014 E8 0A 00 CALL 1021 Print One Character
1017 8A 04 MOV AL,[SI] Get The Char To Al
1019 3C 0D CMP AL,0DH Check For Cr
101B 75 01 JNE 101E If True Terminate The Program
101D CC INT 3

LOOP2:

101E 46 INC SI Else Get The Next Char

101F EB F3 JMP 1014 Continue Print
PRINT:

1021 BA 22 FF MOV DX,FF22H Port B Address

49
LOOP3:

1024 EC IN AL,DX Get The Printer Status

1025 24 02 AND AL, 02H Check The Pb2 Bit(Busy)Status
1027 75 FB JNE 1024 If Busy Then Wait
1029 8A 04 MOV AL,[SI] Else Get The Char From Memory
102B BA 20 FF MOV DX,0FF20H Port A Address
102E EE OUT DX,AL Out The Char To Port A
102F B0 04 MOV AL,04 To Make The Strobe Signal To Low
1031 BA 24 FF MOV DX,0FF24H Port C Address
1034 EE OUT DX,AL Out To Port C
1035 90 NOP
1036 90 NOP
1037 B0 05 MOV AL,05 Make Strobe Back To High
1039 EE OUT DX,AL Out To Port C
103A C3 RET Return

ADDRESS OPCODE
2000
2004
2008
WELCOME TO MICROPROCESSOR &
200C
MICROCONTROLLER LAB
2010
2014
2018

Result:

The above programs were successfully executed and results were verified.

50
Ex. No.
SERIAL AND PARALLEL INTEREFACE
Date:

Aim:
To write an assembly language program for serial and parallel interface.
8251 PROGRAM IN 8086[BOARD] TRANSMIT:

ADDRESS OPCODE MNEMONICS COMMENTS

2000 B8 78 00 MOV AX,0078H BAUD COUNT
2003 E8 1C 00 CALL 2022 AX CONTAIN TIMER COUNT
2006 8A C3 MOV AL,BL BL – CONTAIN THE BYTE TO BE TX
2008 E8 03 00 CALL 200E TX ONE BYTE TO PC
200B EB F9 JMP 2006 JUMP 2006
200D CC INT 3 INTERRUPT 3
200E E8 3D 00 CALL 204E CALL SUBROUTINE 204E
2011 8A D8 MOV BL,AL SAVE THE BYTE
2013 BA 12 FF(62 FF) MOV DX,FF12 STATUS REG
2016 EC IN AL,DX GET THE STATUS BYTE
2017 24 01 AND AL,01 CHECK THE READY BIT
2019 74 FB JE 2016 IF ZF=1,THEN JUMP TO 2016
201B 8A C3 MOV AL,BL RESTORE THE BYTE TO AL
201D BA 10 FF(60 FF) MOV DX,FF10 MODE REG
2020 EE OUT DX,AL TX THE BYTE
2021 C3 RET RETURN
2022 8B C8 MOV CX,AX SAVE THE COUNT IN CX
2024 B0 37 MOV AL,37 COUNTER-0 IS SELECTED
2026 BA06 FF(50 FF) MOV DX,FF06 FF06 CONTROL REG
2029 EE OUT DX,AL MOVES DATA FROM AL TO DX
202A 8A C1 MOV AL,CL COUNT LSB
202C BA 00 FF(50 FF) MOV DX,FF00 COUNTER-0 REG
202F EE OUT DX,AL MOVES DATA FROM AL TO DX
2030 8A C5 MOV AL,CH COUNT MSB
2032 EE OUT DX,AL MOVES DATA FROM AL TO DX
2033 90 NOP NO OPERATION

51
2034 90 NOP NO OPERATION
2035 BA 12 FF(62 FF) MOV DX,FF12 FF12 STATUS REGISTER
2038 B0 00 MOV AL,00 DUMMY MODE WORD
203A EE OUT DX,AL MOVES DATA FROM AL TO DX
203B EE OUT DX,AL MOVES DATA FROM AL TO DX
203C EE OUT DX,AL MOVES DATA FROM AL TO DX
203D B0 40 MOV AL,40 RESET WORD
203F EE OUT DX,AL MOVES DATA FROM AL TO DX
2040 E8 0B 00 CALL 204E CALL SUBROUTINE 204E
2043 B0 4E MOV AL,4E 0100 1110
2045 EE OUT DX,AL ONE STOP BIT, NO PARITY, 8BITS CHAR
2046 90 NOP NO OPERATION
2047 90 NOP NO OPERATION
2048 B0 27 MOV AL,27 ENABLE TX
204A EE OUT DX,AL MOVES DATA FROM AL TO DX
204B 90 NOP NO OPERATION
204C 90 NOP NO OPERATION
204D C3 RET RETURN
204E 53 PUSH BX STORE THE VALUE ON TO BX
204F BB FF 04 MOV BX,04FF 04FF MOVES TO BX
2052 90 NOP NO OPERATION
2053 90 NOP NO OPERATION
2054 4B DEC BX DECREMENT BX
2055 75 FB JNE 2052 IF ZF=0,THEN GO TO 2052
2057 5B POP BX REMOVE THE VALUE FROM BX
2058 C3 RET RETURN

52
8251 PROGRAM IN 8086[BOARD] RECEIVE::

ADDRESS OPCODE MNEMONICS COMMENTS

1000 B8 78 00 MOV AX,0078H BAUD COUNT
1003 E8 11 00 CALL 1017 INITIALIZE THE TIMER AND USART
1006 E8 01 00 CALL 100A RX ONE BYTE
1009 CC INT 3 INTERRUPT 3
100A BA 12 FF(62 FF) MOV DX,FF12 FF12 STATUS REGISTER
100D EC IN AL,DX MOVES DATA FROM I/O PORT TO AL
100E 24 02 AND AL,02 LOGICAL AND OPERATION
1010 74 FB JE 100D IF ZF=1,THEN JUMP TO 100D
1012 BA 10 FF(60 FF) MOV DX,FF10 FF10 MOVES TO DX
1015 EC IN AL,DX MOVES DATA FROM I/O PORT TO AL
1016 C3 RET RETURN
1017 8B C8 MOV CX,AX SAVE THE COUNT IN CX
1019 B0 37 MOV AL,37 COUNTER 0 IS SELECTED
101B BA FF 06(50FF) MOV DX,06FF 06FF CONTROL REG
101E EE OUT DX,AL MOVES DATA FROM AL TO DX
101F 8A C1 MOV AL,CL COUNT LSB
1021 BA 00 FF(50 FF) MOV DX,FF00 FF00 COUNTER 0 REG
1024 EE OUT DX,AL MOVES DATA FROM AL TO DX
1025 8A C5 MOV AL,CH COUNT MSB
1027 EE OUT DX,AL MOVES DATA FROM AL TO DX
1028 90 NOP NO OPERATION
1029 90 NOP NO OPERATION
102A BA 12FF(62 FF) MOV DX,FF12 FF12 STATUS REGISTER
102D B0 00 MOV A1,00 DUMMY MODE WORD
102F EE OUT DX,AL MOVES DATA FROM AL TO DX
1030 EE OUT DX,AL MOVES DATA FROM AL TO DX

53
1031 EE OUT DX,AL MOVES DATA FROM AL TO DX
1032 B0 40 AL,40H RESET WORD
1034 EE OUT DX,AL MOVES DATA FROM AL TO DX
1035 E8 0B 00 CALL 1043 CALL SUBROUTINE 1043
1038 B0 4E MOV AL,4E 01 00 11 10
103A EE OUT DX,AL ONE STOPBIT,NO PARITY,8BITS CHAR
103B 90 NOP NO OPERATION
103C 90 NOP NO OPERATION
103D B0 27 MOV AL,27 ENABLE TX
103F EE OUT DX,AL MOVES DATA FROM AL TO DX
1040 90 NOP NO OPERATION
1041 90 NOP NO OPERATION
1042 C3 RET RETURN
1043 53 PUSH BX STORE THE VALUE ON TO BX
1044 BB FF 04 MOV BX,04FFH 04FF MOVES TO BX
1047 90 NOP NO OPERATION
1048 90 NOP NO OPERATION
1049 4B DEC BX DECREMENT BX
104A 75 FB JNE 1047 IF ZF=0,THEN GO TO 1047
104C 5B POP BX REMOVE THE VALUE FROM BX
104D C3 RET RETURN

54
INPUT: OUTPUT:

In Transmitter In Receiver

RBX = 0042 Execute the Program

Execute the Program G1000

G1000 Get the Result RBX = 0042

PARALLEL COMMUNICATION BETWEEN TWO MP KITS USING MODE 1 AND MODE 2 OF 8255.

PARALLEL PORT PROGRAM: 8086 TRANSMIT:

1000 BA 26 FF MOV DX,FF26 MOVE CONTROL REG ADDRESS

1003 B0 80 MOV AL,80 CONTROL WORD

1005 EE OUT DX,AL MOVE CONTRL WORD TO CNTRL REG

1006 BA 20 FF MOV DX,FF20 MOVE PORT A ADDRESS

1009 B0 1A MOV AL,1A CHANGE THE VALUE

100B EE OUT DX,AL MOVE CONTRL WORD TO CNTRL REG

100C CC INT 3 END THE PROGRAM

55
RECEIVE:

ADDRESS OPCODE MNEMONICS COMMENTS

1000 BA 26 FF MOV DX,FF26 MOVE CONTROL REG ADDRESS

1003 B0 90 MOV AL,90 CONTROL WORD

1005 EE OUT DX,AL MOVE CONTRL WORD TO CNTRL REG

1006 BA 20 FF MOV DX,FF20 MOVE PORT A ADDRESS

1009 EC IN AL,DX GET THE PORT A

100A CC INT 3 END THE PROGRAM

MODE: 1 change the control word: D4 (1004)

MODE: 2 change the control word: D2 (1004)

INPUT: OUTPUT:

Transmit: Receive:

A = 1A (Set the input value in 100A) A = 1A.

Result:

The above programs were successfully executed and results were verified.

56
 Ex. No.
ADC AND DAC INTERFACE
Date:

Aim:
To write an assembly language program for ADC and DAC.

8086 ADC PROGRAM:

ADDRES LABEL OPCODE MNEMONICS COMMENTS

S
1000 BA 26 FF MOV DX,FF26H OUT IT IN CONTROL REG
1003 B0 90 MOV AL,90H CWR FOR PORT A AS I/P PORT B
AND PORT C AS O/P
1005 EE OUT DX,AL MOVE THE CONTROL WORD
CNTR.REG
1006 BA 24 FF MOV DX,FF24H PORT C IS ENABLED FOR WR
1009 B0 FF MOV AL,FFH START OF CONVERSION
100B EE OUT DX,AL MOVE THE CONTROL WORD
CNTR.REG
100C B0 00 MOV AL,00H 00 VALUE MOVES TO AL
100E EE OUT DX,AL MOVE THE CONTROL WORD
CNTR.REG
100F B0 FF MOV AL,FFH FF VALUE MOVES TO AL
1011 EE OUT DX,AL MOVE THE CONTROL WORD
CNTR.REG
1012 E8 EB 00 CALL 1100H DELAY ROUTINE
1015 BA 20 FF MOV DX,FF20H PORTA AS I/P
1018 EC IN AL,DX READ THE ADC VALUE
1019 CC INT 3 BREAK POINT

57
 DELAY SUBROUTINE:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1100 B9 FF FF MOV CX,FFFFH DELAY COUNT
1103 L1 90 NOP NO OPERATION
1104 90 NOP NO OPERATION
1105 49 DEC CX DECREMENT CX
1106 75 FB JNE 1103H(L1) ZF=0,THEN GO TO 1103H
1108 C3 RET RETURN TO MAIN PROGRAM

FORMULAE:

255 x INPUT VOLTAGE

-------------------------------- = DECIMAL VALUE, CONVERT TO HEX
(+5V)MAX VOLTAGE

EXAMPLE:

255 x 2.5 V
= 127.5 (CONVERT THIS O/P VALUE TO HEX)
5V
= 7F 80(DIGITAL VALUE)

OUTPUT EXAMPLE VALUES:

INPUT VALUE(V) OUTPUT DIGITAL VALUE

00 00
1.25 40
2.5 80
3.75 C0
5.0 FF

58
 8086 DAC PROGRAM:
BASIC SIMPLE PROGRAM

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

1000 BA 26 FF MOV DX,FF26H CWR FOR ALL PORT O/P
1003 B0 80 MOV AL,80H OUT IT IN CONTROL REG
1005 EE OUT DX,AL MOVE THE CONTROL
WORD CNTR.REG
1006 BA 22 FF MOV DX,FF22H OUT PORT B
1009 B0 80 MOV AL,80H GIVEN I/P DATA
100B EE OUT DX,AL MOVE THE CONTROL
WORD CNTR.REG
100C CC INT 3 BREAK POINT

FORMULAE:

255 x INPUT VOLTAGE

---------------------------------- = DECIMAL VALUE, CONVERT TO HEX (DIGITAL VALUE)
(+5V)MAX VOLTAGE

EXAMPLE:

255 x 2.5 V
= 127.5 (CONVERT THIS O/P VALUE TO HEX)
5V
= 7F 80(DIGITAL VALUE)

OUTPUT EXAMPLE VALUES:

INPUT DIGITAL VALUE OUTPUT VALUE(V)

00 00
40 1.25
80 2.5
C0 3.75
FF 5.0

59
 INTERFACING USING TIMER TO GENERATE SQUARE WAVE

I/O Address for 8253/8254:

Counter0 -> FF10H

Counter1 -> FF12H

Counter2 -> FF14H

Control reg -> FF16H

PROGRAM:

ADDRESS LABEL OP CODE MNEMONICS COMMENT

0100 B0 B7 MOV AL,B7H ;timer initialized with counter 2
in mode 3
0102 BA 16 FF MOV DX,FF16H ;control port address in dx
0105 EE OUT DX,AL ;send the data to the timer
0106 B0 02 MOV AL,02H ;load lsb count in the al
0108 BA 10 FF MOV DX,FF10H ;port address in dx
010B EE OUT DX,AL ;output the al contents to clk2
010C B0 00 MOV AL,00H ;load msb count in the al
010E BA 10 FF MOV DX,FF10H
0111 EE OUT DX,AL ;output the al content to clk2
0112 CC INT 3 ;break point

Result:

The above programs were successfully executed and results were verified.

60
 Ex. No.
ARTHIMETIC OPERATIONS
Date:

Aim:
To write an assembly language program to perform an addition, subtraction,
multiplication and division of two 16-bit numbers using 8051microcontroller kit.

8 BIT ADDITION WITH CARRRY:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

8600 D3 SETB C Set The Carry Flag
8601 74 33 MOV A,#33 Input 33 Moves To The
8603 79 55 MOV R1,#55 Accumulator
Input 55 Moves To The
8605 39 ADDC A,R1 Accumulator
A<-A+R1+1
8606 90 90 00 MOV DPTR,#9000 Output Value Store In 9000
Memory Location
8609 F0 MOVX @DPTR,A Accumulator Moves To The
External Ram
860A 12 00 BB LCALL 00BB Breakpoint

RESULT:

REGISTER VALUE
A(INPUT) 33
R1(INPUT) 55
M9000(OUTPUT) 89

61
 8 BIT SUBTRACTION WITH BORROW:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

8800 D3 SETB C Clear The Carry Flag
8801 74 66 MOV A,#66 Input 66 Moves To The
Accumulator
8803 79 22 MOV R1,#22 Input 22 Moves To The R1
Register
8805 99 SUBB A,R1 A<-A-R1-1
8806 90 90 00 MOV DPTR,#9000 Output Value Store In 9000
Memory Location
8809 F0 MOVX @DPTR,A Accumulator Moves To The
External Ram
880A 12 00 BB LCALL 00BB Breakpoint

RESULT:

REGISTER VALUE
A(INPUT) 66
R1(INPUT) 22
M9000(OUTPUT) 43

62
 8 BIT MULTIPLICATION:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

8900 74 02 MOV A,#02 Input 02 Moves To The
8902 75 F0 02 MOV 0F0H,#02 Input 02Accumulator
Moves To The 0f0h
Register
8905 A4 MUL AB Multiplies A And B
8906 90 90 00 MOV DPTR,#9000 Output Value Store In 9000
Memory Location
8909 F0 MOVX @DPTR,A Accumulator Moves To The
External Ram
890A A3 INC DPTR Increment Dptr
890B E5 F0 MOV A,0F0H 0f0h Value Moves To The
Accumulator
890D F0 MOVX @DPTR,A Accumulator Moves To The
External Ram
890E 12 00 BB LCALL 00BB Breakpoint

RESULT:

REGISTER VALUE
A(INPUT) 02
0F0H(INPUT) 02
M9000(OUTPUT) 04

63
 8 BIT DIVISION:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

8A00 74 D5 MOV A,#0D5H Input D5 Moves To The Accumulator
8A02 75 F0 11 MOV 0F0H,#11 Input 11 Moves To The 0f0h Register
8A05 84 DIV AB Divide A By B
8A06 90 90 00 MOV DPTR,#9000 Output Value Store In 9000 Memory
Location
8A09 F0 MOVX @DPTR,A Accumulator Moves To The External
Ram
8A0A A3 INC DPTR Increment Dptr
8A0B E5 F0 MOV A,#0F0H 0f0h Value Moves To The Accumulator
8A0D F0 MOVX @DPTR,A Accumulator Moves To The External
Ram
8A0E 12 00 BB LCALL 00BB Breakpoint

RESULT:

REGISTER VALUE
A(INPUT) D5
F0(INPUT) 11
M9000(OUTPUT) 0C

Result:

The above programs were successfully executed and results were verified.

64
 Ex. No.
LOGICAL OPERATIONS
Date:

Aim:
To write an assembly language program to perform logical operations using 8051.
Microcontroller kit.

AND PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 74 01 MOV A,#01 01 Moves To A
9002 78 55 MOV R0,#55 55 Moves To The Acc.
9004 58 ANL A,R0 Logical And Operation
9005 F9 MOV R1,A Acc. Moves To The R1 Reg
9006 12 00 BB LCALL 00BB Breakpoint

AND OPERATION:

DATA 1: 01 0000 0001 (BINARY VALUE FOR 01)

DATA 2: 55 0101 0101 (BINARY VALUE FOR 55)

0000 0001 = 01 (DECIMAL VALUE)

65
 OR PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 74 01 MOV A,#01 Input 01 Moves To The Acc
9002 78 55 MOV R0,#55 Input 55 Moves To The R0 Reg
9004 48 ORL A,R0 Logical Or Operation
9005 F9 MOV R1,A Acc Value Moves To The R1 Reg
9006 12 00 BB LCALL 00BB Breakpoint

OR OPERATION:

DATA 1: 01 0000 0001 (BINARY VALUE FOR 01)

DATA 2: 55 0101 0101 (BINARY VALUE FOR 55)

0101 0101 =55 (DECIMAL VALUE)

66
 EX-OR PROGRAM:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 74 01 MOV A,#01 Input 01 Moves To The Acc
9002 78 55 MOV R0,#55 Input 55 Moves To The R0 Reg
9004 68 XRL A,R0 Logical X-Or Operation
9005 F9 MOV R1,A Acc Moves To The R1 Reg
9006 12 00 BB LCALL 00BB Breakpoint

EX-OR OPERATION:

DATA 1: 01 0000 0001 (BINARY VALUE FOR 01)

DATA 2: 55 0101 0101 (BINARY VALUE FOR 55)

0101 0100 =54 (DECIMAL VALUE)

Result:

The above programs were successfully executed and results were verified.

67
 Ex. No.
SQUARE, CUBE AND 2’S COMPLEMENT
Date:

Aim:
To write an assembly language program to perform square, cube and 2’s
complement using 8051 microcontroller kit.

SQUARE OF A NUMBER:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 90 86 00 MOV DPTR,#8600 Input Value Store In 8600
Memory Location
9003 E0 MOVX A,@DPTR Moves The External Ram To The
Accumulator
9004 F5 F0 MOV F0,A Accumulator Moves To The F0
9006 A4 MUL AB Multiplies A And B
9007 90 87 00 MOV DPTR,#8700 Output Value Store In 8700
Memory Location
900A F0 MOVX @DPTR,A Accumulator Moves To The
External Ram
900B 12 00 BB LCALL 00BB Breakpoint

RESULT:

ADDRESS VALUE
M8600(INPUT) 05
M8700(OUTPUT) 19

68
 CUBE OF THE NUMBER:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 90 86 00 MOV DPTR,#8600 Input Value Store In 8600
Memory Location
9003 E0 MOVX A,@DPTR Moves The External Ram To The
Accumulator
9004 F8 MOV R0,A Accumulator Moves To The R0
Register
9005 F5 F0 MOV B,A Accumulator Value Moves To
B
9007 A4 MUL AB Multiplies A And B
9008 C0 F0 PUSH B Pushes The Direct Byte On To
The Stack
900A F5 F0 MOV B,A Accumulator Value Moves To B

900C E8 MOV A,R0 R0 Register Moves To The

900D A4 MUL AB Accumulator
Mult Iplies A And B
900E 90 87 00 MOV DPTR,#8700 Output Value Store In 8700
Memory Location
9011 F0 MOVX @DPTR,A Accumulator Moves To The
External Ram
9012 12 00 BB LCALL 00BB Breakpoint

RESULT:

ADDRESS VALUE

M8600(INPUT) 03

M8700(OUTPUT) 1B

69
 2’S COMPLEMENT

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 90 85 00 MOV DPTR,#8500 Input Value Store In 8500 Memory
Location
9003 E0 MOVX A,@DPTR Moves The External Ram To The
Accumulator
9004 F4 CPL A Complement The Accumulator
9005 24 01 ADD A,#01 A<-A+01
9007 90 86 00 MOV DPTR,#8600 Output Value Store In 8600 Memory
Location
900A F0 MOVX @DPTR,A Accumulator Moves To The External
Ram
900B 12 00 BB LCALL 00BB Breakpoint

RESULT:

ADDRESS VALUE
M8500(INPUT) 04
M8600(OUTPUT) FC

Result:

The above programs were successfully executed and results were verified.

70
 Ex. No.
UNPACKED BCD TO ASCII CONVERSION
Date:

Aim:
To write an assembly language program to perform unpacked BCD TO ASCII
conversion 8051 microcontroller kit.
UNPACKED BCD TO ASCII CONVERSION:

ADDRESS LABEL OPCODE MNEMONICS COMMENTS

9000 79 04 MOV R1,#04 Data 1 Value Moves To The R1 Register
9002 7A 05 MOV R2,#05 Data 2 Value Moves To The R2 Register
9004 E9 MOV A,R1 R1 Value Moves To The Accumulator
9005 C4 SWAP A Swap The Accumulator
9006 2A ADD A,R2 A<-A+R2
9007 F8 MOV R0,A Accumulator Value Moved To The R0 Register
9008 54 0F ANL A,#0F Logical And Operation
900A 44 30 ORL A,#30 Logical Or Operation
900C FB MOV R4,A Accumulator Value Moves To The R3
900D E8 MOV A,R0 Register
R0 Value Moves To The Accumulator
900E C4 SWAP A Swap The Accumulator
900F 54 0F ANL A,#0F Logical And Operation
9011 44 30 ORL A,#30 Logical Or Operation
9013 FC MOV R3,A Accumulator Value Moves To The R4 Register
9014 12 00 BB LCALL 00BB Breakpoint

RESULT:
REGISTER VALUE
R1(INPUT) 04
R2(INPUT) 05
R3(OUTPUT) 34
R4(OUTPUT) 35

Result:

The above programs were successfully executed and results were verified.

71