MICROPROCESSOR NOTES :

From the discussion of microprocessor 8085 and 8086, it is clear that all the instructions
are nothing but the combination of 0s and 1s. 0 indicates a low signal (may be voltage
0V) and 1 indicates a high signal (may be voltage 5V).
On the other hand all the computers work on Von Neuman stored program principle. We
have to store the computer program, which is nothing but the set of instruction and
computer executes them one other another as per the program requirement.
We have to store the program (i.e. set of instructions) in computer memory. The starting
address of the program must be specified which executing the program and it is loaded
into the program counter. After that program counter keeps track of the execution of the
program till the end of the program.
Every program must be end with a stop or terminating instruction, otherwise the control
unit will keep on fetching information from memory. Once it encounters a halt or stop
instruction, execution stops.
Simple Example:
Consider that we want to add two numbers 75 and 97.
The first requirement is to keep this two numbers in memory.
Next we have to write a program to fetch this two numbers from memory to CPU and add
this two numbers. Finally the result has to be stored in memory.
Again we have to load the program in memory. We must know the memory address of the
first instruction where we have stored the program.
While executing the program counter must be loaded with the starting address of the
program. The control unit will generate appropriate signal to perform the required task.
Consider that we are using Intel 8085 microprocessor to solve this problem. The task
required to perform this operation:
Get the two numbers from memory to general purpose register.
Perform the addition operation
Store the result back into the memory.
Finer details with respect to 8085:
Assume that we store number 75 in memory location 1000H . The result will be stored in
memory location 1002H .
One possible solution:

Step 1: First load the content of memory location 1000H to accumulator.

LDA1000 H

3 A 00 10 (machine instruction in hexadecimal)

The format of this instruction is opcode Low-order address high order address
opcode of LDA is 00 11 10 10 i.e. 3 AH
Step 2: Move the contents of accumulator to register B.
MOV B A
The format of this instruction is
01
DDD
SSS
Destination Source
register
register
i.e. 0 1

000

111

47 H (Machine instruction in hexadecimal)

Step 3: Load the content of memory location 1001H to accumulator

LDA

1001H

3 A 01 10 (Machine instruction in hexadecimal)

Step : Add the content of register B to accumulator and store the result in accumulator.
ADD B
The format of this instruction is
10000

i.e.

S S S
Source register
80 H (Machine instruction in hexadecimal)
10000000

Step 5: Store the result that is present in accumulator to memory location 1002H
STA 10 0 2 H
3 2 0 2 1 0 (Machine instruction in hexadecimal)
opcode Lower order address higher order address
opcode of STA is 0 0 1 1 0 0 1 0 i.e. 32 H
Step 6 : HALT : to indicate the end of program
76H
Opcode of HALT 0 1 1 1 0 1 1 0
Therefore to carry out this addition, we have to perform these five operation.
In this example we assume that data are available in memory and storing the result in
memory.

But if we want to take the input from some input device (like key board), first we have to
accept the input from keyboard and stored in some memory location. Similarly to display
the result in monitor, we have to get the result from memory and display in monitor with
the help of some o instruction.
The complete program is :
Memory location
0100H
3A 00 10
0103H
47
0104H
3A 01 10
0107H
80
0108H
32 02 10
010BH
76

LDA
MOVBA
LDA 1001H
ADD B
STA 1002H
HLT

If we store this program from memory location 100H , then the contents of memory is
shown below:
Memory Address
in Hex
in Hex
Fig
While executing the program, the program counter (PC) will be loaded with the starting
memory address of this program, i.e. 0100H.
The processor will start execution this program starting from memory location 0100H
and it keeps on doing the execution job till it encounters a halt instruction.
If we program the microprocessor in this way, i.e writing the machine code directly, it is
known as machine language programming.
The main advantage of machine language programming is that the memory control is
directly in the hands of the programmer, so that, he/she may able to manage the memory
of the system more efficiently.
The disadvantages of machine language programming are more prominent.
The programming, coding and resource management techniques are tedious. The
programmer has to take care of al these functions.
The programs are difficult to understand unless one has a thorough technical knowledge
of the processor architecture and the instruction set.
Also it is difficult to remember the machine code of each and every instruction,.
Assembly Language programming:

The assembly language programming is simpler as compared to the machine language

programming.
The instruction mnemonics are directly used in the assembly language programming.
There is an one-to one correspondence between instruction mnemonics and machine
instruction.
An assembler is used to translate the assembly language programming to machine code.
The program written in assembly language programming is more readable than machine
language programming.
The main improvement in assembly language over machine language is that the address
value and the contents can be identified by labels.
The assembly language instruction sequence for 8085 microprocessor of the previously
discussed program will look like:
// Load accumulator from memory address 1000H
LDA 1000 H
MOV B, A
// Move the content from accumulator to B
LDA 1001H
// Load accumulator from memory address 1001H
ADD B
// Add the content of B to accumulator and store the result in accumulator
STA 1002 H
// Store the content of accumulator in memory location 1002H
// Halt
HLT
Another assembly language instruction sequence to solve the same problem.
MVI L, 00 H // Load lower order byte of address 00H to register L
MVI H ,10 H // Load higher order byte of address 10H to register H
MVI B, M // Move the contents of memory location addressed by H L pair to B
LDA 01H 10 H // Load the accumulator from memory location 1001H
ADD B // Add the content of B to accumulator
STA 02 H 10 H // Store the content of accumulator to memory location 1002H
HLT // Halt.
The H-L register pair is loaded with 1000H which is the address of first input. This is
done in first two instruction.
Moving the contents of memory location 1000H to the register B. It is done in third
instruction.
Next we are loading the accumulator from the memory location 1001H, which is the
second input. This is done in fourth instruction.

Te content of register B is added with the content of accumulator and store the result in
accumulator. It is done in fifth instruction.
The content of accumulator is stored in memory location 1002H. It is done in sixth
instruction.
Seventh instruction is to halt the processor, i.e, to stop the program execution.
The first two instructions can be replaced
LXI

H ,1000 H

Assembly language instruction sequence for the same program for 8086 microprocessor.
Consider that data segment starts from 20000H and code segment starts from 1000H.
MOV CX , 2000 H // Initialize DS at 2000H
MOV DS , CX //
MOV AX , 1000 H // Get first operand in AX

MOV BX , 1001H // Get second operand in BX

ADD AX , BX // Perform addition
MOV 1002 H , AX // Store the result in location 1002H
HLT // Stop
Since the immediate data cannot be loaded into a segment register, the data is transferred
to one of the general purpose register, i.e. CX, and then the register content is moved to
the segment register DS.
The data segment register contains 2000H.
The effective address of the operands are 2000 :1001 i.e. 21000H and 21001H
The result is stored in memory location 21002H .
Problem: Find out the largest number from an unordered array of sixteen 8 bit numbers
stored sequentially in the memory locations starting at 0200H .
Assembly language instruction sequence for 8085 microprocessor.
MVI
LXI

B, OFH // put OFH in register B to count the number of input elements

H , 0200 H

// Load the register pair H-L by 0200H which is address of the first
element.

MOV

A, M // The content of memory location pointed by H-L register pair is moved

to accumulator.

BACK: INX H // Increment the register pair H-L to get the next element
CMP M PThe content of the memory location whose address is in H-L pair is subtracted
from the accumulator. The accumulator remain unchanged. CY 1 if
A H L
JNC NEXT

// Jump to the level NEXT if the carry is not set, i.e, content of
accumulator is biggest so far.

MOV A, M // if carry is set, the content of the memory addressed by H L pair is

biggest so far, so putting it in accumulator.
NEXT: DCR B
JNZ BACK

// Decrement the content B, to indicate we have checked one more

element

// jump on not zero, content of B indicates numbers of elements to read,

and repeat the process.

HLT // Finalize the input and store.

Assembly language instruction sequence for 8086 microprocessor
Here assume that the data segment stands from memory location 10000H
MOV CX , OFH // initialize counter for number of iteration
MOV AX ,1000 H // initialize data segment
MOV DS , AX //
MOV SI 0200 H
MOV

// initialize source pointer

AX , SI // take first number in AX

BACK: INC SI // increment source pointer.

CMP AX , SI // compare next number with the previous
JNC NEXT // If the next number is smaller, jump to NEXT.

MOV A SI

// If the next number is bigger, replace the previous one with the next
element

NEXT: LOOP BACK // Repeat the procedure for 15 times.

HLT
CMP operation subtract the source operand from the destination operand, but does not
store the result any where. The carry flag is set if the source operand is greater than the
destination operand.
LOOP: This instruction executes the part of the program from the label in the instruction
to the loop instruction, CX number of times. At each iteration CX is decremented
automatically. This instruction basically implements decrement counter and jump if not
zero structure.
Example: Write a program to move a string of data bytes from offset 1000H to 2000H .
The length of the string is FFH .
Assembly language instruction sequence for 8085 microprocessor:
L I H , 1000 H
L I D, 2000 H
MVI C , FFH

LOOP:

MOV A, M
STAX D

// The content of register A is moved to the memory location

whose address is in register pair D-E

INX H
INX D
DCR C
JNZ LOOP // Jump on not zero, i.e. the result of decrement is not zero.
HLT
Assembly language instruction sequence for 8086 microprocessor.
In 8086, we have to define the data segment by setting the DS register. Assume that DS is
set appropriately

MOV SI , 1000 H
MOV DI , 2000 H
MOV CX , FFH
LOOP:

MOV AX , SI

MOV DI , AX
INC SI
INC DI
DEC CX
JNZ LOOP
HLT
The program listing is similar to the program of 8085, every instruction of 8085 is
replaced by an equivalent instruction of 8086.
Therefore, the above program listing is correct. But this is not an efficient implementation
for 8086, because we have not used any advance feature of 8086.
Alternate program listing for 8086 microprocessor
Assume that the data segment register and extra segment registers are set appropriately.

REP

MOV SI , 1000 H
MOV DI , 2000 H
MOV CX , FFH
CLD
MOVSB

CLD instruction clears the direction flag.

If the direction flag bit is 0, the string is processed in auto increment mode.
REP : This instruction is used as a prefix to other instructions. The instruction to which
the REP prefix is provided, is executed repeatedly until the CX register becomes
zero. At each iteration CX is decremented by one automatically. When CX
becomes zero, the execution proceeds to the next instruction in sequence.
MOVSB : A string of bytes stored in a set of consecutive memory locations is moved to
another set of destination locations.
########################### END OF FILE ###############################