8085 Programs List

ZATIN GUPTA
ch
te
of
ZS
8085
/A2
Microprocessor
/c
m
co
e.
Programs
b
tu
ou
.y
w
w
//w
s:
tp
ht
Page 1
https://www.youtube.com/c/A2ZSoftech
ZATIN GUPTA
PROGRAMS FOR 8085 MICROPROCESSOR

PROGRAMS FOR LEARNERS
ch
1. Store 8-bit data in memory
2. Exchange the contents of memory locations
3. Add two 8-bit numbers
te
4. Subtract two 8-bit numbers
5. Add two 16-bit numbers
of
6. Add contents of two memory locations
7. Subtract two 16-bit numbers.
S
8. Finding one's complement of a number
9. Finding Two's complement of a number
2Z
10. Pack the unpacked BCD numbers
11. Unpack a BCD number
12. Execution format of instructions
/A
13. Right shift bit of data
14. Left Shifting of a 16-bit data
15. Alter the contents of flag register in 8085
/c
PROGRAMS FOR BEGINNERS
16.
17. Multiply two 8-bit numbers
om
Calculate the sum of series of numbers
.c
18. Divide a 16 bit number by a 8-bit number
19. Find the negative numbers in a block of data.
be
20. Find the largest of given numbers

21. Count number of one's in a number
22. Arrange in ascending order
tu
23. Calculate the sum of series of even numbers

24. Calculate the sum of series of odd numbers
ou
25. Find the square of given number

26. Search a byte in a given number
27. Add two decimal numbers of 6 digit each
.y
28. Add each element of array with the elements of another array
29. Separate even numbers from given numbers
w
30. Transfer contents to overlapping memory blocks

w
PROGRAMS FOR TRAINEES

//w
31. Add parity bit to 7-bit ASCII characters

32. Find the number of negative, zero and positive numbers
33. Inserting string in a given array of characters
34. Deleting string in a given array of characters
s:
35. Multiply two eight bit numbers with shift and add method
36. Divide 16-bit number with 8-bit number using shifting technique
tp
37. Sub routine to perform the task of DAA

38. Program to test RAM
ht
39. Program to generate fibonacci number

40. Generate a delay of 0.4 seconds
41. Arrange in DESCENDING Order
42. Data transfer from one memory block to other memory block.
43. Find the factorial of a number
44. Find the Square Root of a given number
45. Split a HEX data into two nibbles and store it
Page 2
ZATIN GUPTA
46. Add two 4-digit BCD numbers

47. Subtraction of two BCD numbers
48. Multiply two 2-digit BCD numbers
ch
PROGRAMS FOR EXPERTS
te
a.PROGRAMS TO WORK WITH COUNTERS
49. Generate and display binary up counter
f
50. Generate and display BCD up counter with frequency 1Hz
So
51. Generate and display BCD down counter
52. Generate and display the contents of decimal counter
53. Debug the delay routine
2Z
b.PROGRAMS IN CODE CONVERSION
/A
54. 2-Digit BCD to binary conversion.
55. Binary to BCD conversion
56. Find the 7-segment codes for given numbers
/c
57. Find the ASCII character
m
58. ASCII to Decimal Conversion
59. HEX to Decimal conversion
co
60. HEX to binary conversion
c.PROGRAMS IN INTERFACING & APPLICTIONS

e.
I. Interfacing with IC 8251(Serial Communcation/USART)

ub
61. Output byte from SOD pin

62. Generate square wave from SOD pin
63. Receive ASCII character through SID pin
ut
64. Transmit message using 8251

Receive message using 8251
o
65.
.y
II. Interfacing with IC 8255( Programmable Periperal Interface - PPI)

66. Initialize 8255
w
67. Blink port C bit 0 of 8255

w
68. Flashing of LEDs

69. Traffic Light Control
//w
70. Stepper Motor Control

71. Keyboard interface(64-key-matrix-keyboard)
72. Seven Segment Display Interface (Eight Digits)
s:
III. Interfacing with IC 8279 (Keyboard and Display Controller)

tp
73. 8 x 8 Keyboard Interface(Without Interrupt signal)

74. 8 x 8 Keyboard Interface(With Interrupt signal)
ht
75. 8 x 4 Matrix Keyboard Interface

76. Interfacing of eight 7-segment digits
77. Interfacing of 4x4 matrix keyboard and 4 digit 7 segment display
78. Roll a message - 'HELL0123'
79. Roll your NAME
Page 3
ZATIN GUPTA
1 Statement: Store the data byte 32H into memory location 4000H.
Program 1:
ch
MVI A, 52H : Store 32H in the accumulator
STA 4000H : Copy accumulator contents at address 4000H
te
HLT : Terminate program execution
of
Program 2:
ZS
LXI H : Load HL with 4000H
MVI M : Store 32H in memory location pointed by HL register pair
(4000H)
A2
The result of both programs will be the same. In program 1 direct addressing
/
instruction is used, whereas in program 2 indirect addressing instruction is used.
/c
m
2 Statement: Exchange the contents of memory locations 2000H and 4000H
co
Program 1:
e.
LDA 2000H : Get the contents of memory location 2000H into accumulator
MOV B, A : Save the contents into B register
b
LDA 4000H : Get the contents of memory location 4000Hinto accumulator

tu
STA 2000H : Store the contents of accumulator at address 2000H

MOV A, B : Get the saved contents back into A register
ou
STA 4000H : Store the contents of accumulator at address 4000H
Program 2:
.y
LXI H 2000H : Initialize HL register pair as a pointer to memory

location 2000H.
w
LXI D 4000H : Initialize DE register pair as a pointer to memory

location 4000H.
w
MOV B, M : Get the contents of memory location 2000H into B

register.
//w
LDAX D : Get the contents of memory location 4000H into A register.

MOV M, A : Store the contents of A register into memory location
2000H.
MOV A, B : Copy the contents of B register into accumulator.
s:
STAX D : Store the contents of A register into memory location

4000H.
tp
HLT : Terminate program execution.

ht
In Program 1, direct addressing instructions are used, whereas in Program 2,

indirect addressing instructions are used.
Page 4
ZATIN GUPTA
3 Statement: Add the contents of memory locations 4000H and 4001H and place
the result in memory location 4002H.
Sample problem
(4000H) = 14H
ch
(4001H) = 89H
Result = 14H + 89H = 9DH
fte
Source program
LXI H 4000H : HL points 4000H
So
MOV A, M : Get first operand
INX H : HL points 4001H
ADD M : Add second operand
2Z
MOV M, A : Store result at 4002H
/A
FLOWCHART
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 5
ZATIN GUPTA
4 Statement: Subtract the contents of memory location 4001H from the memory
location 2000H and place the result in memory location 4002H.
Program - 4: Subtract two 8-bit numbers
Sample problem:
ch
(4000H) = 51H
(4001H) = 19H
fte
Result = 51H - 19H = 38H
Source program:
So
LXI H, 4000H : HL points 4000H
MOV A, M : Get first operand
2Z
SUB M : Subtract second operand
/A
MOV M, A : Store result at 4002H.
/c
FLOWCHART
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 6
ZATIN GUPTA
5 Statement: Add the 16-bit number in memory locations 4000H and 4001H to the
16-bit number in memory locations 4002H and 4003H. The most significant eight
bits of the two numbers to be added are in memory locations 4001H and 4003H.
Store the result in memory locations 4004H and 4005H with the most significant
byte in memory location 4005H
ch
Program - 5.a: Add two 16-bit numbers - Source Program 1
te
Sample problem:
of
(4000H) = 15H
(4001H) = 1CH
ZS
(4002H) = B7H
(4003H) = 5AH
Result = 1C15 + 5AB7H = 76CCH
(4004H) = CCH
A2
(4005H) = 76H
Source Program 1:
/
LHLD 4000H : Get first I6-bit number in HL
/c
XCHG : Save first I6-bit number in DE
LHLD 4002H : Get second I6-bit number in HL
MOV A, E
ADD L
m
: Get lower byte of the first number
: Add lower byte of the second number
co
MOV L, A : Store result in L register
MOV A, D : Get higher byte of the first number
ADC H : Add higher byte of the second number with CARRY
e.
MOV H, A : Store result in H register

SHLD 4004H : Store I6-bit result in memory locations 4004H and 4005H.
b

tu
Program - 5b: Add two 16-bit numbers - Source Program 2

ou
Source program 2:
LHLD 4000H : Get first I6-bit number
.y
XCHG : Save first I6-bit number in DE

LHLD 4002H : Get second I6-bit number in HL
w
DAD D : Add DE and HL

SHLD 4004H : Store I6-bit result in memory locations 4004H and 4005H.
w

//w
NOTE: In program 1, eight bit addition instructions are used (ADD and ADC) and
addition is performed in two steps. First lower byte addition using ADD instruction
and then higher byte addition using ADC instruction.In program 2, 16-bit addition
s:
instruction (DAD) is used.

tp
ht
Page 7
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 8
ZATIN GUPTA
6 Statement: Add the contents of memory locations 40001H and 4001H and place
the result in the memory locations 4002Hand 4003H.
Sample problem:
(4000H) = 7FH
ch
(400lH) = 89H
Result = 7FH + 89H = lO8H
(4002H) = 08H
fte
(4003H) = 0lH
Source program:
So
LXI H, 4000H :HL Points 4000H
MOV A, M :Get first operand
2Z
INX H :HL Points 4001H
ADD M :Add second operand
/A
MOV M, A :Store the lower byte of result at 4002H
MVIA, 00 :Initialize higher byte result with 00H
ADC A :Add carry in the high byte result
/c
MOV M, A :Store the higher byte of result at 4003H
HLT
m
:Terminate program execution
FLOWCHART
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 9
ZATIN GUPTA
7 Statement: Subtract the 16-bit number in memory locations 4002H and 4003H
from the 16-bit number in memory locations 4000H and 4001H. The most
significant eight bits of the two numbers are in memory locations 4001H and
4003H. Store the result in memory locations 4004H and 4005H w with
ith the most
significant byte in memory location 4005H.
ch
Sample problem
(4000H) = 19H
te
(400IH) = 6AH
(4004H) = I5H (4003H) = 5CH
of
Result = 6A19H - 5C15H = OE04H
(4004H) = 04H
ZS
(4005H) = OEH
Source program:
A2
LHLD 4000H : Get first 16-bit number in HL
XCHG : Save first 16-bit number in DE
LHLD 4002H : Get second 16-bit number in HL
/
MOV A, E : Get lower byte of the first number
/c
SUB L : Subtract lower byte of the second number
MOV L, A : Store the result in L register
MOV A, D
SBB H
m
: Get higher byte of the first number
: Subtract higher byte of second number with borrow
co
MOV H, A : Store l6-bit result in memory locations 4004H and 4005H.
SHLD 4004H : Store l6-bit result in memory locations 4004H and 4005H.
e.
FLOWCHART
b
tu
ou
.y
w
w
//w
s:
tp
ht
Page 10
ZATIN GUPTA
8 Statement: Find the l's complement of the number stored at memory location
4400H and store the complemented number at memory location 4300H.
Sample problem:
(4400H) = 55H
ch
Result = (4300B) = AAB
Source program:
fte
LDA 4400B : Get the number
CMA : Complement number
STA 4300H : Store the result
So
FLOWCHART
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 11
ZATIN GUPTA
9 Statement: Find the 2's complement of the number stored at memory location
4200H and store the complemented number at memory location 4300H.
Sample problem:
(4200H) = 55H
ch
Result = (4300H) = AAH + 1 = ABH
Source program:
fte
LDA 4200H : Get the number
CMA : Complement the number
So
ADI, 01 H : Add one in the number
2Z
FLOWCHART
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 12
ZATIN GUPTA
10 Statement: Pack the two unpacked BCD numbers stored in memory locations
4200H and 4201H and store result in memory location 4300H. Assume the least
significant digit is stored at 4200H.
Sample problem:
ch
(4200H) = 04
(4201H) = 09
Result = (4300H) = 94
fte
Source program
So
LDA 4201H : Get the Most significant BCD digit
RLC
RLC
2Z
RLC
RLC : Adjust the position of the second digit (09 is changed to 90)
ANI FOH : Make least significant BCD digit zero
/A
MOV C, A : store the partial result
LDA 4200H : Get the lower BCD digit
ADD C : Add lower BCD digit
/c
NOTE:
m
co
BCD NO.: The numbers "0 to 9" are called BCD (Binary Coded Decimal)
numbers. A decimal number 29 can be converted into BCD number by splitting
e.
FLOWCHART
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 13
ZATIN GUPTA
11 Statement: Two digit BCD number is stored in memory location 4200H. Unpack
the BCD number and store the two digits in memory locations 4300H and 4301H
such that memory location 4300H will have lower BCD digit.
Sample problem
ch
(4200H) = 58
Result = (4300H) = 08 and
fte
(4301H) = 05
Source program
So
LDA 4200H : Get the packed BCD number
ANI FOH : Mask lower nibble
RRC
2Z
RRC
RRC
RRC : Adjust higher BCD digit as a lower digit
/A
STA 4301H : Store the partial result
LDA 4200H : .Get the original BCD number
/c
ANI OFH : Mask higher nibble
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 14
ZATIN GUPTA
12 Statement:Read the program given below and state the contents of all registers
after the execution of each instruction in sequence.
Main program:
4000H LXI SP, 27FFH
ch
4003H LXI H, 2000H
4006H LXI B, 1020H
4009H CALL SUB
fte
400CH HLT
Subroutine program:
So
4100H SUB: PUSH B
4101H PUSH H
2Z
4102H LXI B, 4080H
4105H LXI H, 4090H
4108H SHLD 2200H
/A
4109H DAD B
410CH POP H
410DH POP B
/c
410EH RET
om
.c
be
tu
ou
.y
w
w
//w
s:
tp
ht
Page 15
ZATIN GUPTA
13 Statement:Write a program to shift an eight bit data four bits right. Assume
that data is in register C.
Source program:
MOV A, C
ch
RAR
RAR
RAR
fte
RAR
MOV C, A
HLT
So
2Z
/A
/c
m
Statement:Write a program to shift a 16 bit data, 1 bit right. Assume that data is
co
in BC register pair.
Source program:
e.
MOV A, B
RAR
b
MOV B, A
MOV A, C
tu
RAR
MOV C, A
ou
HLT
.y
w
w
//w
s:
tp
ht
Page 16
ZATIN GUPTA
14 Statement: Program to shift a 16-bit data 1 bit left. Assume data is in the HL
register pair.
Source program:
DAD H : Adds HL data with HL data
ch
te
of
ZS
15 Statement: Write a set of instructions to alter the contents of flag register in
8085.
2
PUSH PSW : Save flags on stack
/A
POP H : Retrieve flags in 'L'
MOV A, L : Flags in accumulator
CMA : Complement accumulator
/c
MOV L, A : Accumulator in 'L'
PUSH H : Save on stack
m
POP PSW : Back to flag register
HLT :Terminate program execution
o
.c
16 Statement: Calculate the sum of series of numbers. The length of the series is
be
in memory location 4200H and the series begins from memory location 4201H.
a. Consider the sum to be 8 bit number. So, ignore carries. Store the sum at
tu
memory location 4300H.

b. Consider the sum to be 16 bit number. Store the sum at memory locations
ou
4300H and 4301H.

a. Sample problem
.y
4200H = 04H
4201H = 10H
w
4202H = 45H
4203H = 33H
w
4204H = 22H
Result = 10 +41 + 30 + 12 = H
//w
4300H = H
Source program:
s:
LDA 4200H
MOV C, A : Initialize counter
tp
SUB A : sum = 0
LXI H, 420lH : Initialize pointer
ht
BACK: ADD M : SUM = SUM + data

INX H : increment pointer
DCR C : Decrement counter
JNZ BACK : if counter 0 repeat
STA 4300H : Store sum
Page 17
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
b. Sample problem
e.
4200H = 04H
420lH = 9AH
ub
4202H = 52H
4203H = 89H
4204H = 3EH
ut
Result = 9AH + 52H + 89H + 3EH = H

4300H = B3H Lower byte
o
4301H = 0lH Higher byte

.y
Source program:
w
LDA 4200H
w
LXI H, 4201H : Initialize pointer

SUB A :Sum low = 0
//w
MOV B, A : Sum high = 0

BACK: ADD M : Sum = sum + data
JNC SKIP
s:
INR B : Add carry to MSB of SUM

SKIP: INX H : Increment pointer
tp

JNZ BACK : Check if counter 0 repeat
ht
STA 4300H : Store lower byte

MOV A, B
STA 4301H : Store higher byte
HLT :Terminate program execution
Page 18
ZATIN GUPTA
17 Statement: Multiply two 8-bit numbers stored in memory locations 2200H and
2201H by repetitive addition and store the result in memory locations 2300H and
2301H.
Sample problem:
ch
(2200H) = 03H
(2201H) = B2H
Result = B2H + B2H + B2H = 216H
fte
= 216H
(2300H) = 16H
(2301H) = 02H
So
Source program
2Z
LDA 2200H
MOV E, A
MVI D, 00 : Get the first number in DE register pair
/A
LDA 2201H
LX I H, 0000 H : Result = 0
/c
BACK: DAD D : Result = result + first number
DCR C : Decrement count
JNZ BACK
SHLD 2300H
HLT
: Store result
o m
: If count 0 repeat
: Terminate program execution

.c
be
FLOWCHART
tu
ou
.y
w
w
//w
s:
tp
ht
Page 19
ZATIN GUPTA
18 Statement:Divide 16 bit number stored in memory locations 2200H and 2201H

by the 8 bit number stored at memory location 2202H. Store the quotient in
memory locations 2300H and 2301H and remainder in memory locations 2302H
and 2303H.
Sample problem
ch
(2200H) = 60H
(2201H) = A0H
(2202H) = l2H
te
Result = A060H/12H = 8E8H Quotient and 10H remainder
(2300H) = E8H
of
(2301H) = 08H
(2302H= 10H
ZS
(2303H) 00H
Source program
LHLD 2200H : Get the dividend
LDA 2202H : Get the divisor
A2
MOV C, A
LXI D, 0000H : Quotient = 0
BACK: MOV A, L
/
SUB C : Subtract divisor
/c
MOV L, A : Save partial result
JNC SKIP : if CY 1 jump
DCR H
SKIP: INX D
m
: Subtract borrow of previous subtraction
: Increment quotient
co
MOV A, H
CPI, 00 : Check if dividend < divisor
JNZ BACK : if no repeat
e.
MOV A, L
CMP C
b
JNC BACK
tu
SHLD 2302H : Store the remainder

XCHG
ou
SHLD 2300H : Store the quotient

.y
w
w
//w
s:
tp
ht
Page 20
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 21
ZATIN GUPTA
19 Statement:Find the number of negative elements (most significant bit 1) in a

block of data. The length of the block is in memory location 2200H and the block
itself begins in memory location 2201H. Store the number of negative elements in
memory location 2300H
Sample problem
ch
(2200H) = 04H
(2201H) = 56H
(2202H) = A9H
te
(2203H) = 73H
(2204H) = 82H
f
Result = 02 since 2202H and 2204H contain numbers with a MSB of 1.
So
Source program
LDA 2200H
MOV C, A : Initialize count
2Z
MVI B, 00 : Negative number = 0
BACK: MOV A, M : Get the number
/A
ANI 80H : Check for MSB
JZ SKIP : If MSB = 1
INR B : Increment negative number count
/c
JNZ BACK
MOV A, B
STA 2300H
om
: If count 0 repeat
: Store the result

.c
FLOWCHART
e
t ub
ou
.y
w
w
//w
s:
tp
ht
Page 22
ZATIN GUPTA
20 Statement:Find the largest number in a block of data. The length of the block is
in memory location 2200H and the block itself starts from memory location 2201H.
Store the maximum number in memory location 2300H. Assume that the numbers
in the block are all 8 bit unsigned binary numbers.
Sample problem
ch
(2200H) = 04
(2201H) = 34H
(2202H) = A9H
fte
(2203H) = 78H
(2204H) =56H
Result = (2202H) = A9H
So
Source program
LDA 2200H
2Z
XRA A : Maximum = Minimum possible value = 0
BACK: CMP M : Is number> maximum
/A
JNC SKIP : Yes, replace maximum
MOV A, M
SKIP: INX H
/c
DCR C
JNZ BACK
STA 2300H
HLT
om
: Store maximum number
.c
FLOWCHART
be
tu
ou
.y
w
w
// w
s:
tp
ht
Page 23
ZATIN GUPTA
21 Statement:Write a program to count number of l's in the contents of D register

and store the count in the B register.
Source program:
MVI B, 00H
ch
MVI C, 08H
MOV A, D
BACK: RAR
fte
JNC SKIP
INR B
SKIP: DCR C
So
JNZ BACK
HLT
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 24
ZATIN GUPTA
22 Statement:Write a program to sort given 10 numbers from memory location

2200H in the ascending order.
Source program:
MVI B, 09 : Initialize counter
ch
START : LXI H, 2200H: Initialize memory pointer
MVI C, 09H : Initialize counter 2
te
INX H : Increment memory pointer
CMP M : Compare number with next number
of
JC SKIP : If less, don't interchange
JZ SKIP : If equal, don't interchange
ZS
MOV D, M
MOV M, A
DCX H
MOV M, D
A2
INX H : Interchange two numbers
SKIP:DCR C : Decrement counter 2
JNZ BACK : If not zero, repeat
/
DCR B : Decrement counter 1
/c
JNZ START
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 25
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 26
ZATIN GUPTA
23 Statement:Calculate the sum of series of even numbers from the list of

numbers. The length of the list is in memory location 2200H and the series itself
begins from memory location 2201H. Assume the sum to be 8 bit number so you
can ignore carries and store the sum at memory location 2210H.
Sample problem:
ch
2200H= 4H
2201H= 20H
te
2202H= l5H
2203H= l3H
of
2204H= 22H
Result 22l0H= 20 + 22 = 42H
ZS
= 42H
Source program:
A2
LDA 2200H
MVI B, 00H : sum = 0
/
/c
ANI 0lH : Mask Bit l to Bit7
JNZ SKIP
MOV A, B : Get the
m
: Don't add if number is ODD
sum
co
ADD M : SUM = SUM + data
MOV B, A : Store result in B register
SKIP: INX H : increment pointer
e.

JNZ BACK : if counter 0 repeat
b
STA 2210H : store sum

tu

ou
.y
w
w
//w
s:
tp
ht
Page 27
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 28
ZATIN GUPTA
24 Statement:Calculate the sum of series of odd numbers from the list of numbers.
The length of the list is in memory location 2200H and the series itself begins from
memory location 2201H. Assume the sum to be 16-bit. Store the sum at memory
locations 2300H and 2301H.
Sample problem:
ch
2200H = 4H
2201H= 9AH
te
2202H= 52H
2203H= 89H
of
2204H= 3FH
Result = 89H + 3FH = C8H
ZS
2300H= H Lower byte
2301H = H Higher byte
Source program
A2
LDA 2200H
/
/c
MVI E, 00 : Sum low = 0
MOV D, E : Sum high = 0
BACK: MOV A, M
ANI 0lH
: Get the number
: Mask Bit 1 to Bit7
m
co
JZ SKIP : Don't add if number is even
MOV A, E : Get the lower byte of sum
ADD M : Sum = sum + data
e.
MOV E, A : Store result in E register

JNC SKIP
b
INR D : Add carry to MSB of SUM

tu

ou
.y
w
w
//w
s:
tp
ht
Page 29
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 30
ZATIN GUPTA
25 Statement:Find the square of the given numbers from memory location 6100H
and store the result from memory location 7000H.
Source Program:
LXI H, 6200H : Initialize lookup table pointer
ch
LXI D, 6100H : Initialize source memory pointer
LXI B, 7000H : Initialize destination memory pointer
BACK: LDAX D : Get the number
fte
MOV L, A : A point to the square
MOV A, M : Get the square
STAX B : Store the result at destination memory location
So
INX D : Increment source memory pointer
INX B : Increment destination memory pointer
MOV A, C
2Z
CPI 05H : Check for last number
JNZ BACK : If not repeat
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 31
ZATIN GUPTA
26 Statement: Search the given byte in the list of 50 numbers stored in the
consecutive memory locations and store the address of memory location in the
memory locations 2200H and 2201H. Assume byte is in the C register and starting
address of the list is 2000H. If byte is not found store 00 at 2200H and 2201H.
Source program:
ch
LX I H, 2000H : Initialize memory pointer 52H
MVI B, 52H : Initialize counter
fte
CMP C : Compare with the given byte
JZ LAST : Go last if match occurs
So
DCR B : Decrement counter
JNZ B : I f not zero, repeat
2Z
LXI H, 0000H
SHLD 2200H
JMP END : Store 00 at 2200H and 2201H
/A
LAST: SHLD 2200H : Store memory address
END: HLT : Stop
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 32
ZATIN GUPTA
27 Statement: Two decimal numbers six digits each, are stored in BCD package
form. Each number occupies a sequence of byte in the memory. The starting
address of first number is 6000H Write an assembly language program that adds
these two numbers and stores the sum in the same format starting from memory
location 6200H.
ch
Source Program:
LXI H, 6000H : Initialize pointer l to first number
te
LXI D, 6l00H : Initialize pointer2 to second number
LXI B, 6200H : Initialize pointer3 to result
of
STC
CMC : Carry = 0
ZS
BACK: LDAX D : Get the digit
ADD M : Add two digits
DAA : Adjust for decimal
STAX.B : Store the result
A2
INX H : Increment pointer 1
INX D : Increment pointer2
INX B : Increment result pointer
/
MOV A, L
/c
CPI 06H : Check for last digit
JNZ BACK : If not last digit repeat
HLT
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 33
ZATIN GUPTA
FLOWCHART
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 34
ZATIN GUPTA
28 Statement: Add 2 arrays having ten 8-bit numbers each and generate a third
array of result. It is necessary to add the first element of array 1 with the first
element of array-2 and so on. The starting addresses of array l, array2 and array3
are 2200H, 2300H and 2400H, respectively.
Source Program:
ch
LXI H, 2200H : Initialize memory pointer 1
LXI B, 2300H : Initialize memory pointer 2
fte
LXI D, 2400H : Initialize result pointer
BACK: LDAX B : Get the number from array 2
ADD M : Add it with number in array 1
So
STAX D : Store the addition in array 3
INX H : Increment pointer 1
INX B : Increment pointer2
2Z
INX D : Increment result pointer
MOV A, L
CPI 0AH : Check pointer 1 for last number
/A
JNZ BACK : If not, repeat
HLT : Stop
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 35
ZATIN GUPTA
29 Statement: Write an assembly language program to separate even numbers

from the given list of 50 numbers and store them in the another list starting from
2300H. Assume starting address of 50 number list is 2200H.
Source Program:
ch
LXI H, 2200H : Initialize memory pointer l
LXI D, 2300H : Initialize memory pointer2
MVI C, 32H : Initialize counter
fte
BACK:MOV A, M : Get the number
ANI 0lH : Check for even number
JNZ SKIP : If ODD, don't store
So
MOV A, M : Get the number
STAX D : Store the number in result list
INX D : Increment pointer 2
2Z
SKIP: INX H : Increment pointer l
/A
HLT : Stop
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 36
ZATIN GUPTA
30 Statement: Write assembly language program with proper comments for the
following:
A block of data consisting of 256 bytes is stored in memory starting at 3000H.
This block is to be shifted (relocated) in memory from 3050H onwards. Do not
shift the block or part of the block anywhere else in the memory.
ch
Source Program:
Two blocks (3000 - 30FF and 3050 - 314F) are overlapping. Therefore it is
te
necessary to transfer last byte first and first byte last.
of
ZS
MVI C, FFH : Initialize counter
LX I H, 30FFH : Initialize source memory pointer 3l4FH
LXI D, 314FH : Initialize destination memory pointer
BACK: MOV A, M : Get byte from source memory block
A2
STAX D : Store byte in the destination memory block
DCX H : Decrement source memory pointer
DCX : Decrement destination memory pointer
/
/c
JNZ BACK : If counter 0 repeat
HLT : Stop execution
m
co
31 Statement: Add even parity to a string of 7-bit ASCII characters. The length of
the string is in memory location 2040H and the string itself begins in memory
location 2041H. Place even parity in the most significant bit of each character.
e.
Source Program:
b
LXI H, 2040H
tu
MOV C ,M : Counter for character

REPEAT:INX H : Memory pointer to character
ou
MOV A,M : Character in accumulator

ORA A : ORing with itself to check parity.
JPO PAREVEN : If odd parity place
.y
ORI 80H even parity in D7 (80).

PAREVEN:MOV M , A : Store converted even parity character.
w
DCR C : Decrement counter.

JNZ REPEAT : If not zero go for next character.
w

//w
s:
tp
ht
Page 37
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
om
.c
be
tu
ou
.y
w
w
w
//
s:
tp
ht
Page 38
ZATIN GUPTA
32 Statement: A list of 50 numbers is stored in memory, starting at 6000H. Find

number of negative, zero and positive numbers from this list and store these
results in memory locations 7000H, 7001H, and 7002H respectively.
Source Program:
ch
LXI H, 6000H : Initialize memory pointer
MVI C, 00H : Initialize number counter
MVI B, 00H : Initialize negative number counter
te
MVI E, 00H : Initialize zero number counter
BEGIN:MOV A, M : Get the number
of
CPI 00H : If number = 0
JZ ZERONUM : Goto zeronum
ZS
ANI 80H : If MSB of number = 1i.e. if
JNZ NEGNUM number is negative goto NEGNUM
INR D : otherwise increment positive number counter
JMP LAST
A2
ZERONUM:INR E : Increment zero number counter
JMP LAST
NEGNUM:INR B : Increment negative number counter
/
LAST:INX H : Increment memory pointer
/c
INR C : Increment number counter
MOV A, C
CPI 32H
JNZ BEGIN : Store
m
: If number counter = 5010 then
otherwise check next number
co
LXI H, 7000 : Initialize memory pointer.
MOV M, B : Store negative number.
INX H
e.
MOV M, E : Store zero number.

INX H
b
MOV M, D : Store positive number.

tu
HLT : Terminate execution

ou
.y
w
w
//w
s:
tp
ht
Page 39
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 40
ZATIN GUPTA
33 Statement:Write an 8085 assembly language program to insert a string of four

characters from the tenth location in the given array of 50 characters.
Solution:
Step 1: Move bytes from location 10 till the end of array by four bytes
downwards.
ch
Step 2: Insert four bytes at locations 10, 11, 12 and 13.
Source Program:
te
LXI H, 2l31H : Initialize pointer at the last location of array.
of
LXI D, 2l35H : Initialize another pointer to point the last location of
array after insertion.
ZS
AGAIN: MOV A, M : Get the character
STAX D : Store at the new location
DCX D : Decrement destination pointer
DCX H : Decrement source pointer
A2
MOV A, L : [check whether desired
CPI 05H bytes are shifted or not]
JNZ AGAIN : if not repeat the process
/
INX H : adjust the memory pointer
/c
LXI D, 2200H : Initialize the memory pointer to point the string to be
inserted
REPE: LDAX D
MOV M, A
: Get the character
: Store it in the array
m
co
INX D : Increment source pointer
INX H : Increment destination pointer
MOV A, E : [Check whether the 4 bytes
e.
CPI 04 are inserted]

JNZ REPE : if not repeat the process
b
HLT : stop
tu
ou
34 Statement:Write an 8085 assembly language program to delete a string of 4

characters from the tenth location in the given array of 50 characters.
Solution: Shift bytes from location 14 till the end of array upwards by 4 characters
.y
i.e. from location 10 onwards.

w
Source Program:
w
LXI H, 2l0DH :Initialize source memory pointer at the 14thlocation of the

array.
//w
LXI D, 2l09H : Initialize destn memory pointer at the 10th location of the
array.
MOV A, M : Get the character
s:
STAX D : Store character at new location

INX D : Increment destination pointer
tp
INX H : Increment source pointer

MOV A, L : [check whether desired
CPI 32H bytes are shifted or not]
ht
JNZ REPE : if not repeat the process

HLT : stop
Page 41
ZATIN GUPTA
35 Statement:Multiply the 8-bit unsigned number in memory location 2200H by

the 8-bit unsigned number in memory location 2201H. Store the 8 least significant
bits of the result in memory location 2300H and the 8 most significant bits in
memory location 2301H.
Sample problem:
ch
(2200) = 1100 (0CH)
(2201) = 0101 (05H)
te
Multiplicand = 1100 (1210)
Multiplier = 0101 (510)
of
Result = 12 x 5 = (6010)
ZS
Source program
LXI H, 2200 : Initialize the memory pointer
A2
MOV E, M : Get multiplicand
MVI D, 00H : Extend to 16-bits
/
MOV A, M : Get multiplier
/c
LXI H, 0000 : Product = 0
MVI B, 08H : Initialize counter with count 8
MULT: DAD H
RAL
m
: Product = product x 2
co
JNC SKIP : Is carry from multiplier 1 ?
DAD D : Yes, Product =Product + Multiplicand
SKIP: DCR B : Is counter = zero
e.
JNZ MULT : no, repeat

SHLD 2300H : Store the result
b
HLT : End of program

tu
ou
.y
w
w
//w
s:
tp
ht
Page 42
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 43
ZATIN GUPTA
36 Statement:Divide the 16-bit unsigned number in memory locations 2200H and

2201H (most significant bits in 2201H) by the B-bit unsigned number in memory
location 2300H store the quotient in memory location 2400H and remainder in
2401H.
Assumption: The most significant bits of both the divisor and dividend are zero.
ch
Source program
te
MVI E, 00 : Quotient = 0
LHLD 2200H : Get dividend
of
LDA 2300 : Get divisor
MOV B, A : Store divisor
ZS
MVI C, 08 : Count = 8
NEXT: DAD H : Dividend = Dividend x 2
MOV A, E
RLC
A2
MOV E, A : Quotient = Quotient x 2
MOV A, H
SUB B : Is most significant byte of Dividend > divisor
/
JC SKIP : No, go to Next step
/c
MOV H, A : Yes, subtract divisor
INR E : and Quotient = Quotient + 1
SKIP:DCR C
JNZ NEXT
: Count = Count - 1
: Is count =0 repeat
m
co
MOV A, E
STA 2401H : Store Quotient
Mov A, H
e.
STA 2410H : Store remainder

HLT : End of program.
b
tu
ou
.y
w
w
//w
s:
tp
ht
Page 44
ZATIN GUPTA
ch
te
f
So
2Z
/A
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 45
ZATIN GUPTA
37 Statement:Assume the DAA instruction is not present. Write a sub routine

which will perform the same task as DAA.
Sample Problem:
Execution of DAA instruction:
ch
1. If the value of the low order four bits (03-00) in the accumulator is greater than
9 or if auxiliary carry flag is set, the instruction adds 6 '(06) to the low-order four
bits.
te
2. If the value of the high-order four bits (07-04) in the accumulator is greater
than 9 or if carry flag is set, the instruction adds 6(06) to the high-order four bits.
of
Source Program:
ZS
LXI SP, 27FFH : Initialize stack pointer
MOV E, A : Store the contents of accumulator
ANI 0FH : Mask upper nibble
A2
CPI 0A H : Check if number is greater than 9
JC SKIP : if no go to skip
MOV A, E : Get the number
/
ADI 06H : Add 6 in the number
/c
JMP SECOND : Go for second check
SKIP: PUSH PSW : Store accumulator and flag contents in stack
POP B
register contents in
m
: Get the contents of accumulator in B register and flag
C register
co
MOV A, C : Get flag register contents in accumulator
ANI 10H : Check for bit 4
JZ SECOND : if zero, go for second check
e.

ADI 06 : Add 6 in the number
b
SECOND: MOV E, A : Store the contents of accumulator

tu
ANI FOH : Mask lower nibble

RRC
ou
RRC
RRC
RRC : Rotate number 4 bit right
.y
CPI 0AH : Check if number is greater than 9

JC SKIPl : if no go to skip 1
w

ADI 60 H : Add 60 H in the number
w
JMP LAST : Go to last

SKIP1: JNC LAST : if carry flag = 0 go to last
//w

ADI 60 H : Add 60 H in the number
LAST: HLT
s:
Note: To check auxiliary carry flag it is necessary to get the flag register contents
tp
in one of the registers and then we can check the auxiliary carry flag by checking
bit 4 of that register. To get the flag register contents in any general purpose
register we require stack operation and therefore stack pointer is initialized at the
ht
beginning of the source program.
Page 46
ZATIN GUPTA
ch
te
of
ZS
/A2
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 47
ZATIN GUPTA
38 Statement:To test RAM by writing '1' and reading it back and later writing '0'
(zero) and reading it back. RAM addresses to be checked are 40FFH to 40FFH. In
case of any error, it is indicated by writing 01H at port 10H.
Source Program:
ch
BACK: MVI M, FFH : Writing '1' into RAM
MOV A, M : Reading data from RAM
te
CPI FFH : Check for ERROR
JNZ ERROR : If yes go to ERROR
of
MOV A, H
ZS
CPI SOH : Check for last check
JNZ BACK : If not last, repeat
BACKl: MVI M, OOH : Writing '0' into RAM
A2
MOV A, M : Reading data from RAM
CPI OOH : Check for ERROR
/
MOV A, H
/c
CPI SOH : Check for last check
JNZ BACKl : If not last, repeat
HLT : Stop Execution
m
co
39 Statement:Write an assembly language program to generate fibonacci number.
e.
Source Program:
b
MVI D, COUNT : Initialize counter

tu
MVI B, 00 : Initialize variable to store previous number

MVI C, 01 : Initialize variable to store current number
ou
MOV A, B :[Add two numbers]

BACK: ADD C :[Add two numbers]
MOV B, C : Current number is now previous number
.y
MOV C, A : Save result as a new current number

DCR D : Decrement count
w
JNZ BACK : if count 0 go to BACK

HLT : Stop.
w
//w
40 Statement:Write a program to generate a delay of 0.4 sec if the crystal

frequency is 5 MHz.
s:
Calculation: In 8085, the operating frequency is half of the crystal frequency,

ie.Operating frequency = 5/2 = 2.5 MHz
tp
Time for one T -state =

Number of T-states required =
= 1 x 106
ht
Source Program:
LXI B, count : 16 - bit count
BACK: DCX B : Decrement count
MOV A, C
ORA B : Logically OR Band C
JNZ BACK : If result is not zero repeat
Page 48
ZATIN GUPTA
41 Statement: Arrange an array of 8 bit unsigned no in descending order
Source Program:
ch
START:MVI B, 00 ; Flag = 0
LXI H, 4150 ; Count = length of array
te
MOV C, M
DCR C ; No. of pair = count -1
of
INX H ; Point to start of array
LOOP:MOV A, M ; Get kth element
ZS
INX H
CMP M ; Compare to (K+1) th element
JNC LOOP 1 ; No interchange if kth >= (k+1) th
MOV D, M ; Interchange if out of order
A2
MOV M, A ;
DCR H
MOV M, D
/
INX H
/c
MVI B, 01H ; Flag=1
LOOP 1:DCR C ; count down
JNZ LOOP
DCR B
;
; is flag = 1?
m
co
JZ START ; do another sort, if yes
HLT ; If flag = 0, step execution
e.
42 Statement: Transfer ten bytes of data from one memory to another memory
b
block. Source memory block starts from memory location 2200H where as
tu
destination memory block starts from memory location 2300H.

Source Program:
ou
LXI H, 4150 : Initialize memory pointer

MVI B, 08 : count for 8-bit
.y
MVI A, 54
LOOP : RRC
w
JC LOOP1
MVI M, 00 : store zero it no carry
w
JMP COMMON
LOOP2: MVI M, 01 : store one if there is a carry
//w
COMMON: INX H
DCR B : check for carry
JNZ LOOP
s:
HLT : Terminate the program

tp
ht
Page 49
ZATIN GUPTA
43 Statement: Program to calculate the factorial of a number between 0 to 8
Source program
LXI SP, 27FFH ; Initialize stack pointer
ch
LDA 2200H ; Get the number
CPI 02H ; Check if number is greater than 1
JC LAST
te
MVI D, 00H ; Load number as a result
MOV E, A
of
DCR A
MOV C,A ; Load counter one less than number
ZS
CALL FACTO ; Call subroutine FACTO
XCHG ; Get the result in HL
SHLD 2201H ; Store result in the memory
JMP END
A2
LAST: LXI H, 000lH ; Store result = 01
END: SHLD 2201H
HLT
/
/c
Subroutine Program:
FACTO:LXI H, 0000H
MOV B, C ; Load counter
m
co
BACK: DAD D
DCR B
JNZ BACK ; Multiply by successive addition
e.
XCHG ; Store result in DE

DCR C ; Decrement counter
b
CNZ FACTO ; Call subroutine FACTO

tu
RET ; Return to main program

ou
.y
w
w
//w
s:
tp
ht
Page 50
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 51
ZATIN GUPTA
44 Statement:Write a program to find the Square Root of an 8 bit binary number.

The binary number is stored in memory location 4200H and store the square root
in 4201H.
Source Program:
ch
LDA 4200H : Get the given data(Y) in A register
MOV B,A : Save the data in B register
MVI C,02H : Call the divisor(02H) in C register
te
CALL DIV : Call division subroutine to get initial value(X) in D-
reg
of
REP: MOV E,D : Save the initial value in E-reg
MOV A,B : Get the dividend(Y) in A-reg
ZS
MOV C,D : Get the divisor(X) in C-reg
CALL DIV : Call division subroutine to get initial value(Y/X) in D-
reg
MOV A, D : Move Y/X in A-reg
A2
ADD E : Get the((Y/X) + X) in A-reg
MVI C, 02H : Get the divisor(02H) in C-reg
CALL DIV : Call division subroutine to get ((Y/X) + X)/2 in D-
/
reg.This is XNEW
/c
MOV A, E : Get Xin A-reg
CMP D : Compare X and XNEW
JNZ REP
STA 4201H
m
: If XNEW is not equal to X, then repeat
: Save the square root in memory
co
e.
Subroutine:
b
DIV: MVI D, 00H : Clear D-reg for Quotient

tu
NEXT:SUB C : Subtact the divisor from dividend

INR D : Increment the quotient
ou
CMP C : Repeat subtraction until the

JNC NEXT : divisor is less than dividend
RET : Return to main program
.y
Note: The square root can be taken y an iterative technique. First, an initial value
w
is assumed. Here, the initial value of square root is taken as half the value of given
number. Te new value of square root is computed by using an expression XNEW =
w
(X + Y/X)/2 where, X is the initial value of square root and Y is the given number.
Then, XNEW is compared wit initial value. If they are not equal then the above
//w
process is repeated until X is equal to XNEW after taking XNEW as initial value.
(i.e., X ←XNEW)
s:
tp
ht
Page 52
ZATIN GUPTA
Flowchart subroutine
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
Flowchart Main program

w
w
//w
s:
tp
ht
Page 53
ZATIN GUPTA
45 Statement:Write a simple program to Split a HEX data into two nibbles and
store it in memory
Source Program:
LXI H, 4200H : Set pointer data for array
ch
MOV B,M : Get the data in B-reg
MOV A,B : Copy the data to A-reg
ANI OFH : Mask the upper nibble
te
INX H : Increment address as 4201
MOV M,A : Store the lower nibble in memory
of
MOV A,B : Get the data in A-reg
ANI FOH : Bring the upper nibble to lower nibble position
ZS
RRC
RRC
RRC
RRC
A2
INX H
MOV M,A : Store the upper nibble in memory
/
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 54
ZATIN GUPTA
46 Statement: Add two 4 digit BCD numbers in HL and DE register pairs and store
result in memory locations, 2300H and 2301H. Ignore carry after 16 bit.
Sample Problem:
(HL) =3629
ch
(DE) =4738
Step 1 : 29 + 38 = 61 and auxiliary carry flag = 1
:.add 06
te
61 + 06 = 67
Step 2 : 36 + 47 + 0 (carry of LSB) = 7D
of
Lower nibble of addition is greater than 9, so add 6.
ZS
7D + 06 = 83
Result = 8367
Source program
A2
MOV A, L : Get lower 2 digits of no. 1
ADD E : Add two lower digits
/
DAA : Adjust result to valid BCD
/c
STA 2300H : Store partial result
MOV A, H : Get most significant 2 digits of number
ADC D
DAA
m
: Add two most significant digits
: Adjust result to valid BCD
co
STA 2301H : Store partial result
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 55
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 56
ZATIN GUPTA
47 Statement: Subtract the BCD number stored in E register from the number
stored in the D register.
Source Program:
MVI A,99H
ch
SUB E : Find the 99's complement of subtrahend
INR A : Find 100's complement of subtrahend
ADD D : Add minuend to 100's complement of subtrahend
te
DAA : Adjust for BCD
of
Note: When two BCD numbers are subtracted, we can use DAA instruction for
ajusting the result to BCD. Therefore, the subtraction of BCD number is carried out
ZS
10's complement or 100's complement.
The 10's complement of a decimal number is equal to the 99's complement plus 1.
The 99's complement of a number can be found by subtracting the number from
99.
A2
The steps for finding 100's complement BCD subtraction are :
/
/c
Find the 100's complement of subtrahend
Add two numbers using BCD adition
m
co
48 Statement: Write an assembly language program to multiply 2 BCD numbers
Source Program:
b e.
MVI C, Multiplier : Load BCD multiplier

MVI B, 00 : Initialize counter
tu
LXI H, 0000H : Result = 0000

MVI E, multiplicand : Load multiplicand
ou
MVI D, 00H : Extend to 16-bits

BACK: DAD D : Result Result + Multiplicand
MOV A, L : Get the lower byte of the result
.y
ADI, 00H
DAA : Adjust the lower byte of result to BCD.
w
MOV L, A : Store the lower byte of result

MOV A, H : Get the higher byte of the result
w
ACI, 00H
DAA : Adjust the higher byte of the result to BCD
//w
MOV H, A : Store the higher byte of result.

MOV A, B : [Increment
ADI 01H : counter
s:
DAA : adjust it to BCD and

MOV B,A : store it]
tp
CMP C : Compare if count = multiplier

JNZ BACK : if not equal repeat
ht
HLT : Stop
Page 57
ZATIN GUPTA
49 Statement:Write a program for displaying binary up counter. Counter should

count numbers from 00 to FFH and it should increment after every 0.5 sec.
Assume operating frequency of 8085 equal to 2MHz. Display routine is available.
Source Program:
ch
MVI C, OOH : Initialize counter
BACK: CALL Display : Call display subroutine
te
CALL Delay : Call delay subroutine
INR C : Increment counter
of
MOV A, C
CPI OOH : Check counter is > FFH
ZS
HLT : Stop
Delay Subroutine:
A2
Delay: LXI B, count : Initialize count
BACK: DCX D : Decrement count
/
MOV A, E
/c
ORA D : Logically OR D and E
JNZ BACK : If result is not 0 repeat
RET : Return to main programom
.c
be
tu
ou
.y
w
w
// w
s:
tp
ht
Page 58
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
Program flowchart
e.
Delay routine flowchart

ub
o ut
.y
w
w
//w
s:
tp
ht
Page 59
ZATIN GUPTA
50 Statement:Write a program for displaying BCD up counter. Counter should

count numbers from 00 to 99H and it should increment after every 1 sec. Assume
operating frequency of 8085 equal to 3MHz. Display routine is available.
Source Program:
ch
MVI C, OOH : Initialize counter
te
of
MOV A, C
ADI A, 0 1 : Increment counter
S
DAA : Adjust it for decimal
MOV C,A : Store count
2Z
CPI ,00 : Check count is > 99
HLT : Stop
/A
Delay Subroutine:
/c
Delay:MVI B, Multiplier-count : Initialize multiplier count
m
BACK 1:LXI D, Initialize Count
BACK: DCX D : Decrement count
co
MOV A, E
ORA D : Logically OR D and E
JNZ BACK : If result is not a, repeat
e.
DCR B : Decrement multiplier count

JNZ BACK 1 : If not zero, repeat
b
RET : Return to main program.

Operating Frequency : 3MHz
tu
ou
.y
w
w
//w
s:
tp
ht
Page 60
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
Source program flowchart
Routine flowchart
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 61
ZATIN GUPTA
51 Statement:Write a program for displaying BCD down counter. Counter should

count numbers from 99 to 00 and it should increment after every 1 sec. Assume
operating frequency of 8085 equal to 3MHz. Display routine is available
Source Program 1:
ch
MVI C, 99H : Initialize counter = 99
BACK:CALL Display : Call display subroutine
fte
ADI 99H : See Addition below
DAA : Adjust for decimal
So
CPI 99H : Compare with last count
JNZ BACK :If no, repeat
HLT
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
Source Program2:
//w

MVI C, 99H : Initialize counter = 99
s:

MOV A, C : Get count
tp
ANI 0FH : Check for lower nibble

JNZ SKIP : If it is not 0FH go to skip
MOV A,C : Else get the count
ht
SBI ,06 : Subtract 06

MOV C,A : Store the count
CPI 99H : Check it for last count
HLT : Stop
Page 62
ZATIN GUPTA
52 Statement:Write assembly language program to with proper comments for the

following: To display decimal decrementing counter (99 to 00) at port 05 H with
delay of half seconds between .each count. Write as well the delay routine giving
delay of half seconds. Operating frequency of microprocessor is 3.072 MHz.
Neglect delay for the main program.
ch
Source Program:
te
of
BACK: MOV A, C
ANI OF : Mask higher nibble
CPI OF
S
JNZ SKIP
2Z
MOV A, C
SUI 06 : Subtract 6 to adjust decimal count
MOV D, A
/A
SKIP: MOV A, C
OUT 05 : send count on output port
CALL Delay : Wait for 0.5 seconds
/c
DCR C : decrement count
MOV A, C
CPI FF
JNZ BACK
HLT
: If not zero, repeat
: Stop execution
c om
Delay subroutine:
e.
Delay: LXI D, Count

ub
Back: DCX D : 6 T-states

MOV A, D : 4 T-states
ORA E : 4 T-states
ut
JNZ Back : 10 T-states

RET
o
.y
w
w
w
s ://
tp
ht
Page 63
ZATIN GUPTA
53 Statement:The delay routine given below is in infinite loop, identify the error
and correct the program.
Delay routine with error:
DELAY : LXI H, N
ch
L1 : DCX H
JNZ L1
te
Sol.: 1) The fault in the above program is at instruction JNZ L1. This condition
always evaluates to be true hence loops keep on executing and hence infinite loop.
of
2) Reason for infinite looping: - The instruction DCX H decrease the HL pair count
S
one by one but it does not affect the zero flag. So when count reaches to OOOOH
in HL pair zero flag is not affected and JNZ L1 evaluates to be true and loop
2Z
continues. Now HL again decrements below OOOOH and HL becomes FFFFH and
thus execution continues.
/A
3) The modification in the program is as follows:
DELAY : LXI H, N :Load 16 bit count
/c
L1 : DCX H : Decrement count
MOV A, L
ORA H
JNZ L1
: logically OR Hand L
m
: If result is not 0 repeat
co
54 Statement: Convert a 2-digit BCD number stored at memory address 2200H
into its binary equivalent number and store the result in a memory location 2300H.
e.
Sample Problem
ub
(2200H) = 67H
(2300H) = 6 x OAH + 7 = 3CH + 7 = 43H
ut
Source Program:
o
LDA 2200H : Get the BCD number

.y
MOV B, A : Save it
ANI OFH : Mask most significant four bits
w
MOV C, A : Save unpacked BCDI in C register

MOV A, B : Get BCD again
w
ANI FOH : Mask least significant four bits

RRC : Convert most significant four bits into unpacked BCD2
//w
RRC
RRC
RRC
s:
MOV B, A : Save unpacked BCD2 in B register

XRA A : Clear accumulator (sum = 0)
tp
MVI D, 0AH : Set D as a multiplier of 10

Sum: ADD D : Add 10 until (B) = 0
DCR B : Decrement BCD2 by one
ht
JNZ SUM : Is multiplication complete? i if not, go back and add again

ADD C : Add BCD1
Page 64
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
b e.
tu
ou
.y
w
w
w
//
s:
tp
ht
Page 65
ZATIN GUPTA
55 Statement: Write a main program and a conversion subroutine to convert the

binary number stored at 6000H into its equivalent BCD number. Store the result
from memory location 6100H.
ch
Sample Problem: (6000) H = 8AH
1.8AH ? 64H (Decimal 100) :. Divide by 64H (Decimal 100)
te
8AH/64H ? Quotient = 1, Remainder = 26H
26H < 64H (Decimal 100) :. Go to step 2 and Digit 2 = 1
of
2.26H ? OAH (Decimal 10) :. Divide by OAH (Decimal 10)
26H/OAH ? Quotient = 3, Remainder = O8H
ZS
OSH < OAH (Decimal 10) :. Go to step 3 and Digit 1 =
3
3. Digit 0 = O8H
A2
Source Program:
/
LDA 6000H : Get the binary number in accumulator
/c
CALL SUBROUTINE : Call subroutine
m
Subroutine to convert binary number into its equivalent BCD number:
co
PUSH B : Save BC register pair contents
PUSH D : Save DE register pair contents
e.
MVI B, 64H : Load divisor decimal 100 in B register

MVI C, 0AH : Load divisor decimal 10 in C register
b
MVI D, 00H : Initialize Digit 1

tu
MVI E, 00H : Initialize Digit 2

STEP1: CMP B : Check if number < Decimal 100
ou
JC STEP 2 : if yes go to step 2

SUB B : Subtract decimal 100
INR E : update quotient
.y
JMP STEP 1 : go to step 1

STEP2: CMP C : Check if number < Decimal 10
w
JC STEP 3 : if yes go to step 3

SUB C : Subtract decimal 10
w
INR D : Update quotient

JMP STEP 2 : Continue division by 10
//w
STEP3: STA 6100H : Store Digit 0

MOV A, D : Get Digit 1
STA 6101H : Store Digit 1
s:
MOV A, E : Get Digit 2

STA 6102H : Store Digit 2
tp
POP D : Restore DE register pair

POP B : Restore BC register pair
ht
Page 66
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
om
.c
be
tu
ou
.y
w
w
//w
s:
tp
ht
Page 67
ZATIN GUPTA
56 Statement: Find the 7-segment codes for given 5 numbers from memory
location 6000H and store the result from memory location 7000H.
Sample Problem: (6000) H = 8AH
Source Program
ch
LXI H, 6200H : Initialize lookup table pointer
LXI D, 6000H : Initialize source memory pointer
LXI B, 7000H : Initialize destination memory pointer
fte
BACK: LDAX D : Get the number
MOV L, A : A point to the 7-segment code
MOV A, M : Get the 7-segment code
So
STAX B : Store the result at destination memory location
INX D : Increment source memory pointer
INX B : Increment destination memory pointer
2Z
MOV A, C
CPI O5H : Check for last number
JNZ BACK : If not repeat
/A
HLT : End of program
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 68
ZATIN GUPTA
57 Statement: Write an assembly language program to convert the contents of the

five memory locations starting from 2000H into an ASCII character. Place the
result in another five memory locations starting from 2200H.
Sample Problem
(2000H) = 1
ch
(2001H) = 2
(2002H) = 9
(2003H) = A
te
(2004H) = B
Result:(2200H) = 31
of
(2201H) = 32
(2202H) = 39
ZS
(2203H) = 41
(2204H) = 42
Source program:
A2
LXI H, 2000H : Source memory pointer
/
LXI D, 2200H : Destination memory pointer
/c
MVI C, O5H : Initialize the counter
CALL ASCII
STAX D
m
: Call subroutine ASCII
: Store result
co
INX H : Increment source memory pointer
INX D : Increment destination memory pointer
DCR C : Decrement count by 1
e.
CJNZ : if not zero, repeat

HLT : Stop program execution subroutine ASCII
b
ASCII: CPI, OAH : Check if number is OAR

tu
JNC NEXT : If yes go to next otherwise continue

ADI 30H
ou
JMP LAST
NEXT: ADI 37H
LAST: RET : Return to main program
.y
Subroutine:
w
Subroutine 'ASCII' converts a hexadecimal digit to ASCII.The digit is passed using

w
accumulator and the result is stored in accumulator.Stack starts From 27FEH to

27FDH.
//w
Note: The ASCII Code (American Standard Code for Information Interchange) is
commonly used for communication. In such cases we need to convert binary
number to its ASCII equivalent. It is a seven bit code. In this code number 0
s:
through 9 are represented as 30 through 39 respectively and letters A through Z

are represented as 41H through 5AH. Therefore, by adding 30H we can convert
tp
number into its ASCII equivalent and by adding 37H we can convert letter to its
ASCII equivalent.
ht
Page 69
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
om
.c
be
tu
ou
.y
w
w
//w
s:
tp
ht
Page 70
ZATIN GUPTA
58 Statement: convert the ASCII number in memory to its equivalent decimal

number
Source Program:
LXI H, 4150 : Point to data
ch
MOV A, M : Get operand
SUI 30 : convert to decimal
CPI 0A : Check whether it is valid decimal number
te
JC LOOP : yes, store result
MVI A, FF : No, make result=FF
of
LOOP: INX H
MOV M, A
ZS
HLT : (A) = (4151)
Note: The ASCII Code (American Standard Code for Information Interchange) is
commonly used for communication. It is a seven bit code. In this code number 0
through 9 are represented as 30 through 39 respectively and letters A through Z
A2
are represented as 41H through 5AH. Therefore, by subtracting 30H we can
convert an ASCII number into its decimal equivalent.
/
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 71
ZATIN GUPTA
59 Statement: Convert the HEX number in memory to its equivalent decimal

number
Source Program:
ch
LXI H, 4150 ; Point to data
LXI B, 0000 ; Initialize hundreds= 0, Tens=0
MOV A, M ; Get hex data to A
te
LOOP: SUI 64
JC LOOP 1
of
INR B ; hundreds= hundreds+1
JMP LOOP
ZS
LOOP 1: ADI 64 ; if subtracted extra, add it clear carry flag
LOOP 2: SUI 0A
JC LOOP 3
A2
INR C ; Tens=tens+1
JMP LOOP 2
LOOP 3: ADI 0A ; If subtracted extra, add it again
INX H ; A = Units
/
/c
MOV M, B ; store hundreds
MOV B, A ; Combine Tens in C &
m
MOV A, C ; Units in A to form a
RLC ; Single 8-bit number
RLC
co
RLC
RLC
e.
ADD B
INX H
MOV M, A ; Store tens & Units
b
HLT
tu
Note: In this experiment the number is converted to its equivalent decimal

ou
number using the following logic.

First count the number of hundreds, the number of tens & units present in that
hex number. Then add up to get the equivalent decimal number.
.y
Converting A9 we get:
A9 /64=45 Hundreds = 01
w
Since 64(100 decimal) cannot be subtracted from 45 no. of hundreds = 01. Now
count tens
w
45/0A=3B Tens = 01
Now from 09, 0A cannot be subtracted. Hence tens = 06 the decimal equivalent of
//w
A9 is 169.
s:
tp
ht
Page 72
ZATIN GUPTA
60 Statement: Convert an 8 bit hex no to its binary form & store in memory.
Source Program:
LXI H, 4150 : Initialize memory pointer
ch
MVI B, 08 : count for 8-bit
MVI A, 54
LOOP : RRC
te
JC LOOP1
MVI M, 00 : store zero it no carry
of
JMP COMMON
LOOP2: MVI M, 01 : store one if there is a carry
ZS
COMMON: INX H
DCR B : check for carry
JNZ LOOP
HLT : Terminate the program
A2
61 Statement: Write a program to output contents of B register LSB to MSB on the
/
SOD pin.
/c
Source program:
MVI C, 08H
MOV A, B
m
: Initialize count with 8
co
BACK: RRC : Rotate B register contents right
MOV B, A : Save contents of register B
JNC SKIP : If no carry skip
e.
MVI A, COH
SIM : If carry, send high on SOD
b
JMP NEXT
tu
SKIP: MVI A, 40H

SIM : If no carry, send low on SOD.
ou
NEXT: CALL DELAY : Wait for specific time

DCR C : Decrement count by 1
JNZ BACK : if count = 0 Stop, if not repeat
.y
HLT : Stop program execution

w
Delay subroutine:
w
Delay: LXI D, Count

Back: DCX D
//w
MOV A, D
ORA E
JNZ Back
s:
RET
tp
ht
Page 73
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
om
.c
be
tu
ou
.y
w
w
//w
s:
tp
ht
Page 74
ZATIN GUPTA
62 Statement: Write a program to output square wave of 1 kHz frequency on the

SOD pinof 8085 for 5 seconds. Operating frequency of 8085 is 2 MHz.
Source program
ch
LXI B, 1388H : Initialize counter with count 5000.
BACK: MVI A, COH
SIM : Send high on SOD pin
te
CALL DELAY : Wait for 0.5 msec
MVI A, 40H : Send low on SOD pin
of
CALL DELAY : wait for. 5 msec
DCX B : Decrement count by 1
ZS
MOV A, C
ORA B : Check if count = 0
A2
Delay subroutine:
/
Delay: LXI D, Count
/c
Back: DCX D
MOV A, D
ORA E
JNZ Back
m
co
RET
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 75
ZATIN GUPTA
ch
f te
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
w//
s:
tp
ht
Page 76
ZATIN GUPTA
63 Statement: An ASCII character is being received on SID pin of 8085. Write a

program in assembly language of 8085 to assemble this character and store it in
memory. Write comment for each instruction.
Source program:
ch
LXI SP, 27FFH
LXI H, 2000H : Memory pointer
RIM : Read SID
te
ANI 80H : Check D7 bit of Accumulator
CALL Delay : 1/2 bit time delay for stop bit
of
MVI B, 08H : Initialize bit counter
MVI D, 00H : Clear data register
ZS
UP1: ALL Delay : 1 bit time
RIM : Read SID line
ANI 80H : Mask bits B6 - Bo
ORA D : OR data bit with previous bits
A2
RRC
MOV D, A : Store data bit at appropriate position
DCR B
/
JNZ UP1
/c
RLC : Shift left to correct result
MOV M, A : Store result
RIM
ANI 8OH
: Read stop bit
m
co
CZ error : If not stop bit call error
HLT : Terminate program.
Delay subroutine:
e.
Delay: LXI D, Count

b
Back: DCX D
tu
MOV A, D
ORA E
ou
JNZ Back
RET
.y
w
w
//w
s:
tp
ht
Page 77
ZATIN GUPTA
ch
te
of
ZS
/A2
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 78
ZATIN GUPTA
64 Statement: Write a assembly program to transmit a message from an 8085 to a

CRT terminal for the following requirements and draw the interfacing diagram.
i) A message of 50 characters is stored as ASCII characters (without parity) in
memory locations starting at 2200H.
ii) Baud rate x 16
ch
iii) Stop bits 2
Solution Description:
fte
• CRT terminal uses normal RS 232C standard serial communication interface.
Therefore, to transmit data to CRT it is necessary to have RS 232C interface
So
at the sending end.
• Fig. shows the interfacing of 8251 with RS 232C to 8085.
• As shown in the Fig. three RS-232C signals (TxD, RxD are Ground) are used
2Z
for serial communication between the CRT terminal and the 8085 system.
• Line drivers and receivers are used to transfer logic levels from TTL logic to
RS-232C logic.
/A
• For RS-232C the voltage level +3V to +15V is defined as logic 0 and voltage
level from -3V to -15V is defined as logic 1.
•
/c
The line driver, MC 1488, converts logic 1 of TIL to approximately -9V and
logic a of TIL to approximately +9V. These levels at the receiving end are
m
again converted by the line receiver, MC1489, into TTL compatible logic.
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 79
ZATIN GUPTA
Source program:
LXI H, 2200H : Initialize memory pointer to pointer the message

MVI C, 32H : Initialize counter to send 50 characters
MVI A, 00H
ch
OUT FFH
OUT FFH : Dummy mode word
OUT FFH
fte
MVI A, 40H : Reset command word
OUT FFH : Reset 8251A
MVI A, CAH : Mode word initialization
So
OUT FFH
MVI A, 11H : Command word initialization
OUT FFH
2Z
CHECK: IN FFH
ANI 0lH : Check TxRDY
JZ CHECK : Is TxRDY I? if not, check again
/A
MOV A, M : Get the character in accumulator
OUT FEH : Send character to the transmitter
/c
JNZ CHECK : if not zero, send next character
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 80
ZATIN GUPTA
ch
te
S of
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
w
s ://
tp
ht
Page 81
ZATIN GUPTA
65 Statement: Write a assembly program to receive 25 bytes from an CRT terminal

to 8085 for the following requirements.
i) Baud rate x 16
ii) Stop bits 2
ch
te
of
2 ZS
/A
/c
m
co
b e.
tu
ou
.y
Note: Reading of status word is necessary for checking the status of RxD line of
8085 that whether receiver is ready to give data or not.
w
Source program:
w
LXI H, 2300 H : Initialize memory pointer

//w
MVI C, FFH : Initialize counter to accept 25 characters

MVI A, 00H
OUT FFH
s:
OUT FFH : Dummy mode word

OUT FFH
tp
MVI A, 40H : Reset command word

OUT FFH : Reset 8251 A
ht
MVI A, CAH : Mode word initialization

OUT FFH
MVI A, 14 H : Command word initialization
OUT FFH
CHECK: IN FFH
ANI 02 H : Check RxRDY
JZ CHECK : Is RxRDY ? If not, check again
Page 82
ZATIN GUPTA
IN FEH : Get the character

MOV M, A : save the character
DCR C : Decrement memory pointer
OUT FEH : Send character to the transmitter
ch
JNZ CHECK : If not zero, accept next character
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 83
ZATIN GUPTA
66 Statement:
Write a program to initialize 8255 in the configuration given below
Sample 1:
Write a program to initialize 8255 in the configuration given below:
1. Port A: Simple input
ch
2. Port B: Simple output
3. Port CL: Output
4. Port Cu: Input
fte
Assume address of the control word register of 8255 as 83H.
Solution:
So
2Z
/A
/c
m
SOURCE PROGRAM 1:
co
MVI A, 98H : Load control word
OUT 83H : Send control word
e.
Sample 2:
Write a program to initialize 8255 in the configuration given below:
ub
1. Port A: Output with handshake

2. Port B: Input with handshake
3. Port CL: Output
ut
4. Port Cu: Input

Assume address of the control word register of 8255 as 23H.
o
Solution:
.y
w
w
//w
s:
tp
ht
SOURCE PROGRAM 2:
MVI A, AEH : Load control word
OUT 23H : Send control word
Page 84
ZATIN GUPTA
67 Statement: Write a program to blink Port C bit 0 of the 8255. Assume address
of control word register of 8255 as 83H. Use Bit Set/Reset mode.
ch
fte
So
2Z
/A
/c
Source program:
BACK: MVI A, 0lH

OUT 83H
m
: Load bit pattern to make PCο high
: Send it to control word register
co
CALL DELAY : Call Delay subroutine
MVI A, 00H : Load bit pattern to make PCο Low
e.
OUT 83H : Send it to control word register

CALL Delay : Call Delay subroutine
JMP BACK : Repeat
ub
Delay subroutine:
ut
Delay: LXI D, Count

Back: DCX D
MOV A, D
o
ORA E
.y
JNZ Back
RET
w
w
//w
s:
tp
ht
Page 85
ZATIN GUPTA
68 Statement: Design a system (both Software and Hardware) that will cause 4
LEDs to flash 10 times when a push button switch is pressed. Use 8255. Assume
persistence of vision to be 0.1 seconds.
Source program:
ch
LXI SP, 2000 H : Initialize stack pointer
MVI A, 90H
OUT CR : Initialize 8255
fte
BACK: IN PA : [Read status
ANI 01 : of push
JNZ BACK : button]
So
MVI B, 0AH : Initialize counter
AGAIN: MVI A, 00H : Load data to light LEDs
OUT PC : Send data on port C
2Z
CALL Delay : Call. Delay of 0.1 sec
MVI A, FFH : Load data to switch off LEDs
OUT PC : Send data on port C
/A
CALL Delay : Call Delay of 0.1 sec
DCR B : Decrement count
JNZ AGAIN : If not zero repeat
/c
JMP BACK : Jump back to read status
Delay subroutine:
Delay: LXI D, Count

m
co
Back: DCX D
MOV A, D
ORA E
e.
JNZ Back
RET
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 86
ZATIN GUPTA
69 Statement: Design a microprocessor system to control traffic lights. The traffic

light arrangement is as shown in Fig. The traffic should be controlled in the
following manner.
1) Allow traffic from W to E and E to W transition for 20 seconds. 2) Give
transition period of 5 seconds (Yellow bulbs ON) 3) Allow traffic from N to 5 and 5
ch
to N for 20 seconds 4) Give transition period of 5 seconds (Yellow bulbs ON) 5)
Repeat the process.
HARDWARE FOR TRAFFIC LIGHT CONTROL
fte
So
2Z
/A
/c
Fig. shows the interfacing diagram to control 12
m
electric bulbs. Port A is used to control lights on N-S road and Port B is used to
control lights on W-E road. Actual pin connections are listed in Table 1 below.
co
e.
ub
o ut
.y
The electric bulbs are controlled by relays.

The 8255 pins are used to control relay on-off action with the help of relay driver
w
circuits. The driver circuit includes 12 transistors to drive 12 relays. Fig. also
shows the interfacing of 8255 to the system.
w
//w
s:
tp
ht
Page 87
ZATIN GUPTA
INTERFACING DIAGRAM
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
SOFTWARE FOR TRAFFIC LIGHT CONTROL

s:
tp
ht
Page 88
ZATIN GUPTA
ch
fte
So
Source program:
2Z
MVI A, 80H : Initialize 8255, port A and port B
OUT 83H (CR) : in output mode
/A
START: MVI A, 09H
OUT 80H (PA) : Send data on PA to glow R1 and R2
MVI A, 24H
/c
OUT 81H (PB) : Send data on PB to glow G3 and G4
MVI C, 28H : Load multiplier count (40ıο) for delay
m
CALL DELAY : Call delay subroutine
MVI A, 12H
co
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
e.
CALL: DELAY : Call delay subroutine

MVI A, 24H
ub
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
ut
MVI C, 28H : Load multiplier count (40ıο) for delay

o
MVI A, 12H
.y
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
w

w
JMP START
//w
Delay Subroutine:
DELAY: LXI D, Count : Load count to give 0.5 sec delay

s:
BACK: DCX D : Decrement counter

MOV A, D
tp
ORA E : Check whether count is 0

ht
DCR C : Check if multiplier zero, otherwise repeat

JNZ DELAY
Page 89
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 90
ZATIN GUPTA
70 Statement: Interface a Stepper Motor to the 8085 microprocessor system and

write an 8085 assembly language program to control the Stepper Motor.
HARDWARE FOR STEPPER MOTOR CONTROL

A stepper motor is a digital motor. It can be driven by digital signal. Fig. shows the
ch
typical 2 phase motor rated 12V /0.67 A/ph interfaced with the 8085
microprocessor system using 8255. Motor shown in the circuit has two phases,
with center-tap winding. The center taps of these windings are connected to the
fte
12V supply. Due to this, motor can be excited by grounding four terminals of the
two windings. Motor can be rotated in steps by giving proper excitation sequence
to these windings. The lower nibble of port A of the 8255 is used to generate
So
excitation signals in the proper sequence. These excitation signals are buffered
using driver transistors. The transistors are selected such that they can source
rated current for the windings. Motor is rotated by 1.80 per excitation.
2Z
INTERFACING SCHEME
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
SOFTWARE FOR STEPPER MOTOR CONTROL

As port A is used as an output port, control word for 8255 is 80H.
s:
Stepper Motor Control Program:

tp
6000H Excite code DB 03H, 06H,

ht
09H, OCH : This is the code sequence for clockwise

rotation
Page 91
ZATIN GUPTA
Subroutine to rotate a stepper motor clockwise by 360° - Set the counts:
MVI C, 32H : Set repetition count to 50ıο

START: MVI B, 04H : Counts excitation sequence
ch
BACK1: MOV A, M : Get the Excite code
OUT PORTA : Send Excite code
CALL DELAY : Wait
te
INX H : Increment pointer
DCR B : Repeat 4 times
of
JNZ BACK l
DCR C
ZS
JNZ START : Repeat 50 times
RET
Delay subroutine:
A2
Delay: LXI D, Count
Back: DCX D
/
MOV A, D
/c
ORA E
JNZ Back
RET
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 92
ZATIN GUPTA
71 Statement: Interface a 64-key matrix keyboard to the 8085 microprocessor

using 8255. Write an 8085 assembly language program to initialize 8255 and to
read the key code.
HARDWARE FOR MATRIX KEYBOARD INTERFACE
ch
Fig. shows a matrix keyboard with 64 keys connected to the 8085 microprocessor
using 8255. A matrix keyboard reduces the number of connections, thus the
number of interfacing lines. In this example, the keyboard with 64 keys, is
fte
arranged in 8 x 8 (8 rows and 8 columns) matrix. This requires sixteen lines from
the microprocessor to make all the connections instead of 64 lines if the keys are
connected individually. The interfacing of matrix keyboard requires two ports: one
So
input port and other output port. Rows are connected to the input port, port A and
columns are connected to the output port, port B.
2Z
INTERFACING SCHEME
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
SOFTWARE FOR MATRIX KEYBOARD INTERFACE

s:
Source program
tp
MVI A, 90H : Initialize Port A as input and

OUT CR : Port B as Output
ht
START: MVI A, 00 : Make all scan lines zero

OUT PB
BACK: IN PA
CPI FF : Check for key release
JNZ BACK : If not, wait for key release
CALL DELAY : Wait for key debounce
BACK 1: IN PA
Page 93
ZATIN GUPTA
CPI FF : Check for key press

JZ BACK 1 : If not, wait for key press
CALL DELAY : Wait for key debounce
MVI L, 00H : Initialize key counter
MVI C, 08H
ch
MVI B, FEH : Make one column low
NEXTCOL: MOV A, B
OUT PB
te
MVI D, 08H : Initialize row counter
IN PA : Read return line status
of
NEXTROW: RRC : Check for one row
JNC DISPLAY : If zero, goto display else continue
ZS
INR L : Increment key counter
DCR D : Decrement row counter
JNZ NEXTROW : Check for next row
MOV A, B
A2
RLC : Select the next column
MOV B, A
DCR C : Decrement column count
/
JNZ NEXTCOL : Check for last column if not repeat
/c
JMP START : Go to start
Delay subroutine:
m
co
Delay: LXI D, Count
Back: DCX D
MOV A, D
e.
ORA E
JNZ Back
b
RET
tu
ou
.y
w
w
//w
s:
tp
ht
Page 94
ZATIN GUPTA
ch
fte
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 95
ZATIN GUPTA
72 Statement: Interface an 8-digit 7 segment LED display using 8255 to the 8085
microprocessor system and write an 8085 assembly language routine to display
message on the display.
HARDWARE FOR EIGHT DIGIT SEVEN SEGMENT DISPLAY INTERFACE
ch
Fig. shows the multiplexed eight 7-segment display connected in the 8085 system
using 8255. In this circuit port A and port B are used as simple latched output
fte
ports. Port A provides the segment data inputs to the display and port B provides a
means of selecting a display position at a time for multiplexing the displays. A0-A7
lines are used to decode the addresses for 8255. For this circuit different
So
addresses are:
PA = 00H PB = 01H
PC = 02H CR = 03H.
2Z
The register values are chosen in Fig. such that the segment current is 80 mA. This
current is required to produce an average of 10 mA per segment as the displays
are multiplexed. In this type of display system, only one of the eight display
/A
position is 'ON' at any given instant. Only one digit is selected at a time by giving
low signal on the corresponding control line. Maximum anode current is 560 mA
(7-segments x 80 mA = 560 mA), but the average anode current is 70 mA.
/c
INTERFACING SCHEME
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 96
ZATIN GUPTA
SOFTWARE FOR EIGHT DIGIT SEVEN SEGMENT DISPLAY INTERFACE
For 8255, Port A and B are used as output ports. The control word format of 8255
according to hardware connections is:
ch
fte
So
Source program:
2Z
SOFTWARE TO INITIALIZE 8255:
MVI A, 80H : Load control word in AL
/A
OUT CR : Load control word in CR
/c
SUBROUTINE TO DISPLAY MESSAGE ON MULTIPLEXED LED DISPLAY:
m
SET UP REGISTERS FOR DISPLAY:
MVI B, 08H : load count

co
MVI C, 7FH : load select pattern
LXI H, 6000B : starting address of message
e.
DISPLAY MESSAGE:
ub
DISP 1: MOV A, C : select digit

OUT PB
MOV A, M : get data
ut
OUT PA : display data

CALL DELAY : wait for some time
o
DISP 1: MOV A, C
.y
RRC
MOV C, A : adjust selection pattern
w
INX H
DCR B : Decrement count
w
JNZ DISP 1 : repeat 8 times

RET
//w
Note: This "display message subroutine" must be called continuously to display

the 7-segment coded message stored in the memory from address 6000H.
s:
Delay subroutine:
tp
Delay: LXI D, Count

Back: DCX D
ht
MOV A, D
ORA E
JNZ Back
RET
Page 97
ZATIN GUPTA
73 Statement: Interface an 8 x 8 matrix keyboard to 8085 through 8279 in 2-key

lockout mode and write an assembly language program to read keycode of the
pressed key. The external clock frequency is 2MHz. Use I/O mapped I/O
technique. (Dont use any Interrupts)
HARDWARE FOR 8 x 8 MATRIX KEYBOARD INTERFACE
ch
fte
So
2Z
/A
/c
m
co
e.
ub
SOFTWARE FOR 8 x 8 MATRIX KEYBOARD INTERFACE

o ut
.y
w
w
//w
SOFTWARE FOR 8 x 8 MATRIX KEYBOARD INTERFACE

s:
The three steps needed to write the software are:

Step 1: Find keyboard/display command word.
tp
ht
Step 2: Find program clock command word
Page 98
ZATIN GUPTA
Step 3: Find Read FIFO/sensor RAM command word.
ch
Source program:
MVI A, 00H : Initialize keyboard/display
fte
OUT 81H : in encoded scan keyboard-2 keylockout mode
MVI A, 34H
So
OUT 81H : Initialize prescaler count
BACK: IN 81H : Read FIFO status word
ANI 07H : Mask bit B3 to B7
JZ BACK : If 0, key is not pressed wait for key press else read FIFO
2Z
RAM
MVI A, 40H : Initialize 8279 in read
OUT 81H : FI FO RAM mode
/A
IN 80H : Read FIFO RAM (keycode)
HLT : Stop program execution.
/c
m
FLOWCHART
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 99
ZATIN GUPTA
74 Statement: Interface an 8 x 8 matrix keyboard to 8085 through 8279 in 2-key

lockout mode and write an assembly language program to read keycode of the
pressed key. The external clock frequency is 2MHz. Use I/O mapped I/O
technique.
ch
HARDWARE FOR 8 x 8 MATRIX KEYBOARD INTERFACE(With Interrupt)
Fig. shows the interfacing of 8 x 8 matrix keyboard in interrupt driven keyboard
mode. In the interrupt driven mode interrupt line from 8279 is connected to the
fte
one of the interrupt input of 8085 except INTR. Here, INT line from 8279 is
connected to the interrupt RST 7.5 of 8085. Other signal connections are same as
in the non interrupt mode.
So
2Z
/A
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
SOFTWARE FOR 8 x 8 MATRIX KEYBOARD INTERFACE(With Interrupt)

ht
Page 100
ZATIN GUPTA
Step 3: Find Read FIFO/sensor RAM command word.
ch
fte
Source program:
So
MVI A, 00H : Initialize keyboard/display in encoded
OUT 81H : scan keyboard 2 key lockout mode
MVI A, 34H
2Z
MVI A, 0BH : Load mask pattern to enable RST 7.5
SIM : mask other interrupts
/A
EI : Enable Interrupt
HERE: JMP HERE : Wait for the interrupt
/c
Interrupt Subroutine:
MVI A, 40H
m
: Initialize 8279 in read FIFO
co
OUT 81H : RAM mode
e.

ub
Note: In the interrupt driven keyboard, when key is pressed, key code is loaded
into FIFO RAM and interrupt is generated. This interrupt signal is used to tell CPU
that there is a keycode in the FIFO RAM. CPU then initiates read command with in
ut
the interrupt service routine to read key code from the FIFO RAM.
o
FLOWCHART
.y
w
w
//w
s:
tp
ht
Page 101
ZATIN GUPTA
75 Statement:
Interface an 8 x 4 matrix keyboard to 8085 through 8279.
HARDWARE FOR INTERFACING 8x4 MATRIX KEYBOARD
ch
te
of
ZS
/ A2
/c
m
co
b e.
tu
ou
NOTE: As keyboard is having 8 rows and 4 columns, only 4 scan lines are required
and we can avoid external decoder to generate scan lines by selecting decoded
scan keyboard mode.
.y
SOFTWARE FOR INTERFACING 8x4 MATRIX KEYBOARD

w
Source program:
w

//w
MVI A, 34H
s:

tp
Interrupt Subroutine:
ht
MVI A, 40H : Initialize 8279 in read FIFO

OUT 81H : RAM mode
Page 102
ZATIN GUPTA
76 Statement:
Interface 8/7-segment digits (common cathode) to 8085 through 8279 and write
an 8085 assembly language program to display 1 to 8 on the eight seven segment
digits. External clock frequency is 3 MHz.
ch
HARDWARE FOR EIGHT SEVEN SEGMENT DIGITS INTERFACE
Fig. shows the interfacing of eight 7-segment digits to 8085 through 8279. As
shown in the figure eight display lines (Bo-B3 and Ao-A3) are buffered with the
fte
help of transistor and used to drive display digits. These buffered lines are
connected in parallel to all display digits. So, Sl and S2 lines are decoded and
decoded lines are used for selection of one of the eight digits.
So
2Z
/A
/c
m
co
e.
ub
ut
SOFTWARE FOR EIGHT SEVEN SEGMENT DIGITS INTERFACE

o
To display 1 to 8 numbers on the eight 7-segment digits we have to load 7-

.y
segment codes for 1 to 8 numbers in the corresponding display locations.

w
w
//w
s:
tp
ht

Page 103
ZATIN GUPTA
Step 3: Find display RAM command word.
ch
fte
Source program:
So
LXI B, 6200B : Initialize lookup table pointer
MVI A, 00H : Initialize keyboard/display
OUT 8IH : Mode
2Z
MVI A, 3EH : Initialize prescaler count
OUT 8IH
MVI A, 90H : Initial size 8279 in write Display
/A
OUT 8IH : RAM-mode
BACK : MOV A, M : Get the 7-segment code
/c
OUT 80H : Write 7-segment code in display RAM
INX H : Increment lookup table pointer
m
JNZ BACK : if count = 0 stop, otherwise go to back
co
e.
LOOK UP TABLE
ub
o ut
.y
w
w
//w
FLOWCHART
s:
tp
ht
Page 104
ZATIN GUPTA
77 Statement:
Interface 4 x 4 matrix keyboard and 4 digit 7-segment display and write an
tssembly language program to read keycode of the pressed key and display same
key on :he 7 segment display.
ch
HARDWARE FOR 4x4 MATRIX KEYBOARD & 4 DIGIT 7 SEGMENT DISPLAY
INTERFACE
Fig. shows interfacing diagram. Here, 4 scan lines are sufficient to scan matrix
fte
keyboard and to select display digits. Hence decoded mode is used.
So
2Z
/A
/c
m
co
e.
ub
o ut
SOFTWARE FOR 4x4 MATRIX KEYBOARD & 4 DIGIT 7 SEGMENT DISPLAY

INTERFACE
.y

w

w
//w
s:

tp
ht
Step 3: Find Read FIFO RAM command word.
Page 105
ZATIN GUPTA
Step 3: Find Write FIFO RAM command word.
ch
Source program:
fte
MVI A, 34H
So
2Z
Interrupt service routine
/A
MVI A, 40H : Initialize 8279 in read FIFO RAM mode
OUT 81H
/c
IN 80H : Get keycode
MVI H, 62H : Initialize memory pointer to point
MOV L, A
MVI A, 80H
: 7-Segment code
m
: Initialize 8279 in write display RAM mode
co
OUT 81H
MOV A, M : Get the 7 segment code
e.
EI : Enable interrupt
ub
o ut
FLOWCHARTS
.y
Source Program and Interrupt Service Routine

w
w
//w
s:
tp
ht
Page 106
ZATIN GUPTA
78 Statement: Write an assembly language program to roll message 'HELL0123'

from right to left
HARDWARE FOR ROLLING HELLO123
ch
fte
decoded lines are used for selection of one of the eight digits.
So
2Z
/A
/c
m
co
e.
ub
o ut
SOFTWARE FOR ROLLING HELLO123

.y
To roll above message we have to load 7-segment codes for characters within the
w
message and it is necessary to configure 8279 in right entry mode

w
//w
s:
tp
ht
Page 107
ZATIN GUPTA
ch
te
of
ZS
2
/A
Clear command word.
/c
Source program:
om
.c
be

MVI A, 10H : Initialize keyboard/display in right entry mode
OUT 8IH : Mode
tu

OUT 8IH
ou
MVI A, D0H : Clear Display

OUT 8IH
MVI A, 90H : Initialize 8279 in write display
.y
OUT 81H : RAM mode

w

w

w

//
s:
tp
ht
Page 108
ZATIN GUPTA
LOOK UP TABLE
ch
fte
So
2Z
/A
FLOWCHART
/c
m
co
e.
ub
o ut
.y
w
w
//w
s:
tp
ht
Page 109
ZATIN GUPTA
79 Statement: Write an assembly language program to your name from right to

left
HARDWARE FOR ROLLING HELLO123

ch
fte
decoded lines are used for selection of one of the eight digits
So
2Z
/A
/c
o m
.c
be
tu
ou
SOFTWARE FOR ROLLING THE NAME - J.BINU

.y
To roll the above namewe have to load 7-segment codes for characters within the
message and it is necessary to configure 8279 in right entry mode
w

w

//w
s:

tp
ht
Page 110
ZATIN GUPTA
ch
Clear command word.
fte
So
Source program:
2Z
/A
MVI A, 10H : Initialize keyboard/display in right entry mode
OUT 8IH : Mode
/c
OUT 8IH
m
MVI A, D0H : Clear Display
OUT 8IH
co
MVI A, 90H : Initialize 8279 in write display
OUT 81H : RAM mode
e.

ub

o ut
.y
LOOK UP TABLE
w
w
//w
s:
tp
ht
FLOWCHART
Page 111
ZATIN GUPTA
ch
te
of
2 ZS
/A
/c
m
co
b e.
tu
ou
.y
w
w
//w
s:
tp
ht
Page 112

8085 Programs List

Uploaded by

Copyright:

Available Formats

8085 Programs List

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

8085 Programs List

Uploaded by

Copyright:

Available Formats

ZATIN GUPTA

PROGRAMS FOR 8085 MICROPROCESSOR

20. Find the largest of given numbers

23. Calculate the sum of series of even numbers

25. Find the square of given number

30. Transfer contents to overlapping memory blocks

PROGRAMS FOR TRAINEES

31. Add parity bit to 7-bit ASCII characters

37. Sub routine to perform the task of DAA

39. Program to generate fibonacci number

46. Add two 4-digit BCD numbers

c.PROGRAMS IN INTERFACING & APPLICTIONS

I. Interfacing with IC 8251(Serial Communcation/USART)

61. Output byte from SOD pin

64. Transmit message using 8251

II. Interfacing with IC 8255( Programmable Periperal Interface - PPI)

67. Blink port C bit 0 of 8255

68. Flashing of LEDs

70. Stepper Motor Control

III. Interfacing with IC 8279 (Keyboard and Display Controller)

73. 8 x 8 Keyboard Interface(Without Interrupt signal)

75. 8 x 4 Matrix Keyboard Interface

LDA 4000H : Get the contents of memory location 4000Hinto accumulator

STA 2000H : Store the contents of accumulator at address 2000H

STA 4000H : Store the contents of accumulator at address 4000H

LXI H 2000H : Initialize HL register pair as a pointer to memory

LXI D 4000H : Initialize DE register pair as a pointer to memory

MOV B, M : Get the contents of memory location 2000H into B

LDAX D : Get the contents of memory location 4000H into A register.

STAX D : Store the contents of A register into memory location

HLT : Terminate program execution.

In Program 1, direct addressing instructions are used, whereas in Program 2,

LXI H 4000H : HL points 4000H

MOV H, A : Store result in H register

HLT : Terminate program execution

Program - 5b: Add two 16-bit numbers - Source Program 2

XCHG : Save first I6-bit number in DE

DAD D : Add DE and HL

HLT : Terminate program execution

instruction (DAD) is used.

4000H LXI SP, 27FFH

DAD H : Adds HL data with HL data

memory location 4300H.

4300H and 4301H.

BACK: ADD M : SUM = SUM + data

Result = 9AH + 52H + 89H + 3EH = H

4301H = 0lH Higher byte

LXI H, 4201H : Initialize pointer

MOV B, A : Sum high = 0

INR B : Add carry to MSB of SUM

DCR C : Decrement counter

STA 4300H : Store lower byte

: Terminate program execution

18 Statement:Divide 16 bit number stored in memory locations 2200H and 2201H

SHLD 2302H : Store the remainder

SHLD 2300H : Store the quotient

19 Statement:Find the number of negative elements (most significant bit 1) in a

: Store the result

21 Statement:Write a program to count number of l's in the contents of D register

22 Statement:Write a program to sort given 10 numbers from memory location