All files are for educational and/or historic purposes only. [back to library]

                         :::::::::   ::::::::  :::::::::  :::::::::: 

                         :+:    :+: :+:    :+: :+:    :+: :+:        

                         +:+    +:+ +:+        +:+    +:+ +:+        

                         +#++:++#+  +#++:++#++ +#++:++#:  :#::+::#   

                         +#+    +#+        +#+ +#+    +#+ +#+        

                         #+#    #+# #+#    #+# #+#    #+# #+#        

                         #########   ########  ###    ### ###  




           _______________________I      Topic:        I_____________________

          \                       I   Bascis of am     I                    /

           \     E-mail:          I    3mp33j3w        I   Written by:     /

            >                     I                    I                  < 

           /    [email protected]        I____________________I      Ralph        \

          /___________________________>           <_________________________\         

Basics of am 3mp33j3w

by Ralph ([email protected])

    -AWC ( 

1.  Introduction

    -About this thing

    -Who should read this?

    -Brief intro to Mircoprocessors

2.  Basics



    -Data Register

    -Address Register

    -Program Counter

    -Stack Pointer

    -Instruction Register

    -Instruction Decoder

3.  Architecture


    -Instruction Responses




    -Microprocessor Instructions

    -Modes of Addressing

      -Inherent Mode

      -Immediate Mode

      -Direct Mode

4.  Machine Cycles

5.  Interfacing




6.  Other

1.  Introduction


About this thing


This article will explain the basics of general MPUs.  It is by no means in-depth or 

anything, but it should be enough.  I'm taking a fairly lowlevel approach to this thing.

As in, I will be talking about the circuits and such.

Please note that while I tryed to keep this information as acurate as possible by 

reading multiple views on something, I can't guarentee that this info is actually all 

true since I don't know anyone who wants to and knows enough to proof-read it.

Also, this thing is very general!  Just by reading it you won't be able to distinguish 

an Apple from an IBM or even a calculator.

Finally, even though this thing only explains the very basics of CPUs, it's not really 

recommended reading material for people who are new to computers.  I assume you're

familiar with concepts such as the binary numbering system, PC hardware, circuits, etc.

Who should read this?


I have honestly no idea.  Maybe low level programmers, or people new to this might be

able to put this to some use.  This is basicly just background information you should

know, but will most likely never actually use it.  Kinda the way most people in

high school math are thinking.  In addition, this information is fairly old, thus some 

of this shit has long since been replaced or added on to.

Brief intro to Mircoprocessors


Inside every computer, there is a little ceramic block of purified crystaline silicon, 

coated with impurities that give it electronic swithing abilities, and etched with 

poisonous gases.  This little block was developt in 1971 by Integrated Electronics 

(Intel).  The earliest version of this thing was the 4004 chip used in Japanese

calculators.  One year later, the founders of Intel, Robert Noyce and Gorden Moore, 

designed the 8008 chip.  These things sold rapidly and Motorola produced it's own chip,

the 6800.  I little later more companies like Signetics (the 2650) and Rockwell 

(the PPS8) produced their own chips.  Still later many companies started releasing a

new generations of chips with more functions build into a single chip.  Those are for

example Fairchild and Mostek's F8, Intels 8048, and my favourite, Zilog's Z80 (still 

used in GameBoys).  The Z80 stands out because it can handle the numbers DEAD and BEEF.

Ph33r!  Anyway, eventually most of these companies droped out of the race, and only

Intel and Motorola kept on developing new processors.  Intel started to work with IBM

and produced such famous chips as the 8088 and the 8086.  Later a number was added

with each new version: 80286, 80386, 80486.  The 80586 was renamed to Pentium.  Motorola

on the other hand went to Apple.  I don't like Apples, so I have no idea what the 

current chip versions are.



A microprocessor is a chip which must perform at least all following functions:

* Receive and store binary data

* Perform arithmetic operations

* Make Logical decisions

* Deliver processed data to output circuits

These statements are very general, and along the way, I will explain how each is




ALU stands for Arithmetic Logic Unit, and is just that.  It performs all the arithmetic

and logical operations based on binary data being fed to it.  It performs additions

viva combinational logic based on usually a Full Adder Circuit.  Subtractions is done

by first negetating the numbers, than adding them.  Mulitplication and Division is done

by repeaded adding or subtracting respectivly.

This k-rad ASCII shows you how the ALU would go about adding two numbers (well it's

supposed to anyway):


            |  Memory  |


            |          |

         Number 2   Number 1

            |          |

+-----------+          +-------------+

|Accumalator|          |Data Register|

+-----------+          +-------------+

      \                       /

    Number 2             Number 1

        \                   /

         \                 /


          |      ALU      |








NOTE: The accumalator that stores the result is the same that stored number 2, I 

      just couldn't figure out how to express that in ASCII.



This is a multi-purpose circuit section.  As you can see from my ASCII picture it will

not only hold a number to be mulitplied, but also store the result.  Usually, the result

will than be transfered to some form of memory.

Data Register


Temporary storage for data comming from, and going to the bus.

Address Register


Conains the address of the current memory data.  Used to access specific points in 


Program Counter


As the name implies, this thing keeps track of the memory location containing the next

instruction to be executed.  Whenever a break in the flow of the program (a jump, call,

interrupt, etc), the current number in the program counter is stored in on the stack and

the new location goes into the program counter.  When the break is finished and control

is returned to the original routine, the number on the stack gets poped back into the

program counter.  On most modern CPUs this part would be the Instruction Pointe (IP)


Stack Pointer


A data structure that records the last program step prior to a break in the routine.  

There are two basics systems.  One is to store the last program step in memory and use

the stack-point counter to index the address.  The other is the one used on almost all

systems today, Last In First Out, or LIFO.  Think of it as a stack of books.  You put 

one on top of it, and that one will be the first one to come of next.  Putting stuff on 

the stack is called Pushing, getting stuff from the stack is called Poping.  For 

example, say you have 5 books called A, B, C, D, and E stack on top of each other like 







Now you add (push) book F to the stack:







If you pop the stack, you get book F back and the stack looks like this again:






Instruction Register


The IR holds the binary data fetched from memory during the decoding and executing of

that instruction.  

Instruction Decoder


The ID sets up the logic which controls the entire MPU.  This includes the control 

lines, the clock, and bus access.  Everything happending in your processor is controlled 

from this section of the chip.  Sometimes you may here that everything is controled by 

the Control Unit, but in fact CU is just a name that summarizes the previously discussed


3.  Architecture


Architecture in terms of processors means the layout of a chip.  This might not seem

as important, but the architecture is what has so far kept Intel alive and dominant.

Every single micrometer has to carefully layed out for best performance and efficiency.



Buses are a conductors that transfer binary data in a system.  A bus can be external, 

or internal.  External buses are known as System Buses, but we're only interested in the

internal buses, as they dictate the architecture of the CPU.  

The most basic bus design is the Single-Bus System.  In this design one one set of

conductors is used to connect all the units.

31337 ASCII warning!


              |       |     |    |   |

              |       |     |  +---+ |  

              |       |     |  |ACU| |

              |       |     |  +---+ |

              |       |     |    |   |

            +---+   +---+   |    +---+

            |R1 |   |R2 |   |    |ALU|

            +---+   +---+   |    +---+


<> - Two-way data flow

<  - One-way data flow

Sorry, didn't feel like making a detailed diagram here, but you can kinda see what I

mean.  There is only a single major bus connectiong all registers and the ALU.  There 

are other conducting paths branching, but those aren't important.  This design is not 

being used anymore as it is very slow.  You can see that doing a simple multiplication 

would already require to be done on a time-sharing basis.  This of course slows the 

whole thing down by quite a bit.  However this design does have one advantage, size.  

It's very small, thus the next generation of pens will most likely be using it (that was 

a joke by the way).

To get around this speed problem, designers used the Triple-Bus System.  In this design

3 seperate main buses are being used.  Sorry, no ASCII for this one, just too complex

for notpad

Actual chips today are even more detailed.  They use a decendent of the triple-bus 

design and the bus can be anywhere from 8-bit to 64-bit in size (that is, between 8 and 

64 conducting wires).  And again, no ASCII for this one, if you're a good ASCII

artist, please contact me and I could send you a .bmp or something.  Might not be

easy to draw a detailed 8080 chip with characters though :).

Instruction Responses


Every instruction invloves a three-stage sequence, Fetch, Decode and Execute.


In this stage the Program Counter is switched to the address bus and the binary sequence

is read by the Address Decoder.  Then latched into the Instruction Register.


When the fetch was completed successfully, the decoder kicks in.  The binary data

recieved represents a specific instruction, and will be conditioned in the Programmable

Logic Array (PLA) in the decoder.  This part of the MPU is a complex network of

combinational logic.  The sequences that occur in the decoder are controled by an 

internal ROM called CROM, or Control Read-Only Memory.  This thing sets up a control

sequence corosponding to the instruction code entered (OpCode).  Every MPU has its own 

unique CROM with a set of OpCodes (Operating Codes) called Instruction Set.  Back in

the days, the 8080 has 78 different opcodes, today a Pentium has about 700.  Some (well 

most) of these have additional paramters called Operands following them.  These are 

fetched as the opcode is executed.


After decoding the instruction, the execute unit directs the synchronzing signals which

control the ALU, memory, and I/O circuits.  This sequencing and timing is kepy in sync 

by the Program Counter, which keeps track of every step in the program and control 

breaks as mentioned earlier.

Microprocessor Instructions


Every MPU is designed to respond to a fixed set of instructions.  As mentioned above,

the old 8080 has 78 of them.  However, opcodes actually consist of two parts.  One part

indicates the address mode, the other the actual code.  Usually, only 2 bits are used

for the address mode part.  A 8-bit computer can thus theoreticly have 64 opcodes, but

manufactures usually push this limit a bit and include a few variations.

Some opcode examples are:

Binary     Hex   Mnemonic  Describtion

01110010b  72h   JC        Jump short if carry flag set

00001100b  0Ch   OR AL     Perform logical OR on contents of register AL

Binary is the raw instruction opcode being used in the Decoding process, Hex is the

same number converted to hexidecimal, mnemonic is a more human readable form of that

instruction.  Mnemonix are what assembly programmers code in.

Modes of Addressing


As stated before, a opcode usually contains two bits telling the MPU what addressing

mode to use.  I will cover the three basic (and outdated) 16-bit address modes, 

Inherent, immediate and Direct.

Inherent Mode

This mode invlovles the MPU chip itself as data is being stored on one or more of the

onchip registers during the execution of the instruction.  The opcode itself holds

all the information required to execute the instruction.  Each register is identified in 

the opcode.  For example, say we want to add registers A and B, where A = 000 and 

B = 111, the opcode for that might be 01000111  The 01 indicates Inherent Mode 

addressing, the 000 the source register, and 111 the destination register.  As you can 

see, this opcode contains all the information the decoder needs in order to execute this 


Steps to execution:

1.  a) Fetch instruction

    b) Decode instruction

2.  Execute instruction

Immediate Mode

This mode involves the opcode PLUS the operand.  The operand can contain (at the time

this was writen) 8, 16, 32, or 64 bit information.  This information can either be

an address where data to be used is located, or the data itself.  The decoder is told

how many more bytes to read in by the opcode.  An example of this is a jump instruction.

First comes the opcode telling the MPU to perform a jump, the next few bytes contain

the address to jump to.

Steps to execution:

1.  a) Fetch instruction

    b) Decode instruction

2.  a) Obtain operand

    b) Execute instruction

Direct Mode

This mode is used when transfering data from the MPU to memory or vice versa.  

Instructions based on this mode come in three bytes, one for the opcode, two for the 

(16-bit) address.  For example, the following statement moves the value DEADh into the 

AX register:

10111000 10101101 11011110

10111000 is the opcode for move AX.  Since AX is a 16 bit register, the decoder will 

assume that the next 16 bits are are the value.

Steps to execution:

1.  a) Fetch instruction

    b) Decode instruction

2.  a) Obtain address

    b) Decode address

3.  a) Obtain operand

    b) Execute instruction

4.  Machine Cycles


Timing is a very important thing in MPUs.  Many circuits share the same data bus, and

must be precisly timed.  I briefly mentioned this earlier, and now I'm covering it a bit

more in-depth.

MPU instructions are executed by the control section and timed by a series of machine

cycles.  The cycles are subdevided into 5 parts called Clock Periods.  A instruction 

from memory is given 5 clock periods in which it must complete the instruction.  If it

finishes in less than 5 clock periods, the remaining periods are idled.  The following

k-rad ASCII shows a instruction fetch cycle:

|---Machine Cycle---|


| 1 | 2 | 3 | 4 | 5 |


|-----------| |   |

      |       |   |

 Instruction  |  Idle

    Fetch     |


         Increment PC

          and decode

On a modern computer one machine cycle occurs ever 1193180/65536 of a second, or about


5.  Interfacing


Without interfacing, a MPU is about as usefull as condom made of ice.  Even the simplest

task requires some sort of way to input data, and some way to get the output.  In fact,

interfacing is so fundamental to the MPU that a interfacing apparatus is usually already

part of the MPU design.



When the MPU recieves data, and performs some function, the result is placed on a data 

bus.  These bits can then be read by any imaginable device.  All that is necessary is a

decoder than can read those bits.

31337 ASCII Alert!

+------------+    +------------+    +------------+

|            |    |            |    |            |

|    MPU     |    | Interfacing|    |   Display  |

|            |----|   Chip(s)  |----|            |

|            |    |            |    |            |

+------------+    +------------+    +------------+

6. Other


I cannot be held responsible for anything that happens to you as a result of using this 


You may freely distribute this text as long as you don't change anything.  If there's

something you think should be changed, contact me first.

Send feedback to [email protected]

And very important!  If you noticed a mistake (speling, grammer, and especially 

technical!), please contact me asap.  As I said before, most of this information is 

fairly outdated and useless, if you know of a specific change that has happened to

anything discussed here, please let me know.

Please always get the newest version of this and other tutorials at as they usually contained updated information, and addons.

Greetings to:

cozgedal, Alf (the cat eating fury dude), Sad1stick, rpc, moJoe, Lindex, and everyone I

forgot to mention.

This space intentionally left blank.