Assembly Language

Programming in 8085
Microprocessor
A comprehensive guide to data handling, transfer operations, and
arithmetic functions in the 8085 microprocessor assembly language
programming.
Introduction to 8085 Assembly Language
The Intel 8085 is an 8-bit microprocessor that was introduced in
1976 as a successor to the popular 8080 chip. Assembly language
programming for the 8085 provides direct control over hardware
resources through simple mnemonic instructions.

Understanding 8085 assembly language provides essential knowledge for:

• Low-level hardware control and manipulation

• Embedded systems programming fundamentals
• Building a foundation for advanced processor architecture concepts
• Developing efficient code for resource-constrained environments
8085 Architecture Overview
1 2

Bus Structure General Purpose Registers

The 8085 features an 8-bit data Six general purpose 8-bit
bus allowing it to transfer 8 bits registers (B, C, D, E, H, L) are
of data simultaneously, and a available for temporary data
16-bit address bus capable of storage during program
addressing up to 64KB of execution, offering versatile
memory. data manipulation capabilities.

Special Registers
The Accumulator (A) is the primary register for arithmetic and logical
operations. The Flag register contains status bits that reflect the results
of operations.
8085 Registers and Register Pairs
Individual Registers (8-bit) Register Pairs (16-bit)

• A (Accumulator): Primary • BC: B (high byte) and C (low byte)

register for arithmetic/logical • DE: D (high byte) and E (low byte)
• operations
B, C, D, E: General purpose data • HL: H (high byte) and L (low byte)
storage
Register pairs enable 16-bit
• H, L: Often used for memory
operations, particularly useful for:
addressing
• Memory addressing (HL pair is
most commonly used)
• Loop counters and index pointers
• Storing 16-bit data values or
addresses
Flags in 8085
Sign Flag (S) Zero Flag (Z) Auxiliary Carry Flag (AC)
Set if bit 7 of the result is 1 (negative Set if result is zero; Reset if result is Set if carry from bit 3 to bit 4; Used
in 2's complement); Reset if bit 7 is 0 non-zero for BCD operations
(positive)

Parity Flag (P) Carry Flag (CY)

Set if result has even parity (even number of 1's); Reset if Set if operation results in carry/borrow; Critical for multi-
odd parity byte arithmetic

Flags are stored in the Flag register and are automatically modified by arithmetic and logical instructions. They provide essential
information about the result of an operation and can be tested by conditional jump instructions.
Addressing Modes in 8085

Immediate Addressing

Operand is included in the instruction itself

Example: MVI A, 32H (Load 32H into accumulator)

Register Addressing

Operand is in a register

Example: MOV A, B (Move content of B to A)

Direct Addressing

Memory address is specified in the instruction

Example: LDA 2050H (Load from address 2050H)

Indirect Addressing

Register pair contains the address of operand

Example: MOV A, M (Load from address in HL)

Implicit Addressing

Operand is implied in the instruction

Example: CMA (Complement accumulator)

Categorization of Instructions
Logical
Perform bit manipulation
Arithmetic
and logical operations
Perform mathematical
Examples: ANA, ORA, XRA, Branching
operations
CMP, RLC
Data Transfer Control program flow
Examples: ADD, SUB, INR,
DCR, DAA Examples: JMP, JZ, CALL, RET
Move data between
registers, memory, and I/O
Machine Control
devices
Control processor operation
Examples: MOV, MVI, LDA,
STA, IN, OUT Examples: HLT, NOP, EI, DI
What is Data Handling?
Data handling in assembly language refers to all operations involved in the
manipulation, movement, and storage of data within a microprocessor system. It forms
the foundation upon which complex algorithms and programs are built.

Effective data handling requires understanding:

• How data is represented in memory and registers

• Instructions that move data between storage locations
• Methods to manipulate and transform data
• Memory addressing techniques to access data efficiently

In 8085 assembly language programming, data handling operations form approximately

Data Transfer Instructions: Overview

Move Instructions Load Instructions

Transfer data between registers or between registers and memoryLoad data from memory into registers or register pairs

Examples: MOV r1, r2; MOV r, M; MOV M, r Examples: LDA addr; LDAX rp; LXI rp, data16

Store Instructions Exchange Instructions

Store data from registers into memory Swap data between register pairs or with stack

Examples: STA addr; STAX rp Examples: XCHG; XTHL

Data transfer instructions are the workhorses of assembly programming, facilitating the movement of information through the
system. They typically do not affect flag bits (with some exceptions) and are foundational for implementing algorithms.
MOV Instruction
Syntax Examples

MOV destination, source MOV B, C ; Copy content of register C to BMOV A, M ; Copy content from memory
location ; pointed by HL to accumulatorMOV M, D ; Copy content of
The MOV instruction transfers 8-bit data from a source operand to a destination operand. register D to memory ; location pointed by HL

Characteristics

• 63 valid MOV variations (excluding MOV M, M)

• 1-byte instruction (opcode only)
• No flags affected
• 7 T-states for register to/from memory, 4 T-states for register to register
MVI Instruction
Syntax Examples

MVI r, dataMVI M, data MVI B, 32H ; Load 32H into register BMVI M, 0FFH ; Load FFH into memory location
; pointed by HLMVI A, 00H ; Clear accumulator by loading 00H

The MVI (Move Immediate) instruction loads an immediate 8-bit value into a register or memory location.

Characteristics

• 2-byte instruction (opcode + immediate data)

• No flags affected
• 7 T-states for register, 10 T-states for memory
LDA and STA Instructions

LDA (Load Accumulator) STA (Store Accumulator)

Loads the accumulator with contents from a specified memory address. Stores the contents of the accumulator to a specified memory address.

LDA 2050H; Load accumulator with contents of ; memory location STA 3050H; Store accumulator contents to ; memory location 3050H
2050H

3-byte instruction: opcode + 16-bit address 3-byte instruction: opcode + 16-bit address

Both LDA and STA provide direct memory access without using register pairs as pointers, making them efficient for single-value transfers to specific memory locations.
LXI Instruction
Syntax Examples

LXI rp, data16 LXI H, 2050H ; Load HL pair with 2050H ; H gets 20H, L gets 50HLXI
B, 0000H ; Clear BC pairLXI SP, 8FFFH ; Initialize stack pointer
Where rp is a register pair (B, D, H or SP) and data16 is a 16-bit immediate value.

Characteristics

• 3-byte instruction (opcode + low byte + high byte)

• No flags affected
• 10 T-states
• Useful for initializing pointers and counters
XCHG and XTHL Instructions

XCHG (Exchange D & E with H & L) XTHL (Exchange H & L with Stack)
Exchanges the contents of the HL register pair with the DE register pair. Exchanges the contents of the HL register pair with the top two bytes of the stack.

XCHG; Before: H=25H, L=36H, D=47H, E=58H; After: H=47H, L=58H, XTHL; If stack top contains 2B3CH and HL=47A9H; After: HL=2B3CH,
D=25H, E=36H stack top=47A9H

1-byte instruction, 4 T-states, no flags affected 1-byte instruction, 16 T-states, no flags affected

These exchange instructions provide efficient ways to swap data without using temporary storage, optimizing both code size and execution speed.
Practical Data Handling Example
Scenario: Move Data Between Locations

Let's examine how to move an 8-bit value from memory location 2050H to register B, manipulate
it, and then store the result at location 3050H.

LDA 2050H ; Load value from 2050H to AMOV B, A ; Copy value from A to BADD
B ; Add B to A (doubles the value)STA 3050H ; Store result to 3050H

This sequence demonstrates the combined use of direct and register addressing to process data efficiently.

Execution Steps
Steps in Writing an Assembly Program
Problem Analysis
Understand the requirements, identify inputs and outputs, and determine the processing needed.

Algorithm Development
Design the step-by-step solution approach, breaking complex problems into smaller, manageable tasks.

Flowchart Creation
Create a visual representation of the program logic to identify process flow, loops, and decision points.

Instruction Writing
Translate the algorithm into assembly language instructions, considering registers and memory usage.

Debugging and Testing

Identify and fix errors through systematic testing with different input values and edge cases.
Sample Data Handling ALP
Problem Statement Assembly Program

Copy a byte of data from memory location 2050H to location 3050H.

; Program to copy data from 2050H to 3050H LDA 2050H ; Load from
Algorithm source STA 3050H ; Store to destination HLT ; Halt the
program
1. Load the content of memory location 2050H into the accumulator

2. Store the content of the accumulator into memory location 3050H

3. Halt the program

Data Handling ALP: Code Walkthrough
1 LDA 2050H
Loads the content of memory location 2050H into the accumulator (A register).

The processor:

1. Fetches the LDA opcode (3AH)

2. Fetches the 16-bit address (50H, 20H)
3. Reads the content at 2050H into A

2 STA 3050H
Stores the content of the accumulator into memory location 3050H.

The processor:

1. Fetches the STA opcode (32H)

2. Fetches the 16-bit address (50H, 30H)
3. Writes the accumulator content to 3050H

3 HLT
Halts the processor until a reset or interrupt occurs.

The processor:

1. Fetches the HLT opcode (76H)

2. Enters a halt state
3. Waits for external intervention
Data Handling: Real-World Applications
Device Drivers
Assembly-level data handling enables direct control of hardware peripherals by
transferring control signals and data between the processor and devices.

Embedded Systems
Resource-constrained devices rely on efficient data handling to process sensor
inputs, manage displays, and control actuators with minimal overhead.

Real-time Control
Applications requiring precise timing use assembly for predictable data transfers
between memory, I/O ports, and processing units.

Bootloaders
System initialization code uses data transfer instructions to set up hardware
configurations and load operating systems into memory.
Introduction to Arithmetic Operations
Arithmetic operations form the computational core of assembly
language programming, enabling mathematical processing of data.
The 8085 provides a variety of instructions for performing
calculations on 8-bit and 16-bit values.

Key Arithmetic Operations

• Addition (with and without carry)

• Subtraction (with and without borrow)
• Increment and decrement
• Decimal adjustment for BCD arithmetic

Most arithmetic operations use the accumulator (A) as both an

operand and the destination for results, affecting the flag register to
reflect operation outcomes.
Arithmetic Instruction Groups
Addition Group Subtraction Group
ADD, ADI, ADC, ACI SUB, SUI, SBB, SBI

Add registers, memory, or immediate values to the Subtract registers, memory, or immediate values from
accumulator, with or without considering the carry flag. the accumulator, with or without considering the borrow
(carry flag).

Increment Group Decrement Group

INR, INX DCR, DCX

Increase the value of a register, memory location (INR), Decrease the value of a register, memory location (DCR),
or register pair (INX) by one. or register pair (DCX) by one.
ADD Instruction
Syntax Examples

ADD r ; Add register to accumulatorADD M ; Add memory to accumulator ADD B ; A = A + BADD M ; A = A + [HL]; Example with values:; If A = 3CH, B = 2AH; After ADD
B:; A = 66H; CY = 0, Z = 0, S = 0, P = 1, AC = 1

The ADD instruction adds the content of a register or memory location to the accumulator and stores the result in the
accumulator.

Characteristics

• 1-byte instruction (opcode only)

• Affects all flags
• 4 T-states for registers, 7 for memory
ADI Instruction
Syntax Examples

ADI data ; Add immediate data to accumulator ADI 57H ; A = A + 57HADI 0FFH ; A = A + FFH (max value)ADI 00H ; No change to A, may affect
flags; Example with values:; If A = 78H; After ADI 95H:; A = 0DH; CY = 1, Z = 0, S = 0, P = 0, AC =
The ADI (Add Immediate) instruction adds an immediate 8-bit value to the accumulator and stores the result in the accumulator. 1

Characteristics

• 2-byte instruction (opcode + immediate data)

• Affects all flags
• 7 T-states
ADC and ACI Instructions
ADC (Add with Carry) ACI (Add with Carry Immediate)

ADC r ; Add register and carry to AADC M ACI data ; Add immediate data and carry to A
; Add memory and carry to A
Adds an immediate 8-bit value and the carry flag to the
Adds the content of a register or memory location and the accumulator.
carry flag to the accumulator.
Operation: A ← A + data + CY
Operation: A ← A + r/M + CY
Example: If A=95H, CY=1, then after ACI 6AH: A=00H, CY=1
Example: If A=95H, B=6AH, CY=1, then after ADC B: A=00H, CY=1

ADC and ACI instructions are essential for multi-byte addition operations where the carry from a lower byte addition must be
included when adding higher bytes.
SUB and SUI Instructions
SUB (Subtract) SUI (Subtract Immediate)

SUB r ; Subtract register from ASUB M ; SUI data ; Subtract immediate data from A
Subtract memory from A
Subtracts an immediate 8-bit value from the accumulator.
Subtracts the content of a register or memory location from
Operation: A ← A - data
the accumulator.
Example: If A=95H, then after SUI 6AH: A=2BH, CY=0
Operation: A ← A - r/M

Example: If A=95H, B=6AH, then after SUB B: A=2BH, CY=0

In 8085, the carry flag acts as a borrow flag for subtraction. It is set (1) if no borrow is required and reset (0) if a borrow is needed.
This is the opposite of how many modern processors handle borrow.
INR and DCR Instructions
INR (Increment) DCR (Decrement)

INR r ; Increment registerINR M ; Increment DCR r ; Decrement registerDCR M ; Decrement

memory memory

Increases the content of a register or memory location by 1. Decreases the content of a register or memory location by 1.

Affects all flags except carry flag (CY) Affects all flags except carry flag (CY)

Example: If B=FFH, after INR B: B=00H, Z=1, CY unchanged Example: If B=00H, after DCR B: B=FFH, S=1, Z=0, CY unchanged

INR and DCR are commonly used for loop control and counter operations. Their unique characteristic of not affecting the carry flag
allows them to be used within multi-byte arithmetic operations without disrupting the carry propagation.
INX and DCX Instructions
INX (Increment Register Pair) DCX (Decrement Register Pair)

INX rp ; Increment register pair

DCX rp ; Decrement register pair

Increases the content of a register Decreases the content of a register

pair by 1. pair by 1.

rp can be BC, DE, HL, or SP rp can be BC, DE, HL, or SP

No flags are affected No flags are affected

Example: If BC=FFFFH, after INX B: Example: If BC=0000H, after DCX

BC=0000H B: BC=FFFFH

INX and DCX are particularly useful for:

• Memory pointers (typically HL) in sequential memory operations

• Stack pointer adjustments
• 16-bit counters for loops processing large data blocks
Arithmetic Operations Flow

Operand Fetch ALU Operation

The processor retrieves the operand The Arithmetic Logic Unit performs the
from a register, memory, or as specified calculation (addition,
immediate data in the instruction subtraction, increment, etc.) on the
stream. operands.

Result Storage
Flag Update
The result is stored in the destination
Based on the operation result, the
operand, typically the accumulator
processor updates the appropriate
(except for INR/DCR which modify the
status flags in the flag register.
operand directly).
Flags Affected by Arithmetic
ADD/ADI Yes Yes Yes Yes Yes

ADC/ACI Yes Yes Yes Yes Yes

SUB/SUI Yes Yes Yes Yes Yes

INR/DCR Yes Yes Yes Yes No

INX/DCX No No No No No

Understanding how instructions affect flags is critical for conditional branching and error detection in assembly programs. For
example, the Z flag can be tested after arithmetic to check if a result is zero, while the CY flag indicates overflow in addition or
underflow in subtraction.
ALP: Add Two 8-bit Numbers
Problem Statement Assembly Program

Add two 8-bit numbers stored in registers D and E, then store the result in register C.
; Program to add two 8-bit numbers MVI D, 99H ; Load first number MVI
Algorithm E, 39H ; Load second number MOV A, D ; Move first number to A ADD E
; Add second number to A MOV C, A ; Store result in C HLT ;
1. Load the first number into register D Halt the program
2. Load the second number into register E

3. Move the content of D to accumulator

4. Add E to accumulator
5. Move result from accumulator to C

6. Halt the program

Code Example: Addition
MVI D, 99H 1
Loads the immediate value 99H into register D.

This is our first operand for addition.

2 MVI E, 39H
After execution: D = 99H
Loads the immediate value 39H into register E.

This is our second operand for addition.

MOV A, D 3
After execution: E = 39H
Copies the content of register D to the accumulator.

After execution: A = 99H

4 ADD E
Adds the content of register E to the accumulator.

Calculation: 99H + 39H = D2H

MOV C, A 5
After execution: A = D2H, CY = 0, Z = 0, S = 1, P = 0, AC = 1
Copies the content of the accumulator to register C.

After execution: C = D2H

ALP: Subtract Two Numbers

Problem Statement Assembly Program

Subtract an 8-bit number in register E from another in register D, then store the result in register C.
; Program to subtract two 8-bit numbers MVI
Algorithm D, 56H ; Load first number MVI E, 22H ; Load
second number MOV A, D ; Move first number to A
1. Load the first number (minuend) into register D SUB E ; Subtract second number from A
2. Load the second number (subtrahend) into register E MOV C, A ; Store result in C HLT ;
3. Move the content of D to accumulator Halt the program
4. Subtract E from accumulator
5. Move result from accumulator to C
6. Halt the program
Code Example: Subtraction
MVI D, 56H 1
Loads the immediate value 56H into register D.

This is our minuend (number to subtract from).

2 MVI E, 22H
After execution: D = 56H
Loads the immediate value 22H into register E.

This is our subtrahend (number to subtract).

MOV A, D 3
After execution: E = 22H
Copies the content of register D to the accumulator.

After execution: A = 56H

4 SUB E
Subtracts the content of register E from the accumulator.

Calculation: 56H - 22H = 34H

MOV C, A 5
After execution: A = 34H, CY = 1, Z = 0, S = 0, P = 1, AC = 1
Copies the content of the accumulator to register C.

After execution: C = 34H

ALP: Incrementing/Decrementing Data
Example Program

; Program to demonstrate INR and DCR MVI B, 7FH ; Load test value into B
INR B ; Increment B (7FH + 1 = 80H) MVI C, 00H ; Load test value into C
DCR C ; Decrement C (00H - 1 = FFH) HLT ; Halt the program

After execution:

• B = 80H, S = 1 (negative result), Z = 0, P = 0, AC = 1

• C = FFH, S = 1 (negative result), Z = 0, P = 1, AC = 0

Special Cases
ALP: Adding Multiple Numbers
Problem Statement

Add three 8-bit numbers stored in registers B, C, and D, then store the result in register E.

Assembly Program

; Program to add three 8-bit numbers

MVI B, 25H ; First number MVI C, 40H
; Second number MVI D, 1BH ; Third
number MOV A, B ; Move
first number to A ADD C ; Add
second number ADD D ; Add third
number MOV E, A ; Store result in E
HLT ; Halt the program

Execution Flow
Multi-Byte Addition Example
Problem Statement

Add two 16-bit numbers stored in BC and DE register pairs, then store the result in HL pair.

Assembly Program

; Program to add two 16-bit numbers

LXI B, 2534H ; First 16-bit number LXI D,
19ABH ; Second 16-bit number ; Add
low bytes MOV A, C ; Get low byte of
first number ADD E ; Add low byte of
second number MOV L, A ; Store low byte
result ; Add high bytes with carry
MOV A, B ; Get high byte of first number
ADC D ; Add high byte with carry MOV
H, A ; Store high byte result HLT
; Halt the program

Result Analysis

Initial values:
 Looping and Counters in ALP

Process Data
Initialize Counter
Execute the operations needed for
Load an initial count value into a register. each iteration.

Example: MVI B, 0AH (Set counter to 10) Example: Data manipulation, memory
access, calculations

Test Condition Adjust Counter

Check if loop should continue or terminate. Decrement or increment the counter
register.
Example: JNZ LOOP (Jump to LOOP if
not zero) Example: DCR B (Decrease counter by 1)
ALP: Data Transfer with Loop
Problem Statement

Copy a block of 10 bytes from a source memory location starting at 2050H to a destination starting at 3050H.

Assembly Program

; Block data transfer programSTART: LXI H, 2050H ; Initialize source pointer

LXI D, 3050H ; Initialize destination pointer MVI B, 0AH ; Set counter to 10 bytes
LOOP: MOV A, M ; Get byte from source STAX D ; Store byte to
destination INX H ; Increment source pointer INX D ; Increment
destination pointer DCR B ; Decrement counter JNZ LOOP ; Repeat
until counter = 0 HLT ; Halt when done

Program Operation
ALP: Block Sum Calculation
Problem Statement

Calculate the sum of 8 bytes stored in consecutive memory locations starting at 2050H and store the result at 3050H.

Assembly Program

; Block sum calculation program LXI H, 2050H ; Initialize memory pointer MVI
B, 08H ; Set counter to 8 bytes MVI A, 00H ; Initialize sum to zero LOOP: ADD
M ; Add memory content to sum INX H ; Increment memory pointer DCR B
; Decrement counter JNZ LOOP ; Repeat until counter = 0 STA 3050H
; Store final sum HLT ; Halt when done

Program Operation

1. Initialize HL to point to the first byte at 2050H

Debugging ALPs in 8085
Common Errors
• Using incorrect opcodes or mnemonics
• Selecting invalid addressing modes (e.g., MOV M, M)
• Forgetting to initialize registers or memory
• Improper carry/borrow handling in multi-byte operations
• Infinite loops due to incorrect termination conditions

Debugging Techniques
• Single-step execution to observe instruction effects
• Breakpoints at critical program locations
• Register and memory monitoring during execution
• Flag status checking after arithmetic operations
• Program trace logs to track execution flow

Modern 8085 simulators like GNUSim8085, 8085sim, and Visual 8085 provide
valuable debugging features including register visualization, memory dumps, and
execution tracing to help identify and resolve programming errors.
Best Practices for Writing 8085 ALP
Code Organization
• Use consistent indentation and formatting
• Group related instructions into logical blocks
• Use meaningful labels for program sections
• Maintain a clear separation between code and data

Documentation
• Add comments explaining non-obvious operations
• Document register usage and purpose
• Include algorithm explanation at the beginning
• Note any critical timing or memory constraints

Optimization
• Minimize memory access when possible
• Use register operations instead of memory when feasible
• Reduce instruction count in critical loops
• Consider execution time for time-sensitive applications

Robustness
• Check for boundary conditions and edge cases
• Handle overflow/underflow appropriately
• Consider input validation for external data
• Test with diverse data sets to ensure reliability
Applications of 8085 Arithmetic/Data Handling

Digital Calculators Industrial Controls Measurement Instruments

Implements basic and scientific Monitors sensor inputs, performs Processes analog-to-digital converter
calculations through optimized arithmetic threshold comparisons, and controls outputs, applies calibration factors, and
operations, managing display output and actuators through precise timing and data performs unit conversions using multi-
keypad input through efficient data acquisition routines. byte arithmetic operations.
handling.
Though largely superseded by modern microcontrollers, the principles of 8085 assembly programming continue to influence
embedded systems design, particularly in resource-constrained environments where efficient code execution is critical.
8085 ALP in Modern Context
Educational Value Legacy Systems Maintenance

The 8085 remains an excellent platform for teaching fundamental computer architecture concepts:

• Simple instruction set easy for beginners to grasp

• Direct visibility of CPU operations and memory access
• Clear connection between hardware and software
• Foundation for understanding complex processors

Many computer science and engineering programs still use 8085 assembly programming to introduce low-
level system concepts before moving to modern architectures.
Additional Learning Resources
1 2

Textbooks Simulators
• "Microprocessor Architecture, • GNUSim8085: Open-source 8085
Programming and Applications with simulator with GUI
the 8085" by Ramesh Gaonkar • [Link]: Online browser-
• "The 8085 Microprocessor: based simulator
Fundamentals and Applications" by • Virtual 8085: Windows-based
K. Udaya Kumar simulator with visualization
• "Digital Computer Electronics" by • emulator8085: Mobile app for on-
Albert P. Malvino the-go practice

Practice Exercises
• Implement basic calculator functions
• Create sorting and searching algorithms
• Develop simple data encryption/decryption routines
• Build binary to BCD conversion utilities
Conclusion
Assembly language programming for the 8085 microprocessor provides a fundamental understanding of
how computers operate at the lowest level. Mastering data handling and arithmetic operations forms
the foundation for all higher-level programming concepts.

Key takeaways from this presentation:

• The 8085's register architecture and instruction set provide a complete platform for learning
assembly fundamentals
• Data transfer instructions enable efficient movement of information throughout the system
• Arithmetic operations form the computational core of any program
• Proper understanding of flags and addressing modes is critical for effective programming

While modern programming typically occurs at higher levels of abstraction, the principles learned