The key to a microprocessor is its ability to communicate with itself. It is a sequential logic circuit. Previously, we have only been talking about combinational circuits, whose outputs are only a function of the inputs. In a sequential circuit like a microprocessor, the output is a function of the input, as well as the current, or previous state. As we build parts of the microprocessor, we will repeatedly utilize our answers from one part, as an input to something else, or even looped back to the beggining.
A typical microprocessor is organized like this:
Here the ROM section would contain the read only memory, while the RWM contains Read Write Memory. There are two main type of RWM memory, including RAM and sequential access memory. Ram is the key memory where we store the data that we are working on, while sequential access memory is memory like a magnetic tape, or CD-Rom Disc. In both of these types of memory, the data location is represented by a binary address. This address is how we are able to get into the contents of the memory by calling its address through our address bus. The I/O section is our input output section that lets us talk to the rest of the universe, as well as receive input.
Our basic microprocessor, like most, is based on a fetch/execute cycle. When the microprocessor is in the fetch state it must receive a command from one of its memory locations, or from the I/O lines. Once this instruction is fetched, our microprocessor switches into execute state. In this state the processor induces changes onto memory in various locations as the command instructs. There is only one exception to this otherwise infinite process--halt. After a halt call, a reset is necessary to place the processor into a fetch state. This can be used more extensively in multiprocessor lines, although there are many different implementations here. For now, we will use the halt line only in relation to our memory stack. Let's take a closer look as to just how the processor actually fetches an instruction. To fetch an instruction, our microprocessor sends out the address of the next instruction on the address bus. The external memory returns the instruction along the data bus. The internal processor Program Counter is responsible for the determination as to the next instruction address. The fetch process therefore begins by transferring the contents of the Program Counter to an internal address register. The internal address register is responsible for storing this information, and then feeding the address bus. Our now fetched instruction then enters the microprocessor along our data bus. The fetched instruction first passes into a temporary memory location known as the instruction register. This then flows into the instruction decoder. This decoder is responsible for translating our instruction into the binary control values which are used by the control unit of the microprocessor. The instruction that is passed may contain both an operation, as well as data to operate on. This is usually taken care of within the internal processor memory, or cache, but can be put to external memory as well. The control unit then issues the appropriate signals to the Arithmetic Logic Unit, or ALU. This then passes the correct operands to the ALU as well as any other parts of the microprocessor, or I/O system.
The actual microprocessor computation takes place inside the processor's ALU, and several accumulators. The accumulator holds an operand while the temporary accumulator holds the other operand. The ALU performs a specified arithmetic or logical operation on these operands ans stores the result in the accumulator. The ALU also generates a set of flag signals which are passed onto a (you guessed it) Flag register. These flags indicate certain specific results, such as a result of 0, or an overflow error.
The next major stage that we will be covering will be to make the accumulators and ALU talk to memory, and use PLA's. After we finish with that, our introduction to our processor will be complete. This will lead us into the more facinating world of acually building a microprocessor.
Jump Back to the Processor Design Home Page