Saturday, September 26, 2009
8085 programming (part 2)
Statement:Write an assembly language program to generate fibonacci number.
Source Program:
MVI D, COUNT : Initialize counter
MVI B, 00 : Initialize variable to store previous number
MVI C, 01 : Initialize variable to store current number
MOV A, B :[Add two numbers]
BACK: ADD C :[Add two numbers]
MOV B, C : Current number is now previous number
MOV C, A : Save result as a new current number
DCR D : Decrement count
JNZ BACK : if count 0 go to BACK
HLT : Stop.
Statement:Write a program to generate a delay of 0.4 sec if the crystal frequency is 5 MHz.
Calculation: In 8085, the operating frequency is half of the crystal frequency,
ie.Operating frequency = 5/2 = 2.5 MHz
Time for one T -state =
Number of T-states required =
= 1 x 106
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
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
Statement: Transfer ten bytes of data from one memory to another memory block. Source memory block starts from memory location 2200H where as destination memory block starts from memory location 2300H.
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
Statement: Program to calculate the factorial of a number between 0 to 8
Source program
LXI SP, 27FFH ; Initialize stack pointer
LDA 2200H ; Get the number
CPI 02H ; Check if number is greater than 1
JC LAST
MVI D, 00H ; Load number as a result
MOV E, A
DCR A
MOV C,A ; Load counter one less than number
CALL FACTO ; Call subroutine FACTO
XCHG ; Get the result in HL
SHLD 2201H ; Store result in the memory
JMP END
LAST: LXI H, 000lH ; Store result = 01
END: SHLD 2201H
HLT
Subroutine Program:
FACTO:LXI H, 0000H
MOV B, C ; Load counter
BACK: DAD D
DCR B
JNZ BACK ; Multiply by successive addition
XCHG ; Store result in DE
DCR C ; Decrement counter
CNZ FACTO ; Call subroutine FACTO
RET ; Return to main program
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:
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
CALL DIV : Call division subroutine to get initial value(X) in D-reg
REP: MOV E,D : Save the initial value in E-reg
MOV A,B : Get the dividend(Y) in A-reg
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
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
MOV A, E : Get Xin A-reg
CMP D : Compare X and XNEW
JNZ REP : If XNEW is not equal to X, then repeat
STA 4201H : Save the square root in memory
HLT : Terminate program execution
Subroutine:
DIV: MVI D, 00H : Clear D-reg for Quotient
NEXT:SUB C : Subtact the divisor from dividend
INR D : Increment the quotient
CMP C : Repeat subtraction until the
JNC NEXT : divisor is less than dividend
RET : Return to main program
Flowchart for Source Program:
Flowchart for subroutine:
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
MOV B,M : Get the data in B-reg
MOV A,B : Copy the data to A-reg
ANI OFH : Mask the upper nibble
INX H : Increment address as 4201
MOV M,A : Store the lower nibble in memory
MOV A,B : Get the data in A-reg
ANI FOH : Bring the upper nibble to lower nibble position
RRC
RRC
RRC
RRC
INX H
MOV M,A : Store the upper nibble in memory
HLT : Terminate program execution
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
(DE) =4738
Step 1 : 29 + 38 = 61 and auxiliary carry flag = 1
:.add 06
61 + 06 = 67
Step 2 : 36 + 47 + 0 (carry of LSB) = 7D
Lower nibble of addition is greater than 9, so add 6.
7D + 06 = 83
Result = 8367
Source program
MOV A, L : Get lower 2 digits of no. 1
ADD E : Add two lower digits
DAA : Adjust result to valid BCD
STA 2300H : Store partial result
MOV A, H : Get most significant 2 digits of number
ADC D : Add two most significant digits
DAA : Adjust result to valid BCD
STA 2301H : Store partial result
HLT : Terminate program execution.
Statement: Subtract the BCD number stored in E register from the number stored in the D register.
Source Program:
MVI A,99H
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
DAA : Adjust for BCD
HLT : Terminate program execution
Statement: Write an assembly language program to multiply 2 BCD numbers
Source Program:
MVI C, Multiplier : Load BCD multiplier
MVI B, 00 : Initialize counter
LXI H, 0000H : Result = 0000
MVI E, multiplicand : Load multiplicand
MVI D, 00H : Extend to 16-bits
BACK: DAD D : Result Result + Multiplicand
MOV A, L : Get the lower byte of the result
ADI, 00H
DAA : Adjust the lower byte of result to BCD.
MOV L, A : Store the lower byte of result
MOV A, H : Get the higher byte of the result
ACI, 00H
DAA : Adjust the higher byte of the result to BCD
MOV H, A : Store the higher byte of result.
MOV A, B : [Increment
ADI 01H : counter
DAA : adjust it to BCD and
MOV B,A : store it]
CMP C : Compare if count = multiplier
JNZ BACK : if not equal repeat
HLT : Stop
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:
LXI SP, 27FFH : Initialize stack pointer
MVI C, OOH : Initialize counter
BACK: CALL Display : Call display subroutine
CALL Delay : Call delay subroutine
INR C : Increment counter
MOV A, C
CPI OOH : Check counter is > FFH
JNZ BACK : If not, repeat
HLT : Stop
Delay Subroutine:
Delay: LXI B, count : Initialize count
BACK: DCX D : Decrement count
MOV A, E
ORA D : Logically OR D and E
JNZ BACK : If result is not 0 repeat
RET : Return to main program
.GIF)
Flowchart for Source Program:
Flowchart for Delay routine:
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:
LXI SP, 27FFH : Initialize stack pointer
MVI C, OOH : Initialize counter
BACK: CALL Display : Call display subroutine
CALL Delay : Call delay subroutine
MOV A, C
ADI A, 0 1 : Increment counter
DAA : Adjust it for decimal
MOV C,A : Store count
CPI ,00 : Check count is > 99
JNZ BACK : If not, repeat
HLT : Stop
Delay Subroutine:
Delay:MVI B, Multiplier-count : Initialize multiplier count
BACK 1:LXI D, Initialize Count
BACK: DCX D : Decrement count
MOV A, E
ORA D : Logically OR D and E
JNZ BACK : If result is not a, repeat
DCR B : Decrement multiplier count
JNZ BACK 1 : If not zero, repeat
RET : Return to main program.
Operating Frequency : 3MHz
Flowchart for Source Program:
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:
LXI SP, 27FFH : Initialize stack pointer
MVI C, 99H : Initialize counter = 99
BACK:CALL Display : Call display subroutine
CALL Delay : Call delay subroutine
ADI 99H : See Addition below
DAA : Adjust for decimal
CPI 99H : Compare with last count
JNZ BACK :If no, repeat
HLT
Source Program2:
LXI SP, 27FFH : Initialize stack pointer
MVI C, 99H : Initialize counter = 99
BACK: CALL Display : Call display subroutine
CALL Delay : Call delay subroutine
MOV A, C : Get count
ANI 0FH : Check for lower nibble
JNZ SKIP : If it is not 0FH go to skip
MOV A,C : Else get the count
SBI ,06 : Subtract 06
MOV C,A : Store the count
DCR C : Decrement count
CPI 99H : Check it for last count
JNZ BACK : If not, repeat
HLT : Stop
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.
Source Program:
MVI C, 99H : Initialize counter
BACK: MOV A, C
ANI OF : Mask higher nibble
CPI OF
JNZ SKIP
MOV A, C
SUI 06 : Subtract 6 to adjust decimal count
MOV D, A
SKIP: MOV A, C
OUT 05 : send count on output port
CALL Delay : Wait for 0.5 seconds
DCR C : decrement count
MOV A, C
CPI FF
JNZ BACK : If not zero, repeat
HLT : Stop execution
Delay subroutine:
Delay: LXI D, Count
Back: DCX D : 6 T-states
MOV A, D : 4 T-states
ORA E : 4 T-states
JNZ Back : 10 T-states
RET
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
L1 : DCX H
JNZ L1
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.
2) Reason for infinite looping: - The instruction DCX H decrease the HL pair count 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 continues. Now HL again decrements below OOOOH and HL becomes FFFFH and thus execution continues.
3) The modification in the program is as follows:
DELAY : LXI H, N :Load 16 bit count
L1 : DCX H : Decrement count
MOV A, L
ORA H : logically OR Hand L
JNZ L1 : If result is not 0 repeat
PROGRAMS IN CODE CONVERSION
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
(2200H) = 67H
(2300H) = 6 x OAH + 7 = 3CH + 7 = 43H
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
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.
Sample Problem: (6000) H = 8AH
1.8AH ? 64H (Decimal 100) :. Divide by 64H (Decimal 100)
8AH/64H ? Quotient = 1, Remainder = 26H
26H < 64H (Decimal 100) :. Go to step 2 and Digit 2 = 1
2.26H ? OAH (Decimal 10) :. Divide by OAH (Decimal 10)
26H/OAH ? Quotient = 3, Remainder = O8H
OSH < OAH (Decimal 10) :. Go to step 3 and Digit 1 = 3
3. Digit 0 = O8H
Source Program:
LXI SP, 27FFH : Initialize stack pointer
LDA 6000H : Get the binary number in accumulator
CALL SUBROUTINE : Call subroutine
HLT : Terminate program execution
Subroutine to convert binary number into its equivalent BCD number:
PUSH B : Save BC register pair contents
PUSH D : Save DE register pair contents
MVI B, 64H : Load divisor decimal 100 in B register
MVI C, 0AH : Load divisor decimal 10 in C register
MVI D, 00H : Initialize Digit 1
MVI E, 00H : Initialize Digit 2
STEP1: CMP B : Check if number < Decimal 100
JC STEP 2 : if yes go to step 2
SUB B : Subtract decimal 100
INR E : update quotient
JMP STEP 1 : go to step 1
STEP2: CMP C : Check if number < Decimal 10
JC STEP 3 : if yes go to step 3
SUB C : Subtract decimal 10
INR D : Update quotient
JMP STEP 2 : Continue division by 10
STEP3: STA 6100H : Store Digit 0
MOV A, D : Get Digit 1
STA 6101H : Store Digit 1
MOV A, E : Get Digit 2
STA 6102H : Store Digit 2
POP D : Restore DE register pair
POP B : Restore BC register pair
RET : Return to main program
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
LXI H, 6200H : Initialize lookup table pointer
LXI D, 6000H : Initialize source memory pointer
LXI B, 7000H : Initialize destination memory pointer
BACK: LDAX D : Get the number
MOV L, A : A point to the 7-segment code
MOV A, M : Get the 7-segment code
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 O5H : Check for last number
JNZ BACK : If not repeat
HLT : End of program
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.
Statement: convert the ASCII number in memory to its equivalent decimal number
Source Program:
LXI H, 4150 : Point to data
MOV A, M : Get operand
SUI 30 : convert to decimal
CPI 0A : Check whether it is valid decimal number
JC LOOP : yes, store result
MVI A, FF : No, make result=FF
LOOP: INX H
MOV M, A
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 are represented as 41H through 5AH. Therefore, by subtracting 30H we can convert an ASCII number into its decimal equivalent.
Statement: Convert the HEX number in memory to its equivalent decimal number
Source Program:
LXI H, 4150 ; Point to data
LXI B, 0000 ; Initialize hundreds= 0, Tens=0
MOV A, M ; Get hex data to A
LOOP: SUI 64
JC LOOP 1
INR B ; hundreds= hundreds+1
JMP LOOP
LOOP 1: ADI 64 ; if subtracted extra, add it clear carry flag
LOOP 2: SUI 0A
JC LOOP 3
INR C ; Tens=tens+1
JMP LOOP 2
LOOP 3: ADI 0A ; If subtracted extra, add it again
INX H ; A = Units
MOV M, B ; store hundreds
MOV B, A ; Combine Tens in C &
MOV A, C ; Units in A to form a
RLC ; Single 8-bit number
RLC
RLC
RLC
ADD B
INX H
MOV M, A ; Store tens & Units
HLT
Note: In this experiment the number is converted to its equivalent decimal 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.
Converting A9 we get:
A9 /64=45 Hundreds = 01
Since 64(100 decimal) cannot be subtracted from 45 no. of hundreds = 01. Now count tens
45/0A=3B Tens = 01
Now from 09, 0A cannot be subtracted. Hence tens = 06 the decimal equivalent of A9 is 169.
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
Labels: 8085, assembly language, microprocessors
i'm doing my mini project..
and my problem is to make 2 7-sengment count down...
can u help me by doing the progrm..
Subscribe to Post Comments [Atom]
<< Home
Subscribe to Posts [Atom]
