The 8085 Addressing Modes : Immediate addressing , Register , Direct , Indirect

SbistudyPosted onincontrol system, Digital electronics, electronics

The 8085 Addressing Modes

The instructions MOV B, A or MVI A, 82H are to copy data from a source into a destination. In these instructions, the source can be a register, an input port or an 8 bit number (00H to FFH). Similarly, a destination can be a register or an output port. The sources and destination are operands. The various formats for specifying operands are called the addressing modes. For 8085, they are

  1. Immediate addressing
  2. Register addressing
  3. Direct addressing
  4. Indirect addressing

Immediate Addressing

Data is present in the instruction. Load the immediate data to the destination provided. Example, MVI R, data.

Register Addressing

Data is provided through the registers. Example, MOV RD, Rs.

Direct Addressing

Used to accept data from outside devices to store in the accumulator or send the data stored in the accumulator to the outside device. Accept the data from the port 00H and store them into the accumulator or send the data from the accumulator to the port 01H.

Example, in 00H or out 01H.

Indirect Addressing

This means that the effective address is calculated by the processor and the contents of the address (and the one following) is used to form a second address. The second address is where the data is stored. Note that this requires several memory accesses; two accesses to retrieve the 16-bit address and a further access (or accesses) to retrieve the data which is to be loaded into the register.

The 8085 Instruction Set Classification

An instruction is a binary pattern designed inside a microprocessor to perform a specific function. The entire group of instructions called the instruction set determines, what functions the microprocessor can perform. These instructions can be classified into the following five functional categories data transfer (copy) operations, arithmetic operations, logical operations, branching operations and machine control operations.

Data Transfer (Copy) Operations

This group of instructions copy data from a location called a source, to another location called a destination, without modifying the contents of the source. In technical manuals, the term data transfer is used for this copying function. However, the term transfer is misleading; it creates the impression that the contents of the source are destroyed when, in fact, the contents are retained without any modification. The various types of data transfer (copy) are listed below together with examples of each type

Types                                                                       Examples

  1. Between registers.
  2. Copy the contents of the register B into register D.
  3. Specific data byte to a register Load register B with the data byte 32H.
  4. Between a memory location and a register. From a memory location 2000H to
  5. Between an I/O device and the accumulator. Register B.

. from an input keyboard to the

Accumulator.

Arithmetic Operations

These instructions perform arithmetic operations such as addition, subtraction, increment and decrement.

Addition

Any 8-bit number or the contents of a register or the contents of a memory location can be added to the contents of the accumulator and the sum is stored in the accumulator. No two other 8-bit registers can be added directly (e.g., the contents of register B cannot be added directly to the contents of the register C). the instruction DAD is an exception; it adds 16-bit data directly in register pairs.

Subtraction

Any 8-bit number or the contents of a register or the contents of a memory location can be subtracted from the contents of the accumulator and the results stored in the accumulator. The subtraction is performed in 2’s complement and the results, if negative, are expressed in 2’s complement. No other registers can be subtracted directly.

Increment /Decrement

The 8-bit contents of a register or a memory location can be incremented or decremented by 1. Similarly, the 16-bit incremented or decremented by 1. These increment and decrement operations differ from addition and subtraction in an important way, i.e., they can be performed in any one of the registers or in a memory location.

Logical Operations

These instructions perform various logical operations with the contents of the accumulator.

AND, OR Exclusive-OR

Any 8-bit number or the contents of a register or of a memory location can be logically ANDed, ORed, or Exclusive-ORed with the contents of the accumulator. The results are stored in the accumulator.

Rotate

Each bit in the accumulator can be shifted either left or right to the next position.

Compare

Any 8-bit number or the contents of a register or a memory location can be compared for equality, greater than, or less than, with the contents of the accumulator.

Complement

The contents of the accumulator can be complemented. All 0s are replaced by 1s and 1s are replaced by 0s.

Branching Operations

This group of instructions alters the sequence of program execution either conditionally or unconditionally.

Jump

Conditional jumps are an important aspect of the decision-making process in the programming. These instructions test for a certain conditions (e.g., Zero or carry flag) and alter the program sequence when the condition is met. In addition, the instruction set includes in instruction called unconditional jump.

Call, Return and Restart

These instructions change the sequence of a program either by calling a subroutine or returning from a subroutine. The conditional call and return instructions also can test condition flags.

Machine Control Operations

These instructions control machine functions such as halt, interrupt or do nothing.

The microprocessor operations related to data manipulation can be summarized in four functions :

  1. Copying data
  2. Performing arithmetic operations
  3. Performing logical operations
  4. Testing for a given condition and alerting the program sequence

Some important aspects of the instruction set are noted below.

  1. In data transfer, the contents of the source are not destroyed; only the contents of the destination are changed. The data copy instructions do not affect the flags.
  2. Arithmetic and logical operations are performed with the contents of the accumulator, and the results are stored in the accumulator (with some expectations). The flags are affected according to the results.
  3. Any register including the memory can be used for increment and decrement.
  4. A program sequence can be changed either conditionally or by testing for a given data condition.

The 8085 Instruction Format

An instruction is a command to the microprocessor to perform a given task on a specified data. Each instruction has two parts, one is task to be performed, called the operation code (opcode) and the second is the data to be operated on called the operand. The operand (or data) can be specified in various ways. It may include 8-bit (or 16-bit) data, an internal register, a memory location, or 8-bit (or 16-bit) address. In some instructions, the operand is implicit.

Instruction word size

The 8085 instruction set is classified into the following three groups according to word size

  1. One-word or 1-byte instructions
  2. Two –word or 2-byte instructions
  3. Three –word or 3-byte instructions

In the 8085, byte and word are synonymous because it is an 8-bit microprocessor. However, instructions are commonly referred to in terms of bytes rather than words.

One-byte Instructions

A 1-byte instruction includes the opcode and operand in the same byte. Operands are internal registers and are for example,

TASK                                    Opcode          operand        binary code     hex code

Copy the contents of            MOV                  C,A               01001111         4FH

The accumulator in

The register C.

Add the contents of              ADD                    B                   1000 0000           80H

The register B to the

Contents of the accumulator

Invert (complement) each bit in          CMA                               00101111            2FH

The accumulator

These instructions are 1-byte instructions performing three different tasks. In the first instruction, both operand registers are specified. In the second instructions, the operand B is specified and the accumulator is assumed. Similarly, in the third instruction, the accumulator is assumed to be the implicit operand. These instructions are stored in 8-bit binary format in memory; each requires one memory location.

MOV  rd,  rs

Rd < – – rs copies contents of rs into rd.

Coded as 01 ddd sss where ddd is a code for one of the 7 general registers which is the destination of the data, sss is the code of the source register.

Example, MOV A,B

Coded as 01111000 = 78H = 170 octal (octal was used extensively in instruction design of such processors).

ADD  r

A < – – A  + r

Two- byte Instructions

In a two –byte instruction, the first byte specifies the operation code and the second byte specifies the operand. Source operand is a data byte immediately following the opcode. For example,

Task                                    opcode        operand      binary code   hex code

Load an 8-bit data byte         MVI               A, data         0011 1110     3E               First byte

In the accumulator

DATA           Data          second byte

Assume that the data byte is 32H. the assembly language instruction is written as

The instruction would required two memory locations to store in memory.

MVI r, data

R < – – data

Example, MIV A, 30H coded as 3EH  30H as two contiguous bytes. This is an example of immediate addressing.

ADI data

A < – – A + data

OUT port where port is an 8-bit device address.

(port) < – – A. since the byte is not the data but points directly to where it is located this is called direct addressing.

Three Byte Instructions

In a three byte instruction, the first by specifies the opcode and the following two bytes specify the 16-bit address. Note that, the second byte is the low-order address and the third byte is the high-order address.

Opcode + data byte + data byte

For example,

This instruction would require three memory locations to store in memory.

Three byte instructions  – opcode + data byte + data byte.

LXI rp, data 16

Rp is one of the pairs of registers BC, DE, HL used as 16-bit registers. The two data byte are 16-bit data in LH order of significance.

Re < – – data 16

Example

LXI H, 0520H coded as 21H 20H 50H in three bytes.

This is also immediate addressing

LDA addr

A < – – (addr) addr is a 16-bit address in LH order.

Example , LDA2134H coded as 3AH34H21H. This is also an example of direct addressing.

The 8085 Instruction set

ACI Data (8b)

Description : Add immediate 8-bit data to the accumulator with carry.

Bytes/M-cycles \T-states: 2/2/7

Hex code : CE

Flags : All flags are affected based upon the result of the addition.

ADC R

Description : Add register to accumulator with carry

Bytes/M-Cycles/T-States : 1/1/4

Hex codes:           Register

8F      A

88       B

89       C

8A        D

8B        E

8C        H

8D        L

Flags : All flags are affected based upon the result of the addition.

ADC M

Description : Add contents of memory location pointed to by HL register pair to the accumulator with carry.

Bytes/M-Cycles/T-States : 1/2/7

Hex code : 8E

Flags :All flags are affected based upon the result of the addition.

ADD R

Description :    Add register to accumulator.

Bytes/M-Cycles/T-states : 1/1/4

Hex  code                            Register

                         87                   A

80                    B

81                         C

82                         D

83                         E

84                         H

85                         L

Flags : All flags are affected based upon the result of the addition.

ADD M

Description: Add contents of memory location pointed by HL to the accumulator.

Bytes/M-Cycles/T-States : 1/2/7

Hex code 86

Flags: All flags are affected based upon the result of the addition.

ADI Data (8b)

Description : Add the immediate 8 bit data to the accumulator.

Bytes/m-cycles/t-states : 2/2/7

Hex code c6

Flags : All flags are affected based upon the result of the addition.