Assembly Language Programming (8085)

Assembly language programming for the 8085 microprocessor involves writing low-level code that directly controls the hardware. This type of programming is essential for understanding how microprocessors work, optimizing performance, and implementing critical real-time applications. The 8085 microprocessor, with its simple architecture and instruction set, is an excellent starting point for learning assembly language programming.

Instruction Set

The instruction set of the 8085 microprocessor comprises various commands that dictate the processor's operations. These instructions are categorized into five main groups, each serving a distinct purpose:

Data Transfer Group
Arithmetic Group
Logical Group
Branch Control Group
Control Group

To write Assembly Language Programs, we should be familiar with certain instructions. Here is a review of these instructions:

Data Transfer Group

The Data Transfer Group includes instructions that handle the movement of data between registers, memory, and I/O devices. These instructions are crucial for the effective manipulation of data within the system.

The addressing modes in this group specify how the operand is accessed. One of the most common modes is the Immediate Mode, where the operand is included directly in the instruction, enabling rapid execution without delay.

Here are some key instructions under the immediate addressing mode:

MVI B, 25H:
The "MVI" instruction stands for "Move Immediate," indicating that the data (25H) is moved directly into the specified register (B).
Format: MVI [destination], [source]
Operation: B ← 25H
Explanation: This instruction places the hexadecimal value 25 directly into the B register. The "I" in "MVI" signifies that the operand is immediate, meaning it is provided directly in the instruction itself.
LXI B, 2000H:
The "LXI" instruction stands for "Load Register Pair Immediate," indicating that the data (2000H) is loaded directly into a specified register pair.
Format: LXI [register pair], [data]
Operation: B ← 20H, C ← 00H
Explanation: This instruction loads the immediate 16-bit data (2000H) into the B-C register pair. Here, the higher byte (20H) is loaded into register B, and the lower byte (00H) is loaded into register C. The "X" in "LXI" denotes that the instruction deals with a register pair.
MVI M, 25H:
In this instruction, "M" stands for memory. The memory location is defined by the address pointed to by the H-L register pair.
Format: MVI M, [data]
Operation: (HL) ← 25H
Explanation: This instruction loads the immediate value 25H into the memory location pointed to by the H-L register pair. For instance, if the H-L pair is pointing to the memory address C500, the value 25H will be stored at that specific memory location. The use of "M" indicates that the data is being moved directly into the memory address defined by the contents of the H-L register pair.

Now we have the Register Addressing Mode. In this mode, data is transferred through registers. The following instructions fall under this category:

MOV B, C:
This instruction moves the data from register C to register B.
Format: MOV [destination], [source]
Operation: B ← C
Explanation: The data in register C is transferred to register B. This operation is useful when you need to copy data between registers without altering the original data in the source register (C in this case).
MOV B, M:
This instruction moves the data from the memory location addressed by the H-L register pair to register B.
Format: MOV [destination], [source]
Operation: B ← (HL)
Explanation: The data in the memory location pointed to by the H-L register pair is transferred to register B. This instruction is useful for accessing data stored in memory and moving it to a register for further processing.
MOV M, C:
This instruction moves the data from register C to the memory location addressed by the H-L register pair.
Format: MOV [destination], [source]
Operation: (HL) ← C
Explanation: The data in register C is transferred to the memory location specified by the H-L register pair. This instruction is useful for storing data from a register into a specific memory address for later use. For instance, if the H-L pair points to the memory address 3000H, the data in register C will be moved to this address.

Now the following instructions come under the high-level instructions:

LDA 2000H:
This instruction loads the accumulator with the data from the memory location 2000H.
Format: LDA [address]
Operation: A ← (2000H)
Explanation: The "LDA" instruction stands for "Load Accumulator." Although the accumulator (A) is an 8-bit register, the address 2000H is 16-bit, indicating the location in memory from which data is to be fetched. This instruction reads the data from the specified memory address (2000H) and loads it into the accumulator for immediate use in subsequent operations.
STA 2000H:
This instruction stores the contents of the accumulator into the memory location 2000H.
Format: STA [address]
Operation: (2000H) ← A
Explanation: The "STA" instruction stands for "Store Accumulator." It takes the data in the accumulator and writes it to the specified memory address. For instance, if the accumulator contains the value 5AH, executing STA 2000H will store this value at the memory location 2000H.
LDAX B:
This instruction loads the accumulator with the contents of the memory location addressed by the B-C register pair.
Format: LDAX [register pair]
Operation: A ← (BC)
Explanation: The "LDAX" instruction stands for "Load Accumulator Indirect." It fetches data from the memory address specified by the B-C register pair and loads it into the accumulator. If the B-C register pair points to address 3000H, executing LDAX B will load the data from memory location 3000H into the accumulator.
STAX B:
This instruction stores the contents of the accumulator into the memory location addressed by the B-C register pair.
Format: STAX [register pair]
Operation: (BC) ← A
Explanation: The "STAX" instruction stands for "Store Accumulator Indirect." It takes the data in the accumulator and writes it to the memory address specified by the B-C register pair. If the accumulator contains the value 3FH and the B-C pair points to address 4000H, executing STAX B will store 3FH at memory location 4000H.

Arithmetic Group

The Arithmetic Group includes instructions that perform various arithmetic operations such as addition, subtraction, multiplication, and division.

We have the following instructions:

ADD B:
In microprocessor instructions, the operand is fixed to register A, so it does not need to be included in the instruction, resulting in a shorter instruction length.
Operation: A ← A + B
Explanation: This instruction adds the contents of register B to register A, updating the value in register A with the sum.
ADD M:
Here, M represents a memory location where data is stored.
Operation: A ← A + [data at memory location M]
Explanation: This instruction adds the data stored at memory location M to the contents of register A, updating the value in register A with the sum.
H and L Pair: In some microprocessor architectures like Intel 8085, the `ADD M` instruction indirectly uses the H and L registers. The memory address specified by the HL pair (H-L register pair) points to the memory location M. So, the data at the memory location addressed by HL is added to register A.
SUB B:
This instruction subtracts the value in register B from the contents of register A.
Operation: A ← A - B
Explanation: The SUB B instruction performs subtraction by subtracting the value in register B from the contents of register A, updating the result in register A.
SUB M:
Here, M represents a memory location where data is stored.
Operation: A ← A - [data at memory location M]
Explanation: This instruction subtracts the data stored at memory location M from the contents of register A, updating the value in register A with the difference.
H and L Pair: Similar to the ADD M instruction, in architectures like Intel 8085, the `SUB M` instruction indirectly uses the H and L registers. The memory address specified by the HL pair (H-L register pair) points to the memory location M, from which data is subtracted from register A.
INR B:
This instruction increments the value in register B by 1.
Operation: B ← B + 1
Explanation: The INR B instruction increases the value in register B by 1, updating the result in register B.
DCR B:
This instruction decrements the value in register B by 1.
Operation: B ← B - 1
Explanation: The DCR B instruction decreases the value in register B by 1, updating the result in register B.
INR M:
Here, M represents a memory location where data is stored.
Operation: [data at memory location M] ← [data at memory location M] + 1
Explanation: This instruction increments the data stored at memory location M by 1, updating the value at that memory location.
H and L Pair: In architectures like Intel 8085, the `INR M` instruction indirectly uses the H and L registers. The memory address specified by the HL pair (H-L register pair) points to the memory location M, where data is incremented by 1.
DCR M:
Here, M represents a memory location where data is stored.
Operation: [data at memory location M] ← [data at memory location M] - 1
Explanation: This instruction decrements the data stored at memory location M by 1, updating the value at that memory location.
H and L Pair: Similar to `INR M`, the `DCR M` instruction in certain architectures indirectly uses the H and L registers to access and modify data at memory location M.
INX B:
This instruction increments the BC register pair by 1.
Operation: BC ← BC + 1
Explanation: The INX B instruction increases the BC register pair by 1, updating the result in the BC register pair.
DCX B:
This instruction decrements the BC register pair by 1.
Operation: BC ← BC - 1
Explanation: The DCX B instruction decreases the BC register pair by 1, updating the result in the BC register pair.
CMP B (Compare with Register B):
In microprocessor instructions, the CMP B instruction compares the contents of the accumulator with the contents of register B.
Operation: A - B
Explanation: This instruction subtracts the contents of register B from the contents of the accumulator, but the result is not stored. Instead, the flags are updated based on the result of the subtraction.
- If the accumulator is greater than the contents of register B, the carry flag (CY) is reset (CY = 0) and the zero flag (Z) is reset (Z = 0).
- If the accumulator is equal to the contents of register B, the zero flag (Z) is set (Z = 1).
- If the accumulator is less than the contents of register B, the carry flag (CY) is set (CY = 1).

Branch Control Group

The Branch Control Group in the 8085 microprocessor contains instructions that change the sequence of execution of instructions in a program. These instructions are essential for implementing control flow constructs such as loops, conditionals, and function calls. The primary function of branch control instructions is to alter the program counter (PC), which dictates the address of the next instruction to be executed.

JNC (Jump if No Carry):
In microprocessor instructions, the condition is checked for the Carry flag (CY). If the CY flag is not set (no carry occurred), the program jumps to the specified address or label.
Operation: Conditional jump to specified address if CY flag is not set (no carry occurred).
Explanation: This instruction checks the Carry flag (CY) and jumps to the specified address or label if the CY flag is not set (indicating no carry occurred during the previous operation). Otherwise, the program continues sequential execution without jumping.
RCC (Return on Carry Clear):
In microprocessor instructions, the condition is checked for the Carry flag (CY). If the CY flag is not set (no carry occurred), the program returns from the subroutine to the address stored in the stack.
Operation: Conditional return from subroutine if CY flag is not set (no carry occurred).
Explanation: This instruction checks the Carry flag (CY) and returns from the subroutine to the address stored in the stack if the CY flag is not set (indicating no carry occurred during the previous operation). Otherwise, the program continues sequential execution within the subroutine.

Control Group

The Control Group in the 8085 microprocessor includes instructions that manage the flow of data and control within the processor. These instructions are crucial for handling input/output operations, enabling interrupts, and controlling various aspects of the microprocessor's operation.

HLT (Halt):
In microprocessor instructions, the HLT instruction is used to halt or stop the execution of the program.
Operation: Halts the program execution.
Explanation: This instruction causes the microprocessor to stop executing instructions and enter a halted state, suspending program execution until the system is reset or another interrupt occurs.

There are many instructions, about 70 or more, but we are only discussing those that are relevant for writing basic assembly language programs.

Categorization of Microprocessor Instructions by Byte Length

As we will write programs in assembly language, it is important to know the byte length of the instructions so that we can accurately fill the memory location column of our program.

One-Byte Instructions

One-byte instructions consist solely of an opcode and operate directly on specific registers or implied operands. They do not require any additional data bytes.

MOV B, C: Moves the contents of register C to register B.
MOV B, M: Moves the contents of the memory location pointed to by the HL register pair to register B.
MOV M, C: Moves the contents of register C to the memory location pointed to by the HL register pair.
LDAX B: Loads the contents of the memory location pointed to by the BC register pair into the accumulator.
STAX B: Stores the contents of the accumulator in the memory location pointed to by the BC register pair.
ADD B: Adds the contents of register B to the accumulator.
ADD M: Adds the contents of the memory location pointed to by the HL register pair to the accumulator.
SUB B: Subtracts the contents of register B from the accumulator.
SUB M: Subtracts the contents of the memory location pointed to by the HL register pair from the accumulator.
INR B: Increments the contents of register B by 1.
DCR B: Decrements the contents of register B by 1.
INR M: Increments the contents of the memory location pointed to by the HL register pair by 1.
DCR M: Decrements the contents of the memory location pointed to by the HL register pair by 1.
INX B: Increments the BC register pair by 1.
DCX B: Decrements the BC register pair by 1.

Two-Byte Instructions

Two-byte instructions consist of an opcode followed by a single byte of data. This additional byte provides immediate data or an 8-bit operand.

MVI B, 25H: Moves immediate data 25H to register B.
First byte: Opcode for MVI B.
Second byte: Immediate data 25H.
MVI M, 25H: Moves immediate data 25H to the memory location pointed to by the HL register pair.
First byte: Opcode for MVI M.
Second byte: Immediate data 25H.
JNC (Jump if No Carry): Conditional jump instruction in the 8085 microprocessor instruction set.
First byte: Opcode for JNC.
Second byte: Address or label to jump to if the Carry flag (CY) is not set (no carry occurred).

Three-Byte Instructions

Three-byte instructions consist of an opcode followed by two bytes of data. These two bytes typically represent a 16-bit address.

LXI B, 2000H: Loads the BC register pair with immediate 16-bit data 2000H.
First byte: Opcode for LXI B.
Second byte: Lower-order byte of the address (00H).
Third byte: Higher-order byte of the address (20H).
LDA 2000H: Loads the accumulator with the contents of memory location 2000H.
First byte: Opcode for LDA.
Second byte: Lower-order byte of the address (00H).
Third byte: Higher-order byte of the address (20H).
STA 2000H: Stores the contents of the accumulator in memory location 2000H.
First byte: Opcode for STA.
Second byte: Lower-order byte of the address (00H).
Third byte: Higher-order byte of the address (20H).

Assembly Language Programs

1- Write a Program for Addition of two 8-bit Hexa-decimal Numbers and Store the Result at 3050H Location. (Without Carry)

Suppose the first number is 32H and the second number is 54H. The addition of these two numbers will be 32H + 54H = 86H.
We start our program from the memory location 3000H, so 3000H will be the starting memory location.

                    
Memory Location  |   Instruction   |    Comments
-----------------|-----------------|---------------------------------------------
  3000H          |  MVI A, 32H     |    ; Load 32H into the accumulator (A)
  3002H          |  MVI B, 54H     |    ; Load 54H into register B
  3004H          |  ADD B          |    ; Add the contents of register B to the accumulator
  3005H          |  STA 3050H      |    ; Store the result from the accumulator at memory location 3050H
  3008H          |  HLT            |    ; Halt the program

Explanation of Instructions:

MVI A, 32H: This instruction moves the immediate value 32H into the accumulator (A).
MVI B, 54H: This instruction moves the immediate value 54H into register B.
ADD B: This instruction adds the contents of register B to the accumulator and stores the result in the accumulator.
STA 3050H: This instruction stores the contents of the accumulator at the memory location 3050H.
HLT: This instruction halts the execution of the program.

2. Write a Program for Addition of Two 8-bit Hexadecimal Numbers and Store the Sum and Carry at Memory Locations 2051H and 2052H Respectively

Numbers are: FFH and FFH.

So basically, FFH is added to FFH, resulting in 1FEH. Since there is a carry, 1 is stored as the carry, and FEH is stored as the sum.

The basic steps involved for this program are:

Start
Initialize the carry register as zero (C = 0)
Get the first and second numbers
Add them
Check for the carry
- If there is a carry, then increment the carry register
Store the sum
Store the carry if there is one
Stop

                    
MVI C, 00H        ; Initialize carry register (C) to zero
MVI A, FFH        ; Load first number (FFH) into accumulator A
MVI B, FFH        ; Load second number (FFH) into register B
ADD B             ; Add the contents of register B to accumulator A
JNC NO_CARRY      ; Jump if no carry (CY flag is not set)
INR C             ; Increment register C (carry) by 1 if there is a carry
NO_CARRY:         ; Label for no carry condition
STA 2051H         ; Store the sum from the accumulator to memory location 2051H
MOV A, C          ; Move the value of register C (carry) to accumulator A
STA 2052H         ; Store the carry from the accumulator to memory location 2052H
HLT               ; Halt the program

After execution of this program, FEH will be stored at 2051H, and the carry 1 will be stored at 2052H.

3- Program to Subtract Two 8-Bit Numbers Without Borrow in 8085

Suppose we have two 8-bit numbers, 40H and 30H, and we want to subtract them without borrow.

    
  Memory Location  |   Instruction   |    Comments
-------------------|-----------------|---------------------------------------------
    3000H          |  MVI A, 40H     |    ; Load first number (40H) into accumulator A
    3002H          |  MVI B, 30H     |    ; Load second number (30H) into register B
    3004H          |  SUB B          |    ; Subtract the content of register B from accumulator A without borrow
    3005H          |  HLT            |    ; Halt the program

Explanation of Instructions:

MVI A, 40H: Load the first number (40H) into accumulator A.
MVI B, 30H: Load the second number (30H) into register B.
SUB B: Subtract the content of register B from accumulator A without borrow.
HLT: Halt the execution of the program.

4- Program to Subtract Two 8-Bit Numbers with Borrow in 8085

Suppose we have two 8-bit numbers, 30H and 20H where we want to subtract 30H from 20H with borrow (20H - 30H).

    
  Memory Location  |   Instruction   |    Comments
-------------------|-----------------|---------------------------------------------
    3000H          |  MVI A, 20H     |    ; Load 20H into accumulator A
    3002H          |  MVI B, 30H     |    ; Load 30H into register B
    3004H          |  SUB B          |    ; Subtract B from A with borrow
    3005H          |  MOV C, A       |    ; Move result to register C
    3006H          |  SBB A          |    ; Subtract borrow from A
    3007H          |  HLT            |    ; Halt the program

Explanation:

MVI A, 20H: Loads the first number (20H) into accumulator A.
MVI B, 30H: Loads the second number (30H) into register B.
SUB B: Subtracts B (30H) from A (20H) with borrow.

Now, let's perform the binary subtraction:

  A (Accumulator)  |  B (Register B)  |  Result (A - B with borrow)  |  Carry (CY)  
-------------------|------------------|-----------------------------|---------------
    0010 0000      |    0011 0000     |          1111 0000           |       1

After the subtraction, the result (1111 0000) is stored in accumulator A, and the carry flag (CY) is set to 1 indicating a borrow.

MOV C, A: Moves the result (1111 0000) from accumulator A to register C.
SBB A: Subtracts the borrow (1) from A (1111 0000 - 1 = 1110 1111).
HLT: Halts the program.

After executing this program, the final result in accumulator A is EFH (1110 1111 in binary).

5- Program to Add Two 16-bit Hexadecimal Numbers and Store the Result at Memory Location 3050H

Suppose we have two 16-bit numbers: 2A75H and B42FH. We want to add these numbers and store the result at memory location 3050H.

    
Memory Location  |   Instruction   |    Comments
-----------------|-----------------|---------------------------------------------
    3000H        |  MVI H, 2AH     |    ; Load high byte of first number (2A75H) into register H
    3002H        |  MVI L, 75H     |    ; Load low byte of first number into register L
    3004H        |  MVI D, B4H     |    ; Load high byte of second number (B42FH) into register D
    3006H        |  MVI E, 2FH     |    ; Load low byte of second number into register E
    3008H        |  MOV A, L       |    ; Move low byte of first number to accumulator A
    3009H        |  ADD E          |    ; Add low byte of second number to accumulator A
    300AH        |  MOV L, A       |    ; Move the sum in accumulator A to register L (low byte)
    300BH        |  MOV A, H       |    ; Move high byte of first number to accumulator A
    300CH        |  ADC D          |    ; Add high byte of second number to accumulator A with carry
    300DH        |  MOV H, A       |    ; Move the sum in accumulator A to register H (high byte)
    300EH        |  STA 3050H      |    ; Store the 16-bit sum from registers H and L at memory location 3050H
    3011H        |  HLT            |    ; Halt the program

Explanation of Instructions:

MVI H, 2AH: Load the high byte (2A) of the first number (2A75H) into register H.
MVI L, 75H: Load the low byte (75) of the first number into register L.
MVI D, B4H: Load the high byte (B4) of the second number (B42FH) into register D.
MVI E, 2FH: Load the low byte (2F) of the second number into register E.
MOV A, L: Move the low byte of the first number (75) to accumulator A.
ADD E: Add the low byte of the second number (2F) to accumulator A (resulting in 75 + 2F = A4).
MOV L, A: Move the sum (A4) in accumulator A to register L (low byte).
MOV A, H: Move the high byte (2A) of the first number to accumulator A.
ADC D: Add the high byte (B4) of the second number to accumulator A with carry (resulting in 2A + B4 + 1 (carry) = D9).
MOV H, A: Move the sum (D9) in accumulator A to register H (high byte).
STA 3050H: Store the 16-bit sum (D9A4H) from registers H and L at memory location 3050H.
HLT: Halt the execution of the program.

6- Program to Swap Two Numbers in Memory Locations.

Suppose we have two numbers stored in memory locations 4000H and 4001H, and we want to swap their values.

                                
Memory Location  |   Instruction   |    Comments
-----------------|-----------------|---------------------------------------------
    3000H        |  LXI H, 4000H   |    ; Load memory location for first number into register pair HL
    3003H        |  MOV A, M       |    ; Move the content of memory location 4000H to accumulator A
    3004H        |  LXI D, 4001H   |    ; Load memory location for second number into register pair DE
    3007H        |  MOV E, M       |    ; Move the content of memory location 4001H to register E
    3008H        |  MOV L, E       |    ; Move the content of register E (second number) to register L (first number)
    3009H        |  MOV M, A       |    ; Move the content of accumulator A (first number) to memory location 4001H
    300AH        |  MOV M, L       |    ; Move the content of register L (second number) to memory location 4000H
    300BH        |  HLT            |    ; Halt the program

Explanation of Instructions:

LXI H, 4000H: Load the memory location for the first number into register pair HL.
MOV A, M: Move the content of memory location 4000H to accumulator A.
LXI D, 4001H: Load the memory location for the second number into register pair DE.
MOV E, M: Move the content of memory location 4001H to register E.
MOV L, E: Move the content of register E (second number) to register L (first number).
MOV M, A: Move the content of accumulator A (first number) to memory location 4001H.
MOV M, L: Move the content of register L (second number) to memory location 4000H.
HLT: Halt the execution of the program.

7- Program to Move a Block of Data of 16 Bytes from Starting Addresses 2050H to 2060H in 8085

We want to move a block of data of 16 bytes from starting addresses 2050H to 2060H to another location.

                                
Memory Location  |   Instruction   |    Comments
-----------------|-----------------|---------------------------------------------
    3000H          |  LXI H, 2050H   |    ; Load starting address of the block into register pair HL
    3003H          |  LXI D, 2070H   |    ; Load destination address into register pair DE
    3006H          |  LXI B, 10H     |    ; Load counter (number of bytes to move) into register pair BC
    3009H          |  L1 MOV A, M    |    ; Move data from source address pointed by HL to accumulator A
    300AH          |  MOV M, A       |    ; Move data from accumulator A to destination address pointed by DE
    300BH          |  INX H          |    ; Increment source address (HL)
    300CH          |  INX D          |    ; Increment destination address (DE)
    300DH          |  DCX B          |    ; Decrement counter (BC)
    300EH          |  JNZ L1         |    ; Jump to L1 if counter is not zero
    3011H          |  HLT            |    ; Halt the program

Explanation of Instructions:

LXI H, 2050H: Load the starting address of the block (2050H) into register pair HL.
LXI D, 2070H: Load the destination address (2070H) into register pair DE.
LXI B, 10H: Load the counter (number of bytes to move, here 16 bytes) into register pair BC.
MOV A, M: Move data from the source address pointed by HL to accumulator A.
MOV M, A: Move data from accumulator A to the destination address pointed by DE.
INX H: Increment the source address (HL).
INX D: Increment the destination address (DE).
DCX B: Decrement the counter (BC).
JNZ L1: Jump to label L1 if the counter is not zero.
HLT: Halt the execution of the program.