Instruction Set 8085

1. Control
2. Logical
3. Branching
4. Arithmetic
5. Data Transfer

Control Instructions

---

Opcode	Operand	Explanation of Instruction	Description
NOP	none	No operation	No operation is performed. The instruction is fetched and decoded. However no operation is executed. Example: NOP
HLT	none	Halt and enter wait state	The CPU finishes executing the current instruction and halts any further execution. An interrupt or reset is necessary to exit from the halt state. Example: HLT
DI	none	Disable interrupts	The interrupt enable flip-flop is reset and all the interrupts except the TRAP are disabled. No flags are affected. Example: DI
EI	none	Enable interrupts	The interrupt enable flip-flop is set and all interrupts are enabled. No flags are affected. After a system reset or the acknowledgement of an interrupt, the interrupt enable flipflop is reset, thus disabling the interrupts. This instruction is necessary to reenable the interrupts (except TRAP). Example: EI
RIM	none	Read interrupt mas	This is a multipurpose instruction used to read the status of interrupts 7.5, 6.5, 5.5 and read serial data input bit. The instruction loads eight bits in the accumulator with the following interpretations. Example: RIM
SIM	none	Set interrupt mask	This is a multipurpose instruction and used to implement the 8085 interrupts 7.5, 6.5, 5.5, and serial data output. The instruction interprets the accumulator contents as follows. Example: SIM

LOGICAL INSTRUCTIONS

---

Opcode	Operand	Explanation of Instruction	Description
CMP	R M	Compare register or memory with accumulator	The contents of the operand (register or memory) are M compared with the contents of the accumulator. Both contents are preserved . The result of the comparison is shown by setting the flags of the PSW as follows: if (A) < (reg/mem): carry flag is set if (A) = (reg/mem): zero flag is set if (A) > (reg/mem): carry and zero flags are reset Example: CMP B or CMP M
CPI	8-bit data	Compare immediate with accumulator	The second byte (8-bit data) is compared with the contents of the accumulator. The values being compared remain unchanged. The result of the comparison is shown by setting the flags of the PSW as follows: if (A) < data: carry flag is set if (A) = data: zero flag is set if (A) > data: carry and zero flags are reset Example: CPI 89H
ANA	R M	Logical AND register or memory with accumulator	The contents of the accumulator are logically ANDed with M the contents of the operand (register or memory), and the result is placed in the accumulator. If the operand is a memory location, its address is specified by the contents of HL registers. S, Z, P are modified to reflect the result of the operation. CY is reset. AC is set. Example: ANA B or ANA M
ANI	8-bit data	Logical AND immediate with accumulator	The contents of the accumulator are logically ANDed with the 8-bit data (operand) and the result is placed in the accumulator. S, Z, P are modified to reflect the result of the operation. CY is reset. AC is set. Example: ANI 86H
XRA	R M	Exclusive OR register or memory with accumulator	The contents of the accumulator are Exclusive ORed with M the contents of the operand (register or memory), and the result is placed in the accumulator. If the operand is a memory location, its address is specified by the contents of HL registers. S, Z, P are modified to reflect the result of the operation. CY and AC are reset. Example: XRA B or XRA M
XRI	8-bit data	Exclusive OR immediate with accumulator	The contents of the accumulator are Exclusive ORed with the 8-bit data (operand) and the result is placed in the accumulator. S, Z, P are modified to reflect the result of the operation. CY and AC are reset. Example: XRI 86H
ORA	R M	Logical OR register or memory with accumulator	The contents of the accumulator are logically ORed with M the contents of the operand (register or memory), and the result is placed in the accumulator. If the operand is a memory location, its address is specified by the contents of HL registers. S, Z, P are modified to reflect the result of the operation. CY and AC are reset. Example: ORA B or ORA M
ORI	8-bit data	Logical OR immediate with accumulator	The contents of the accumulator are logically ORed with the 8-bit data (operand) and the result is placed in the accumulator. S, Z, P are modified to reflect the result of the operation. CY and AC are reset. Example: ORI 86H
RLC	none	Rotate accumulator left	Each binary bit of the accumulator is rotated left by one position. Bit D7 is placed in the position of D0 as well as in the Carry flag. CY is modified according to bit D7. S, Z, P, AC are not affected. Example: RLC
RRC	none	Rotate accumulator right	Each binary bit of the accumulator is rotated right by one position. Bit D0 is placed in the position of D7 as well as in the Carry flag. CY is modified according to bit D0. S, Z, P, AC are not affected. Example: RRC
RAL	none	Rotate accumulator left through carry	Each binary bit of the accumulator is rotated left by one position through the Carry flag. Bit D7 is placed in the Carry flag, and the Carry flag is placed in the least significant position D0. CY is modified according to bit D7. S, Z, P, AC are not affected. Example: RAL
RAR	none	Rotate accumulator right through carry	Each binary bit of the accumulator is rotated right by one position through the Carry flag. Bit D0 is placed in the Carry flag, and the Carry flag is placed in the most significant position D7. CY is modified according to bit D0. S, Z, P, AC are not affected. Example: RAR
CMA	none	Complement accumulator	The contents of the accumulator are complemented. No flags are affected. Example: CMA
CMC	none	Complement carry	The Carry flag is complemented. No other flags are affected. Example: CMC
STC	none	Set Carry	Set Carry Example: STC

BRANCHING INSTRUCTIONS

---

Opcode	Operand	Explanation of Instruction	Description
JMP	16-bit address	Jump unconditionally	The program sequence is transferred to the memory location specified by the 16-bit address given in the operand. Example: JMP 2034H or JMP XYZ
Opcode Description Flag Status JC Jump on Carry CY = 1 JNC Jump on no Carry CY = 0 JP Jump on positive S = 0 JM Jump on minus S = 1 JZ Jump on zero Z = 1 JNZ Jump on no zero Z = 0 JPE Jump on parity even P = 1 JPO Jump on parity odd P = 0	16-bit address	Jump conditionally	The program sequence is transferred to the memory location specified by the 16-bit address given in the operand based on the specified flag of the PSW as described below. Example: JZ 2034H or JZ XYZ
Opcode Description Flag Status CC Call on Carry CY = 1 CNC Call on no Carry CY = 0 CP Call on positive S = 0 CM Call on minus S = 1 CZ Call on zero Z = 1 CNZ Call on no zero Z = 0 CPE Call on parity even P = 1 CPO Call on parity odd P = 0	16-bit address	Unconditional subroutine call	The program sequence is transferred to the memory location specified by the 16-bit address given in the operand. Before the transfer, the address of the next instruction after CALL (the contents of the program counter) is pushed onto the stack. Example: CALL 2034H or CALL XYZ
RET	none	Return from subroutine unconditionally	The program sequence is transferred from the subroutine to the calling program. The two bytes from the top of the stack are copied into the program counter,and program execution begins at the new address. Example: RET
Opcode Description Flag Status RC Return on Carry CY = 1 RNC Return on no Carry CY = 0 RP Return on positive S = 0 RM Return on minus S = 1 RZ Return on zero Z = 1 RNZ Return on no zero Z = 0 RPE Return on parity even P = 1 RPO Return on parity odd P = 0	none	Return from subroutine conditionally	The program sequence is transferred from the subroutine to the calling program based on the specified flag of the PSW as described below. The two bytes from the top of the stack are copied into the program counter, and program execution begins at the new address. Example: RZ
PCHL	none	Load program counter with HL contents	The contents of registers H and L are copied into the program counter. The contents of H are placed as the high-order byte and the contents of L as the low-order byte. Example: PCHL
RST	0-7	Restart	The RST instruction is equivalent to a 1-byte call instruction to one of eight memory locations depending upon the number. The instructions are generally used in conjunction with interrupts and inserted using external hardware. However these can be used as software instructions in a program to transfer program execution to one of the eight locations. The addresses are: Instruction Restart Address RST 0 0000H RST1 0008H RST 2 0010H RST 3 0018H RST 4 0020H RST 5 0028H RST 6 0030H RST 7 0038H The 8085 has four additional interrupts and these interrupts generate RST instructions internally and thus do not require any external hardware. These instructions and their Restart addresses are: Interrupt Restart Address TRAP 0024H RST 5.5 002CH RST 6.5 0034H RST 7.5 003CH

Arithmetic Instructions

---

Opcode	Operand	Explanation of Instruction	Description
ADD	R M	Add register or memory, to accumulator	The contents of the operand (register or memory) are added to the contents of the accumulator and the result is stored in the accumulator. If the operand is a memory location, its location is specified by the contents of the HL registers. All flags are modified to reflect the result of the addition. Example: ADD B or ADD M
ADC	R M	Add register to accumulator with carry	The contents of the operand (register or memory) and M the Carry flag are added to the contents of the accumulator and the result is stored in the accumulator. If the operand is a memory location, its location is specified by the contents of the HL registers. All flags are modified to reflect the result of the addition. Example: ADC B or ADC M
ADI	8-bit data	Add immediate to accumulator	The 8-bit data (operand) is added to the contents of the accumulator and the result is stored in the accumulator. All flags are modified to reflect the result of the addition. Example: ADI 45H
ACI	8-bit data	Add immediate to accumulator with carry	The 8-bit data (operand) and the Carry flag are added to the contents of the accumulator and the result is stored in the accumulator. All flags are modified to reflect the result of the addition. Example: ACI 45H
LXI	Reg. pair, 16-bit data	Load register pair immediate	The instruction loads 16-bit data in the register pair designated in the operand. Example: LXI H, 2034H or LXI H, XYZ
DAD	Reg. pair	Add register pair to H and L registers	The 16-bit contents of the specified register pair are added to the contents of the HL register and the sum is stored in the HL register. The contents of the source register pair are not altered. If the result is larger than 16 bits, the CY flag is set. No other flags are affected. Example: DAD H
SUB	R M	Subtract register or memory from accumulator	The contents of the operand (register or memory ) are subtracted from the contents of the accumulator, and the result is stored in the accumulator. If the operand is a memory location, its location is specified by the contents of the HL registers. All flags are modified to reflect the result of the subtraction. Example: SUB B or SUB M
SBB	R M	Subtract source and borrow from accumulator	The contents of the operand (register or memory ) and M the Borrow flag are subtracted from the contents of the accumulator and the result is placed in the accumulator. If the operand is a memory location, its location is specified by the contents of the HL registers. All flags are modified to reflect the result of the subtraction. Example: SBB B or SBB M
SUI	8-bit data	Subtract immediate from accumulator	The 8-bit data (operand) is subtracted from the contents of the accumulator and the result is stored in the accumulator. All flags are modified to reflect the result of the subtraction. Example: SUI 45H
SBI	8-bit data	Subtract immediate from accumulator with borrow	The contents of register H are exchanged with the contents of register D, and the contents of register L are exchanged with the contents of register E. Example: XCHG
INR	R M	Increment register or memory by 1	The contents of the designated register or memory) are incremented by 1 and the result is stored in the same place. If the operand is a memory location, its location is specified by the contents of the HL registers. Example: INR B or INR M
INX	R	Increment register pair by 1	The contents of the designated register pair are incremented by 1 and the result is stored in the same place. Example: INX H
DCR	R M	Decrement register or memory by 1	The contents of the designated register or memory are M decremented by 1 and the result is stored in the same place. If the operand is a memory location, its location is specified by the contents of the HL registers. Example: DCR B or DCR M
DCX	R	Decrement register pair by 1	The contents of the designated register pair are decremented by 1 and the result is stored in the same place. Example: DCX H
DAA	none	Decimal adjust accumulator	The contents of the accumulator are changed from a binary value to two 4-bit binary coded decimal (BCD) digits. This is the only instruction that uses the auxiliary flag to perform the binary to BCD conversion, and the conversion procedure is described below. S, Z, AC, P, CY flags are altered to reflect the results of the operation. If the value of the low-order 4-bits in the accumulator is greater than 9 or if AC flag is set, the instruction adds 6 to the low-order four bits. If the value of the high-order 4-bits in the accumulator is greater than 9 or if the Carry flag is set, the instruction adds 6 to the high-order four bits. Example: DAA

Data Transfer Instructions

---

Opcode	Operand	Explanation of Instruction	Description
MOV	Rd, Rs M, Rs Rd, M	Copy from source(Rs) to destination(Rd)	This instruction copies the contents of the source register into the destination register; the contents of the source register are not altered. If one of the operands is a memory location, its location is specified by the contents of the HL registers. Example: MOV B, C or MOV B, M
MVI	Rd, data M, data	Move immediate 8-bit	The 8-bit data is stored in the destination register or memory. If the operand is a memory location, its location is specified by the contents of the HL registers. Example: MVI B, 57H or MVI M, 57H
LDA	16-bit address	Load accumulator	The contents of a memory location, specified by a 16-bit address in the operand, are copied to the accumulator. The contents of the source are not altered. Example: LDA 2034H
LDAX	B/D Reg. pair	Load accumulator indirect	The contents of the designated register pair point to a memory location. This instruction copies the contents of that memory location into the accumulator. The contents of either the register pair or the memory location are not altered. Example: LDAX B
LXI	Reg. pair, 16-bit data	Load register pair immediate	The instruction loads 16-bit data in the register pair designated in the operand. Example: LXI H, 2034H or LXI H, XYZ
LHLD	16-bit address	Load H and L registers direct	The instruction copies the contents of the memory location pointed out by the 16-bit address into register L and copies the contents of the next memory location into register H. The contents of source memory locations are not altered. Example: LHLD 2040H
STA	16-bit address	16-bit address	The contents of the accumulator are copied into the memory location specified by the operand. This is a 3-byte instruction, the second byte specifies the low-order address and the third byte specifies the high-order address. Example: STA 4350H
STAX	Reg. pair	Store accumulator indirect	The contents of the accumulator are copied into the memory location specified by the contents of the operand (register pair). The contents of the accumulator are not altered. Example: STAX B
SHLD	16-bit address	Store H and L registers direct	The contents of register L are stored into the memory location specified by the 16-bit address in the operand and the contents of H register are stored into the next memory location by incrementing the operand. The contents of registers HL are not altered. This is a 3-byte instruction, the second byte specifies the low-order address and the third byte specifies the high-order address. Example: SHLD 2470H
XCHG	none	Exchange H and L with D and E	The contents of register H are exchanged with the contents of register D, and the contents of register L are exchanged with the contents of register E. Example: XCHG
SPHL	none	Copy H and L registers to the stack pointer	The instruction loads the contents of the H and L registers into the stack pointer register, the contents of the H register provide the high-order address and the contents of the L register provide the low-order address. The contents of the H and L registers are not altered. Example: SPHL
XTHL	none	Exchange H and L with top of stack	The contents of the L register are exchanged with the stack location pointed out by the contents of the stack pointer register. The contents of the H register are exchanged with the next stack location (SP+1); however, the contents of the stack pointer register are not altered. Example: XTHL
PUSH	Reg. pair	Push register pair onto stack	The contents of the register pair designated in the operand are copied onto the stack in the following sequence. The stack pointer register is decremented and the contents of the highorder register (B, D, H, A) are copied into that location. The stack pointer register is decremented again and the contents of the low-order register (C, E, L, flags) are copied to that location. Example: PUSH B or PUSH A
POP	Reg. pair	Pop off stack to register pair	The contents of the memory location pointed out by the stack pointer register are copied to the low-order register (C, E, L, status flags) of the operand. The stack pointer is incremented by 1 and the contents of that memory location are copied to the high-order register (B, D, H, A) of the operand. The stack pointer register is again incremented by 1. Example: POP H or POP A
OUT	8-bit port address	Output data from accumulator to a port with 8-bit address	The contents of the accumulator are copied into the I/O port specified by the operand. Example: OUT F8H
IN	8-bit port address	Input data to accumulator from a port with 8-bit address	The contents of the input port designated in the operand are read and loaded into the accumulator. Example: IN 8CH

Store 8-bit data in memory

---

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 memory location pointed by HL register pair (4000H)"
HLT    : "Terminate program execution"

Note: 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. 

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 accumulator"
MOV B, A    : "Save the contents into B register"
LDA 4000H   : "Get the contents of memory location 4000Hinto accumulator"
STA 2000H   : "Store the contents of accumulator at address 2000H"
MOV A, B    : "Get the saved contents back into A register"
STA 4000H   : "Store the contents of 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 B register into accumulator."
STAX D      : "Store the contents of A register into memory location 4000H."
HLT         : "Terminate program execution."

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

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"

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 –: 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 second operand"
INX H        : "HL points 4002H"
MOV M, A     : "Store result at 4002H"
HLT          : "Terminate program execution"

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.

Sample problem:
(4000H) = 15H
(4001H) = 1CH
(4002H) = B7H
(4003H) = 5AH
Result = 1C15 + 5AB7H = 76CCH
(4004H) = CCH
(4005H) = 76H
 
Source Program 1:
LHLD 4000H  : "Get first I6-bit number in HL"
XCHG        : "Save first I6-bit number in DE"
LHLD 4002H  : "Get 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 higher byte of the first number"
ADC H       : "Add 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"

Source program 2:
LHLD 4000H : Get first I6-bit number
XCHG : Save first I6-bit number in DE
LHLD 4002H : Get 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. 

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 first operand"
INX H         : "HL Points 4001H"
ADD M         : "Add second operand"
INX H         : "HL Points 4002H"
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"
INX H         : "HL Points 4003H"
MOV M, A      : "Store the higher byte of result at 4003H"
HLT           : "Terminate program execution"

Subtract two 16-bit numbers

---

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 with the most significant byte in memory location 4005H.

Sample problem:
(4000H) = 19H
(400IH) = 6AH
(4004H) = I5H (4003H) = 5CH
Result    = 6A19H – 5C15H = OE04H
(4004H) = 04H
(4005H) = OEH
Source program: 
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"
SUB L       : "Subtract lower byte of the second number"
MOV L, A    : "Store the result in L register"
MOV A, D    : "Get higher byte of the first number"
SBB H       : "Subtract higher byte of second number with borrow"
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"
HLT         : "Terminate program execution"

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"

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, 01 H  : "Add one in the number"
STA 4300H  : "Store the result"
HLT        : "Terminate program execution"

Pack the unpacked BCD numbers

---

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:
(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"

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

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"

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

Right shift, bit of data( 8 bit and 16 bit)

---

Statement: Write a program to shift an eight bit data four bits right. Assume data is in register C.

Sample problem:
(4200H) = 58
Result = (4300H) = 08 and
    (4301H) = 05
 
Source program 1: 
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 2
MOV A, B
RAR
MOV B, A
MOV A, C
RAR
MOV C, A
HLT

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

HL = 1025 = 0001 0000 0010 0101
 
    HL = 0001 0000 0010 0101
  + HL = 0001 0000 0010 0101
----------------------------
Result = 0010 0000 0100 1010                  

Alter the contents of flag register in 8085

---

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

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"

Programs For 8085 Microprocessor Level 2

Count number of one’s in a number

---

Statement: Write a program to count number of l’s in the contents of D register and store the count in the B register.

Sample problem
(2200H) =  04
(2201H) = 34H
(2202H) = A9H
(2203H) = 78H
(2204H) = 56H
Result = (2202H) = A9H

MVI B, 00H
MVI C, 08H
MOV A, D
BACK: RAR
JNC SKIP
INR B
SKIP: DCR C
JNZ BACK
HLT 

Arrange in ascending order

---

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

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"

Calculate the sum of series of even numbers

---

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
2200H= 4H
2201H= 20H
2202H= l5H
2203H= l3H
2204H= 22H
Result 22l0H= 20 + 22 = 42H
= 42H

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"

Calculate the sum of series of odd numbers

---

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

Find the square of given number

---

Statement: Find the square of the given numbers from memory location 6100H and store the result from memory location 7000H.

Sample problem
2200H = 4H
2201H= 9AH
2202H= 52H
2203H= 89H
2204H= 3FH
Result = 89H + 3FH = C8H
2300H= H Lower byte
2301H = H Higher byte

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"

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.

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             :"If 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"

Add two decimal numbers of 6 digit each

---

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.

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"

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 the another list starting from 2300H. Assume starting address of 50 number list is 2200H.

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 even number"
JNZ SKIP         :"If ODD, don’t store"
MOV A, M         :"Get the number"
STAX D           :"Store the number in 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

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.

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"