1.
Statement: Write an ALP using 8085 to evaluate the expression C=A +B
2 2
Let ‘A’ be Data#1 and ‘B’ be Data#2
Source program 1:
MVI B, Data#1 ; Data #1 is stored in register B
MOV C, B ; Copy of Data #1 is made in register C
MVI D, Data#2 ; Data #2 is stored in register D
MOV E,D ; Copy of Data #2 is made in register E
XRA A ; Accumulator content is cleared
Again: ADD B ]
DCR C } A2 is calculated by repeated Addition
JNZ Again ]
MOV H,A ; Calculated A2 value is stored in register H
XRA A ; Accumulator content is cleared
Loop: ADD D ]
DCR E } B2 is calculated by repeated Addition
JNZ Loop ]
ADD H ; A2+ B2 is determined, by adding result in A and register content H
STA 4200H ; Result is stored in memory location 4200H
4. Calculate the sum of series of numbers(8085)
Statement: Calculate the sum of series of numbers. The length of the series is
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
memory location 4300H.
b. Consider the sum to be 16 bit number. Store the sum at memory locations
4300H and 4301H.
a. Sample problem
4200H = 04H
4201H = 10H
4202H = 45H
4203H = 33H
4204H = 22H
Result = 10 +41 + 30 + 12 = H
4300H = H
Source program:
LDA 4200H
MOV C, A : Initialize counter
SUB A : sum = 0
LXI H, 420lH : Initialize pointer
BACK: ADD M : SUM = SUM + data
INX H : increment pointer
DCR C : Decrement counter
JNZ BACK : if counter 0 repeat
STA 4300H : Store sum
HLT : Terminate program execution
b. Sample problem
4200H = 04H
420lH = 9AH
4202H = 52H
4203H = 89H
4204H = 3EH
Result = 9AH + 52H + 89H + 3EH = H
4300H = B3H Lower byte
4301H = 0lH Higher byte
Source program:
LDA 4200H
MOV C, A : Initialize counter
LXI H, 4201H : Initialize pointer
SUB A :Sum low = 0
MOV B, A : Sum high = 0
BACK: ADD M : Sum = sum + data
JNC SKIP
INR B : Add carry to MSB of SUM
SKIP: INX H : Increment pointer
DCR C : Decrement counter
JNZ BACK : Check if counter 0 repeat
STA 4300H : Store lower byte
MOV A, B
STA 4301H : Store higher byte
HLT :Terminate program execution
5. 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
(2200H) = 60H
(2201H) = A0H
(2202H) = l2H
Result = A060H/12H = 8E8H Quotient
and 10H remainder
(2300H) = E8H
(2301H) = 08H
(2302H= 10H
(2303H) 00H
Source program
LHLD 2200H : Get the dividend
LDA 2202H : Get the divisor
MOV C, A
LXI D, 0000H : Quotient = 0
BACK: MOV A, L
SUB C : Subtract divisor
MOV L, A : Save partial result
JNC SKIP : if CY 1 jump
DCR H : Subtract borrow of previous
subtraction
SKIP: INX D : Increment quotient
MOV A, H
CPI, 00 : Check if dividend < divisor
JNZ BACK : if no repeat
MOV A, L
CMP C
JNC BACK
SHLD 2302H : Store the remainder
XCHG
SHLD 2300H : Store the quotient
HLT : Terminate program
execution
6. Count number of one's in a number (8085)
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
MVI C, 08H
MOV A, D
BACK: RAR
JNC SKIP
INR B
SKIP: DCR C
JNZ BACK
HLT
8. 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 1:
2200H = 4H
2201H= 9AH
2202H= 52H
2203H= 89H
2204H= 3FH
Result = 89H + 3FH = C8H
2300H= H Lower byte
2301H = H Higher byte
LDA 2200H
MOV C, A : Initialize counter
MVI B, 00H : sum = 0
LXI H, 2201H : Initialize pointer
BACK: MOV A, M : Get the number
ANI 0lH : Mask Bit l to Bit7
JNZ SKIP : Don't add if number is ODD
MOV A, B : Get the sum
ADD M : SUM = SUM + data
MOV B, A : Store result in B register
SKIP: INX H : increment pointer
DCR C : Decrement counter
JNZ BACK : if counter 0 repeat
STA 2210H : store sum
HLT : Terminate program execution
10. Find the square of given number (8085)
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
LXI D, 6100H : Initialize source memory pointer
LXI B, 7000H : Initialize destination memory pointer
BACK: LDAX D : Get the number
MOV L, A : A point to the square
MOV A, M : Get the square
STAX B : Store the result at destination memory location
INX D : Increment source memory pointer
INX B : Increment destination memory pointer
MOV A, C
CPI 05H : Check for last number
JNZ BACK : If not repeat
HLT : Terminate program execution
11.Arrange in DESCENDING Order (8085)
Statement: Arrange an array of 8 bit unsigned no in descending order
Source Program:
START:MVI B, 00 ; Flag = 0
LXI H, 4150 ; Count = length of array
MOV C, M
DCR C ; No. of pair = count -1
INX H ; Point to start of array
LOOP:MOV A, M ; Get kth element
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
MOV M, A ;
DCR H
MOV M, D
INX H
MVI B, 01H ; Flag=1
LOOP 1:DCR C ; count down
JNZ LOOP ;
DCR B ; is flag = 1?
JZ START ; do another sort, if yes
HLT ; If flag = 0, step execution
12. 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.
Sample problem 1:
(2200H) = 67H
(2300H) = 6 x OAH + 7 = 3CH + 7 = 43H
Flowchart for program
Source program :
LDA 2200H : Get the BCD number
MOV B, A : Save it
ANI OFH : Mask most significant four bits
MOV C, A : Save unpacked BCDI in C register
MOV A, B : Get BCD again
ANI FOH : Mask least significant four bits
RRC : Convert most significant four bits into unpacked
BCD2
RRC
RRC
RRC
MOV B, A : Save unpacked BCD2 in B register
XRA A : Clear accumulator (sum = 0)
MVI D, 0AH : Set D as a multiplier of 10
Sum: ADD D : Add 10 until (B) = 0
DCR B : Decrement BCD2 by one
JNZ SUM : Is multiplication complete? i if not, go back
and add again
ADD C : Add BCD1
STA 2300H : Store the result
HLT : Terminate program execution
13. 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
(2001H) = 2
(2002H) = 9
(2003H) = A
(2004H) = B
Result:(2200H) = 31
(2201H) = 32
(2202H) = 39
(2203H) = 41
(2204H) = 42
Source program :
LXI SP, 27FFH : Initialize stack pointer
LXI H, 2000H : Source memory pointer
LXI D, 2200H : Destination memory pointer
MVI C, O5H : Initialize the counter
BACK: MOV A, M : Get the number
CALL ASCII : Call subroutine ASCII
STAX D : Store result
INX H : Increment source memory pointer
INX D : Increment destination memory pointer
DCR C : Decrement count by 1
CJNZ : if not zero, repeat
HLT : Stop program execution subroutine ASCII
ASCII: CPI, OAH : Check if number is OAR
JNC NEXT : If yes go to next otherwise continue
ADI 30H
JMP LAST
NEXT: ADI 37H
LAST: RET : Return to main program
Subroutine:
Subroutine 'ASCII' converts a hexadecimal digit to ASCII.The digit is
passed using accumulator and the result is stored in accumulator.Stack
starts From 27FEH to 27FDH.
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 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
number into its ASCII equivalent and by adding 37H we can convert letter to its ASCII equivalent.
14. HEX to binary conversion(8085)
Statement: Convert an 8 bit hex no to its binary form & store in memory.
Source Program:
LXI H, 4150 : Initialize memory pointer
MVI B, 08 : count for 8-bit
MVI A, 54
LOOP : RRC
JC LOOP1
MVI M, 00 : store zero it no carry
JMP COMMON
LOOP2: MVI M, 01 : store one if there is a carry
COMMON: INX H
DCR B : check for carry
JNZ LOOP
HLT : Terminate the program
15. Stepper Motor Control
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
motor is a digital motor. It can be driven by
digital signal. Fig. shows the 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 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 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
SOFTWARE FOR STEPPER MOTOR CONTROL
As port A is used as an output port, control word for 8255 is 80H.
Stepper Motor Control Program:
6000H Excite code DB 03H, 06H,
09H, OCH : This is the code sequence for clockwise rotation
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
LXI H, 6000H : Initialize pointer
BACK1: MOV A, M : Get the Excite code
OUT PORTA : Send Excite code
CALL DELAY : Wait
INX H : Increment pointer
DCR B : Repeat 4 times
JNZ BACK l
DCR C
JNZ START : Repeat 50 times
RET
INTERFACING SCHEME
Delay subroutine:
Delay: LXI D, Count
Back: DCX D
MOV A, D
ORA E
JNZ Back
RET
16. 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 to N for 20 seconds 4) Give transition
period of 5 seconds (Yellow bulbs ON) 5) Repeat the process.
HARDWARE FOR TRAFFIC LIGHT CONTROL
Fig. shows the interfacing diagram to control 12 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.
The electric bulbs are controlled by relays. The 8255
pins are used to control relay on-off action with the
help of relay driver circuits. The driver circuit
includes 12 transistors to drive 12 relays. Fig. also
shows the interfacing of 8255 to the system.
INTERFACING DIAGRAM
SOFTWARE FOR TRAFFIC LIGHT CONTROL
Source Program 1:
MVI A, 80H : Initialize 8255, port A and port B
OUT 83H (CR) : in output mode
START: MVI A, 09H
OUT 80H (PA) : Send data on PA to glow R1 and R2
MVI A, 24H
OUT 81H (PB) : Send data on PB to glow G3 and G4
MVI C, 28H : Load multiplier count (40ıο) for delay
CALL DELAY : Call delay subroutine
MVI A, 12H
OUT (81H) PA : Send data on Port A to glow Y1 and Y2
OUT (81H) PB : Send data on port B to glow Y3 and Y4
MVI C, 0AH : Load multiplier count (10ıο) for delay
CALL: DELAY : Call delay subroutine
MVI A, 24H
OUT (80H) PA : Send data on port A to glow G1 and G2
MVI A, 09H
OUT (81H) PB : Send data on port B to glow R3 and R4
MVI C, 28H : Load multiplier count (40ıο) for delay
CALL DELAY : Call delay subroutine
MVI A, 12H
OUT PA : Send data on port A to glow Y1 and Y2
OUT PB : Send data on port B to glow Y3 and Y4
MVI C, 0AH : Load multiplier count (10ıο) for delay
CALL DELAY : Call delay subroutine
JMP START
Delay Subroutine:
DELAY: LXI D, Count : Load count to give 0.5 sec delay
BACK: DCX D : Decrement counter
MOV A, D
ORA E : Check whether count is 0
JNZ BACK : If not zero, repeat
DCR C : Check if multiplier zero, otherwise repeat
JNZ DELAY
RET : Return to main program
** Extra program which I found :
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 1:
2200H= 4H
2201H= 20H
2202H= l5H
2203H= l3H
2204H= 22H
Result 22l0H= 20 + 22 = 42H
= 42H
Flowchart for program
Source program :
LDA 2200H
MOV C, A : Initialize counter
MVI B, 00H : sum = 0
LXI H, 2201H : Initialize pointer
BACK: MOV A, M : Get the number
ANI 0lH : Mask Bit l to Bit7
JNZ SKIP : Don't add if number is
ODD
MOV A, B : Get the sum
ADD M : SUM = SUM + data
MOV B, A :
Store result in B register
SKIP: INX H : increment pointer
DCR C : Decrement counter
JNZ BACK : if counter 0 repeat
STA 2210H : store sum
HLT : Terminate program execution
