8085 programming (part1)

 1. Store 8-bit data in memory 

Statement: Store the data byte 32H into memory location 4000H.

Program 1:

MVI A, 52H  : Store 32H in the accumulator

STA 4000H  : Copy accumulator contents at address 4000H

HLT              : Terminate program execution

Program 2:

LXI H           : Load HL with 4000H

MVI M                   : Store 32H in the memory location pointed by HL register pair (4000H)

HLT              : Terminate program execution

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.

  1. Exchange the contents of memory locations

Statement: Exchange the contents of memory locations 2000H and 4000H

Program 1:

 LDA 2000H : Get the contents of memory location 2000H into the accumulator

 MOV B, A    : Save the contents into the B register

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

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

 MOV A, B    : Get the saved contents back into A register

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

Program 2:

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

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

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

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 the B register into the accumulator.

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

HLT              : Terminate program execution.

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

  1. Add two 8-bit numbers

Statement: Add the contents of memory locations 4000H and 4001H and place the result in memory location 4002H.

Sample problem

       (4000H) = 14H

       (4001H) = 89H

       Result     = 14H + 89H = 9DH

Source program

               LXI H 4000H    : HL points 4000H

               MOV A, M         : Get first operand

               INX H               : HL points 4001H

               ADD M             : Add second operand

               INX H               : HL points 4002H

               MOV M, A         : Store result at 4002H

               HLT                  : Terminate program execution

  1. Subtract two 8-bit numbers

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:

(4000H)        = 51H

(4001H)        = 19H

Result           = 51H - 19H = 38H

Source program:

       LXI H, 4000H           : HL points 4000H

       MOV A, M                 : Get first operand

       INX H                      : HL points 4001H

       SUB M                      : Subtract the second operand

       INX H                      : HL points 4002H

       MOV M, A                 : Store result at 4002H.

       HLT                          : Terminate program execution

  1. Add two 16-bit numbers

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.

Program - 5.a: Add two 16-bit numbers - Source Program 1

Sample problem:

(4000H) = 15H

(4001H) = 1CH

(4002H) = B7H

(4003H) = 5AH

Result = 1C15 + 5AB7H = 76CCH

(4004H) = CCH

(4005H) = 76H

Source Program 1:

LHLD 4000H          : Get the first I6-bit number in HL

XCHG                    : Save first I6-bit number in DE

LHLD 4002H         : Get the second I6-bit number in HL

MOV A, E               : Get lower byte of the first number

ADD L                   : Add lower byte of the second number

MOV L, A               : Store result in L register

MOV A, D              : Get a higher byte of the first number

ADC H                   : Add a higher byte of the second number with CARRY

MOV H, A               : Store result in H register

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

HLT                       : Terminate program execution

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

Source program 2:

LHLD 4000H          : Get first I6-bit number

XCHG          : Save first I6-bit number in DE

LHLD 4002H          : Get the second I6-bit number in HL

DAD D         : Add DE and HL

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

HLT              : Terminate program execution

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 instruction (DAD) is used.

  1. Add contents of two memory locations

Statement: Add the contents of memory locations 40001H and 4001H and place the result in the memory locations 4002Hand 4003H.

Sample problem:        

       (4000H) = 7FH

       (400lH)  = 89H

Result    = 7FH + 89H = lO8H

       (4002H) = 08H

       (4003H) = 0lH

Source program:

       LXI H, 4000H  : HL Points 4000H

       MOV A, M       : Get the first operand

       INX H             : HL Points 4001H

       ADD M           : Add the second operand

       INX H             : HL Points 4002H

       MOV M, A       : Store the lower byte of result at 4002H

       MVI A, 00       : Initialize higher byte result with 00H

       ADC A           : Add carry in the high byte result

       INX H             : HL Points 4003H

       MOV M, A       : Store the higher byte of result at 4003H

       HLT               : Terminate program execution

  1. Subtract two 16-bit numbers.

Statement: Add the contents of memory locations 40001H and 4001H and place the result in the memory locations 4002Hand 4003H.

Sample problem:

       (4000H) = 7FH

       (400lH)  = 89H

Result    = 7FH + 89H = lO8H

       (4002H) = 08H

       (4003H) = 0lH

Source program:

       LXI H, 4000H  : HL Points 4000H

       MOV A, M       : Get the first operand

       INX H             : HL Points 4001H

       ADD M           : Add the second operand

       INX H             : HL Points 4002H

       MOV M, A       : Store the lower byte of result at 4002H

       MVI A, 00       : Initialize higher byte result with 00H

       ADC A            : Add carry in the high byte result

       INX H             : HL Points 4003H

       MOV M, A       : Store the higher byte of result at 4003H

       HLT                : Terminate program execution

  1. Finding one's complement of a number

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

 Result = (4300B) = AAB                                        

Source program: 

LDA 4400B  : Get the number

CMA            : Complement number

STA 4300H  : Store the result

HLT              : Terminate program execution

  1. Finding Two's complement of a number

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

 Result = (4300H) = AAH + 1 = ABH

Source program:

LDA 4200H            : Get the number

CMA                      : Complement the number

ADI, 01H               : Add one in the number

STA 4300H            : Store the result

HLT                       : Terminate program execution

  1. Pack the unpacked BCD numbers

Statement: Pack the two unpacked BCD numbers stored in memory locations 4200H and 4201H and store the result in memory location 4300H. Assume the least significant digit is stored at 4200H. 

Sample problem:

       (4200H) = 04

       (4201H) = 09

 Result = (4300H) = 94

Source program

LDA 4201H                : Get the Most significant BCD digit

RLC

RLC

RLC

RLC                        : Adjust the position of the second digit (09 is changed to 90)

ANI FOH                : Make least significant BCD digit zero

MOV C, A                : store the partial result

LDA 4200H                : Get the lower BCD digit

ADD C                        : Add lower BCD digit

STA 4300H                : Store the result

HLT                        : Terminate program execution

NOTE:

       BCD NO.: The numbers "0 to 9" are called BCD (Binary Coded Decimal) numbers. A decimal number 29 can be converted into a BCD number by splitting it into two. ie. 02 and 09.

  1. Unpack a BCD number

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 digits.

Sample problem

       (4200H) = 58

Result = (4300H) = 08 and

        (4301H) = 05

Source program

LDA 4200H                        : Get the packed BCD number

ANI FOH                        : Mask lower nibble

RRC                                

RRC

RRC

RRC                                : Adjust higher BCD digit as a lower digit

STA 4301H                        : Store the partial result

LDA 4200H                        : .Get the original BCD number

ANI OFH                        : Mask higher nibble

STA 4201H                        : Store the result

HLT                                : Terminate program execution

  1. Execution format of instructions

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

4003H                LXI H, 2000H

4006H                LXI B, 1020H

4009H                CALL SUB

400CH                HLT

Subroutine program:

4100H                SUB: PUSH B

4101H                PUSH H

4102H                LXI B, 4080H

4105H                LXI H, 4090H

4108H                SHLD 2200H

4109H                DAD B

410CH                POP H

410DH                POP B

410EH                RET

 Note:

       The table given gives the instruction sequence and the contents of all registers and stack after the execution of each instruction.

  1. Right shift bit of data

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

       RAR

       RAR

       RAR

       RAR

       MOV C, A

       HLT                                  

Statement: Write a program to shift a 16-bit data, 1 bit right. Assume that data is in BC register pair.

Source program:

       MOV A, B

       RAR

       MOV B, A

       MOV A, C

       RAR

       MOV C, A

       HLT

  1. Left Shifting of a 16-bit data

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

  1. Alter the contents of the flag register in 8085

Statement: Write a set of instructions to alter the contents of flag register in 8085.

 Source program: 

PUSH PSW                : Save flags on stack

POP H                        : Retrieve flags in 'L'

MOV A, L                : Flags in accumulator

CMA                        : Complement accumulator

MOV L, A                : Accumulator in 'L'

PUSH H                : Save on stack

POP PSW                : Back to flag register

HLT                        :Terminate program execution                                           

  1. Calculate the sum of a series of numbers

Statement: Calculate the sum of a 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 a 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

  1. Multiply two 8-bit numbers 

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:

       (2200H) = 03H

       (2201H) = B2H

Result = B2H + B2H + B2H = 216H

                      = 216H

       (2300H) = 16H

       (2301H) = 02H

Source program

               LDA 2200H

               MOV E, A

               MVI D, 00                : Get the first number in DE register pair

               LDA 2201H                

               MOV C, A                : Initialize counter

               LX I H, 0000 H        : Result = 0

       BACK: DAD        D                : Result = result + first number

               DCR        C                : Decrement count

               JNZ        BACK                : If count   0 repeat

               SHLD 2300H                : Store result

               HLT                        : Terminate program execution

  1. Divide a 16-bit number by an 8-bit number 

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 the 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

  1. Find the negative numbers in a block of data. 

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

       (2200H) = 04H

       (2201H) = 56H

       (2202H) = A9H

       (2203H) = 73H

       (2204H) = 82H

Result = 02 since 2202H and 2204H contain numbers with a MSB of 1.

Source program

               LDA 2200H

               MOV C, A                : Initialize count

               MVI B, 00                : Negative number = 0

               LXI H, 2201H         : Initialize pointer

       BACK: MOV A, M                : Get the number

               ANI 80H                : Check for MSB

               JZ SKIP                : If MSB = 1

               INR B                        : Increment negative number count

        SKIP: INX H                        : Increment pointer

               DCR C                        : Decrement count

               JNZ BACK                : If count   0 repeat

               MOV A, B

               STA 2300H                : Store the result

               HLT                        : Terminate program execution

  1. Find the largest of given numbers 

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 

       (2200H) = 04H

       (2201H) = 56H

       (2202H) = A9H

       (2203H) = 73H

       (2204H) = 82H

Result = 02 since 2202H and 2204H contain numbers with an MSB of 1.

Source program

               LDA 2200H

               MOV C, A                : Initialize count

               MVI B, 00                : Negative number = 0

               LXI H, 2201H         : Initialize pointer

       BACK: MOV A, M                : Get the number

               ANI 80H                : Check for MSB

               JZ SKIP                : If MSB = 1

               INR B                        : Increment negative number count

        SKIP: INX H                        : Increment pointer

               DCR C                        : Decrement count

               JNZ BACK                : If count   0 repeat

               MOV A, B

               STA 2300H                : Store the result

               HLT                        : Terminate program execution

  1. Count number of one's in a number 

Statement: Write a program to count a number of l's in the contents of the 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

  1. Arrange in ascending order

Statement: Write a program to sort given 10 numbers from memory location 2200H in ascending order.

Source program:

               MVI B, 09                : Initialize counter     

               START                        : LXI H, 2200H: Initialize memory pointer

               MVI C, 09H                : Initialize counter 2

       BACK: MOV A, M                : Get the number

               INX H                        : Increment memory pointer

               CMP M                : Compare number with next number

               JC SKIP                : If less, don't interchange

               JZ SKIP                : If equal, don't interchange

               MOV D, M

               MOV M, A

               DCX H

               MOV M, D

               INX H                        : Interchange two numbers

       SKIP:DCR C                        : Decrement counter 2

               JNZ BACK                : If not zero, repeat

               DCR B                : Decrement counter 1

               JNZ START

               HLT                         : Terminate program execution

  1. Calculate the sum of a series of even numbers 

Statement: Calculate the sum of a 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:

       2200H= 4H

       2201H= 20H

       2202H= l5H

       2203H= l3H

       2204H= 22H

 Result 22l0H= 20 + 22 = 42H

                       = 42H

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 Bit1 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

  1. Calculate the sum of a series of odd numbers 

Statement: Calculate the sum of a 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:

       2200H = 4H

       2201H= 9AH

       2202H= 52H

       2203H= 89H

       2204H= 3FH

Result = 89H + 3FH = C8H

       2300H= H Lower byte

       2301H = H Higher byte

Source program

               LDA 2200H

               MOV C, A                : Initialize counter

               LXI H, 2201H                : Initialize pointer

               MVI E, 00                : Sum low = 0

               MOV D, E                 : Sum high = 0

       BACK: MOV A, M                : Get the number

               ANI 0lH                : Mask Bit 1 to Bit7

               JZ SKIP                : Don't add if number is even

               MOV A, E                : Get the lower byte of sum

               ADD M                : Sum = sum + data

               MOV E, A                 : Store result in E register

               JNC SKIP

               INR D                        : Add carry to MSB of SUM

       SKIP: INX H                         : Increment pointer

               DCR C                : Decrement counter

               JNZ BACK                : Check if counter   0 repeat

               MOV A, E

               STA 2300H                : Store lower byte

               MOV A, D

               STA 2301H                : Store higher byte

               HLT                        : Terminate program execution

  1. Find the square of a given number

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

  1. Search a byte in a given number

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:

               LX I H, 2000H        : Initialize memory pointer 52H

               MVI B, 52H                : Initialize counter

       BACK: MOV A, M                : Get the number

               CMP C                 : Compare with the given byte

               JZ LAST                 : Go last if match occurs

               INX H                  : Increment memory pointer

               DCR B                        : Decrement counter

               JNZ B                : I f not zero, repeat

               LXI H, 0000H

               SHLD 2200H

               JMP END                : Store 00 at 2200H and 2201H

       LAST: SHLD 2200H                : Store memory address

       END:  HLT                        : Stop

  1. Add two decimal numbers of 6 digits each 

Statement: Two decimal numbers six digits each, are stored in BCD package form. Each number occupies a sequence of bytes in the memory. The starting address of the 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.

Source Program:

               LXI H, 6000H                : Initialize pointer l to first number

               LXI D, 6l00H                : Initialize pointer2 to second number

               LXI B, 6200H        : Initialize pointer3 to result

               STC

               CMC                         : Carry = 0

       BACK: LDAX D                 : Get the digit

               ADD M                 : Add two digits

               DAA                        : Adjust for decimal

               STAX.B                : Store the result

               INX H                        : Increment pointer 1

               INX D                 : Increment pointer2

               INX B                        : Increment result pointer

               MOV A, L

               CPI 06H                : Check for last digit

               JNZ BACK                 : If not last digit repeat

               HLT                        : Terminate program execution

  1. Add each element of the array with the elements of another array

Statement: Add 2 arrays having ten 8-bit numbers each and generate a third array of results. 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:

               LXI H, 2200H                : Initialize memory pointer 1

               LXI B, 2300H                        : Initialize memory pointer 2

               LXI D, 2400H                : Initialize result pointer

       BACK: LDAX B                        : Get the number from array 2

               ADD M                        : Add it with number in array 1

               STAX D                        : Store the addition in array 3

               INX H                        : Increment pointer 1

               INX B                                : Increment pointer2

               INX D                                : Increment result pointer

               MOV A, L

               CPI 0AH                        : Check pointer 1 for last number

               JNZ BACK                        : If not, repeat

               HLT                                : Stop

  1. Separate even numbers from given numbers 

Statement: Write an assembly language program to separate even numbers from the given list of 50 numbers and store them in another list starting from 2300H. Assume starting address of the 50 number list is 2200H.

Source Program:

               LXI H, 2200H                : Initialize memory pointer l

               LXI D, 2300H                : Initialize memory pointer2

               MVI C, 32H                : Initialize counter

       BACK:MOV A, M                : Get the number

               ANI 0lH                : Check for an even number

               JNZ SKIP                : If ODD, don't store

               MOV A, M                : Get the number

               STAX        D                : Store the number in the result list

               INX D                        : Increment pointer 2

       SKIP: INX H                        : Increment pointer l

               DCR C                        : Decrement counter

               JNZ BACK                : If not zero, repeat

               HLT                        : Stop

  1. Transfer contents to overlapping memory blocks 

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.

Source Program:

       Two blocks (3000 - 30FF and 3050 - 314F) are overlapping. Therefore it is necessary to transfer last byte first and first byte last.

       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

       STAX D                        : Store byte in the destination memory block

       DCX H                        : Decrement source memory pointer

       DCX                                : Decrement destination memory pointer

       DCR C                                : Decrement counter

       JNZ BACK                         : If counter   0 repeat

       HLT                                : Stop execution

  1. Add parity bit to 7-bit ASCII characters 

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.

Source Program:

       LXI H, 2040H

       MOV C ,M                        : Counter for character

REPEAT:INX H                        : Memory pointer to character

       MOV A,M                        : Character in accumulator

       ORA A                                : ORing with itself to check parity.

       JPO PAREVEN                : If odd parity place 

       ORI 80H                         even parity in D7 (80).

PAREVEN:MOV M , A                : Store converted even parity character.

       DCR C                        : Decrement counter.

       JNZ REPEAT                        : If not zero go for next character.

       HLT                                : Terminate program execution

  1. Find the number of negative, zero & positive numbers 

Statement: A list of 50 numbers is stored in memory, starting at 6000H. Find a number of negative, zero and positive numbers from this list and store these results in memory locations 7000H, 7001H, and 7002H respectively.

Source Program:

       LXI H, 6000H                : Initialize memory pointer

       MVI C, 00H                : Initialize number counter

       MVI B, 00H                : Initialize negative number counter

       MVI E, 00H                 : Initialize zero number counter

BEGIN:MOV A, M                : Get the number

       CPI 00H                : If number = 0

       JZ ZERONUM                : Goto zeronum

       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                                                                                

ZERONUM:INR E                : Increment zero number counter

       JMP LAST                                                                                

NEGNUM:INR B                : Increment negative number counter

LAST:INX H                        : Increment memory pointer        

       INR C                        : Increment number counter        

       MOV A, C                                                                                

       CPI 32H                : If number counter = 5010 then

       JNZ BEGIN                : Store        otherwise check next number

       LXI H, 7000                : Initialize memory pointer.        

       MOV M, B                : Store        negative number.                

       INX H                                                                                        

       MOV M, E                : Store        zero number.                                

       INX H                                                                                        

       MOV M, D                : Store positive number.

       HLT                        : Terminate execution

  1. Inserting string in a given array of characters 

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.
  • Step 2: Insert four bytes at locations 10, 11, 12 and 13.

Source Program:

       LXI H, 2l31H                : Initialize pointer at the last location of array.

       LXI D, 2l35H                : Initialize another pointer to point the last location of array after insertion.

AGAIN: MOV A, M                : Get the character

       STAX D                : Store at the new location

       DCX D                : Decrement destination pointer

       DCX H                : Decrement source pointer

       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

       LXI D, 2200H        : Initialize the memory pointer to point the string to be inserted

REPE: LDAX D                : Get the character

       MOV M, A                : Store it in the array

       INX D                        : Increment source pointer

       INX H                 : Increment destination pointer

       MOV A, E                : [Check whether the 4 bytes

       CPI 04                    are inserted]

       JNZ REPE                 : if not repeat the process

       HLT                        : stop

  1. Deleting string in a given array of characters

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 i.e. from location 10 onwards.

Source Program:

LXI H, 2l0DH                :Initialize source memory pointer at the 14thlocation of the array.

LXI D, 2l09H                : Initialize destn memory pointer at the 10th location of the array.

MOV A, M                : Get the character

STAX D                : Store character at new location

INX D                        : Increment destination pointer

INX H                        : Increment source pointer

MOV A, L                : [check whether desired

CPI 32H                  bytes are shifted or not]

JNZ REPE                : if not repeat the process

HLT                        : stop

  1. Multiply two eight-bit numbers with shift and add method 

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:

               (2200)         = 1100 (0CH)

               (2201)         = 0101 (05H)

       Multiplicand         = 1100 (1210)        

       Multiplier         =  0101 (510)

       Result                 = 12 x 5 = (6010)

Source program

               LXI H, 2200                : Initialize the memory pointer

               MOV E, M                : Get multiplicand

               MVI D, 00H                : Extend to 16-bits

               INX H                        : Increment memory pointer

               MOV A, M                : Get multiplier

               LXI H, 0000                : Product = 0

               MVI B, 08H                : Initialize counter with count 8

       MULT: DAD H                        : Product = product x 2

               RAL                        

               JNC SKIP                : Is carry from multiplier 1 ?

               DAD D                        : Yes, Product =Product + Multiplicand

       SKIP:  DCR B                        : Is counter = zero        

               JNZ MULT                : no, repeat

               SHLD 2300H                : Store the result

               HLT                        : End of program

  1. Divide 16-bit number with an 8-bit number using a shifting technique

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.

Source program 

       MVI E, 00                : Quotient = 0        

       LHLD        2200H                : Get dividend        

       LDA 2300                : Get divisor

       MOV B, A                : Store        divisor

       MVI C, 08                : Count = 8

NEXT: DAD H                 : Dividend = Dividend x 2

       MOV A, E

       RLC

       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

       MOV H, A                : Yes, subtract divisor

       INR E                        : and Quotient = Quotient + 1

SKIP:DCR C                        : Count = Count - 1

       JNZ NEXT                : Is count =0 repeat

       MOV A, E

       STA 2401H                : Store Quotient

       Mov A, H

       STA 2410H                : Store remainder

       HLT                        : End of program.

  1. Sub routine to  perform the task of DAA

Statement: Assume the DAA instruction is not present. Write a subroutine that will perform the same task as DAA.

Sample Problem:

Execution of DAA instruction:

  1. If the value of the low order four bits (03-00) in the accumulator is greater than 9 or if the auxiliary carry flag is set, the instruction adds 6 '(06) to the low-order four bits.
  2. If the value of the high-order four bits (07-04) in the accumulator is greater than 9 or if the carry flag is set, the instruction adds 6(06) to the high-order four bits.          

Source Program:

       LXI SP, 27FFH        : Initialize stack pointer

       MOV E, A                : Store the contents of the accumulator

       ANI 0FH                : Mask upper nibble

       CPI 0A H                : Check if the 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

       JMP SECOND                : Go for a second check

SKIP: PUSH PSW                : Store accumulator and flag contents in the stack

       POP B            : Get the contents of accumulator in B register and flag register contents in C register

       MOV A, C                : Get flag register contents in the accumulator

       ANI 10H                 : Check for bit 4

       JZ SECOND                 : if zero, go for a second check

       MOV A, E                 : Get the number

       ADI 06                : Add 6 in the number

SECOND: MOV E, A                : Store the contents of the accumulator

       ANI FOH                : Mask lower nibble

       RRC 

       RRC

       RRC

       RRC                        : Rotate number 4 bit right

       CPI 0AH                : Check if the number is greater than 9

       JC SKIPl                 : if no go to skip 1

       MOV A, E                : Get the number

       ADI 60 H                 : Add 60 H in the number

       JMP LAST                : Go to last

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

       MOV A, E                : Get the number

       ADI 60 H                 : Add 60 H in the number

LAST: HLT

Note: To check the auxiliary carry flag it is necessary to get the flag register contents 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 beginning of the source program.

  1. Program to test RAM

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: 

       LXI H, 4000H        : Initialize memory pointer

BACK: MVI M, FFH                : Writing '1' into RAM

       MOV A, M                : Reading data        from RAM

       CPI FFH                : Check for ERROR

       JNZ ERROR                : If yes go to ERROR

       INX H                        : Increment memory pointer

       MOV A, H

       CPI SOH                : Check for last check

       JNZ BACK                : If not last, repeat

       LXI H, 4000H                : Initialize memory pointer

BACKl: MVI M, OOH                : Writing '0' into RAM

       MOV A, M                : Reading data from RAM

       CPI OOH                : Check for        ERROR

       INX H                        : Increment memory pointer

       MOV A, H                

       CPI SOH                : Check for last check

       JNZ BACKl                : If not last, repeat

       HLT                        : Stop Execution



Sim8085 - A 8085 microprocessor simulator

Sim8085
https://www.sim8085.com

Simulator, Assembler and Debugger for Intel 8085 microprocessor.

Comments

Post a Comment

Popular posts from this blog

Assignment Questions (Subject:- Microprocessor and Its Interfacing)

Microprocessor and Its Interfacing Assignment Questions   Instructions: ·          Solve any 8 questions in each section. ·          Make appropriate assumptions wherever necessary. Unit – I 1.       What is a microprocessor? What is a flag? Why are the program counter and the stack pointer 16-bit register? 2.       List the major features of 8085 microprocessor. 3.       List the allowed register pairs of 8085. 4.    What is microprocessor? Give the power supply & clock freqency of 8085 5.    List few applications of microprocessor-based system. 6.    What are the functions of an accumulator? 7.    List the 16 – bit registers of 8085 microprocessor. 8.    Define flags? What is the use of ALE? 9.       Explain the need to ...
Read more

Demultiplexing Address/Data Bus AD7- AD0

Image
Demultiplexing Address/Data Bus AD7- AD0  Pin 30 of 8085 is the ALE pin which stands for ‘Address Latch Enable’. ALE signal is used to demultiplex the lower order address bus (AD0 – AD7). Pins 12 to 19 of 8085 are AD0 – AD7 which is the multiplexed address-data bus. Multiplexing is done to reduce the number of pins of 8085. Lower byte of address (A0 – A7) are available from AD0 – AD7 (pins 12 to 19) during T1 of machine cycle. But the lower byte of address (A0 – A7), along with the upper byte A8 – A15 (pins 21 to 28) must be available during T2 and rest of the machine cycle to access memory location or I/O ports. Now ALE signal goes high at the beginning of T1 of each machine cycle and goes low at the end of T1 and remains low during the rest of the machine cycle. This high to low transition of ALE signal at the end of T1 is used to latch the lower order address byte (A0 – A7) by the latch IC 74LS373, so that the lower byte A0 – A7 is continued to be available till the end of the m...
Read more