See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/4342279

FPGA Implementation of an 8-bit Simple Processor

Conference Paper · May 2008

DOI: 10.1109/TPSD.2008.4562743 · Source: IEEE Xplore

CITATIONS READS

15 873

5 authors, including:

Eric Ayeh Parthasarathy Guturu

University of North Texas University of North Texas
5 PUBLICATIONS   23 CITATIONS    27 PUBLICATIONS   263 CITATIONS   

SEE PROFILE SEE PROFILE

All content following this page was uploaded by Eric Ayeh on 21 May 2014.

The user has requested enhancement of the downloaded file.

 FPGA Implementation of an 8-bit Simple Processor
E. Ayeh, K. Agbedanu, Y. Morita, O. Adamo, and P. Guturu
1
Department of Electrical Engineering
University of North Texas, Denton, TX. 76207
USA

suitable for different types of designs where errors and components

Abstract— Since its “birth” in 1971, embedded failures can be limited.
microprocessor has been widely used as a tool for
Our FPGA-based 8-bit processor designed using the VHDL
technological innovations and cost reduction. Its speed and
language mainly consists of 4 4-bit registers, a 16-word memory with
programmability are the main characteristics determining its
8-bit words, a control unit, and an arithmetic logic unit (ALU).
performance. Therefore, for a design to be competitive, its
processor has to fit the following characteristics: relatively Due to the exponential increase of technologies; designers are faced
inexpensive, flexible, adaptable, fast, and reconfigurable. A with problems that require the advent of systems that can be fast,
solution to this is the use of Field-programmable gate arrays flexible, and mainly re-programmable. FPGAs because of their
(FPGA) as design tool. This paper describes the realization advantage of real-time in-circuit reconfigurability make the FPGA
of an 8-bit FPGA based simple processor. Our system was based microprocessor flexible, programmable, and reliable. They
implemented on the Xilinx Spartan 3 xc3s200FT256 using also facilitate the prototyping of complex electronic designs.
ISE foundation 8.1 and VHDL. 132 (6%) of the slices, 351
Bels were used. A maximum frequency of 95.364 MHz was
reached with a minimum period of 10.486 ns. II. RELATED WORK

Due to the cost of ASIC design and the speed of DSPs

processors that is involved in the development of flexible
I. INTRODUCTION
devices, many engineers are now turning to FPGA. As a result,
Nowadays, embedded microprocessors are used in a variety of many significant works have been based on FPGA. However,
electronic products such as personal computers, cell phones, and not all of them are related to the actual design of a processor.
robots. They consist of thousands of electronic components and use a
collection of machine instructions to perform not only mathematical In [1], the implementation of a systolic array architecture in
operations but also to move information from one memory location hardware using FPGAs for processing compressed binary
to another. images without decompressing them is proposed. In [2], the
author talked about how a high performance of embedded
The processor or Central Processing Unit (CPU) is the heart of the systems and real time computing can be obtained through the
computer. It determines in a large part, how fast the computer will be use of FPGA technology. Similar to the previous writer the
and what capabilities the machine will have. As designers we have a authors in [3] dealt with the reliability of FPGA platforms in
choice between using digital signal processors (DSPs), FPGAs, or the design of embedded systems. In fact, a soft processor
application specific integrated circuits (ASICs) in our designing which is a programmable instruction processor and a
process. In this paper, we implemented an FPGA-based processor. methodology for measuring their area, performance, and
power was proposed as a solution. The authors in [4]
ASICs customized for a particular use are very expensive even
described a system that can enable FPGAs to generate machine
though they provide the highest performance. DSP based designs,
code for various CPUs. The system will perform a conversion
on the other hand, are cost efficient and low in power consumption
of an intermediate to a CPU’s native code for applications in
and heat-emission. However, they only provide a limited speed for
virtual machines such as the Java Virtual Machine. In [5], the
data processing because using special memory architectures that are
implementation of a floating point processor array for a high-
able to fetch multiple data and/or instructions at the same time, they
precision dot product is described. The authors mentioned the
are susceptible to arithmetic saturation.
cost and configurability benefits that can be obtained through
FPGAs are usually slower than ASICs but have the advantage of the use of FPGA. The authors in [6] used FPGA as a practical
shorter time to market, ability to be re-programmed in the field for experimentation and verification platform for emulation of
errors correction and upgrades, flexibility, and low-cost. Therefore, hardware without the non-recurring cost engineering (NRE)
they combine many advantages of ASICs and DSPs. The use of costs of ASIC hardware. The use of FPGA as a design tool can
hardware description languages (HDLs) allows FPGAs to be more provide not only cost but also performance benefits. In [7], the
accuracy, rapidity, (re)configurability, transparency and the
cost of FPGA as computer simulator were discussed. In this
paper, we present the FPGA implementation of a simple
978-1-4244-2077-3/08/$25.00 ©2008 IEEE.
processor with limited resources. The processor was jump, leaving room for the last set of instructions to be carried
implemented on the Xilinx Spartan 3 xc3s200FT256 using ISE out.
foundation 8.1 and VHDL.

Figure 2: Branch Instructions

III. INSTRUCTION SET
The Halt & I/O Instructions are carried out only with an input
Our processor is designed to input an 8-bit set of instructions,
of 1100 in the first four bits. When the third bit is 1, the
which will be used to determine most of the operations needed
processor will enable loading from a fixed register to the data
as well as their addresses. The first (higher) four bits are
register specified. When the fourth bit is 1, the processor will
generally used to determine an operation while the last (lower)
display the information located in the destination register on
four bits are used to determine an address. A memory unit is
the seven-segment display. When both L and H are, an error
used to store the instructions and registers are used to store the
will occur and no changes will be made. (Figure 3)
addresses. The three different types of instructions used are:
Register Instructions, Branch Instructions, and Halt & I/O
Instructions. The register instructions are used to perform
arithmetic operations and add them to and from the data
registers. The instruction format for register instruction is
shown in figure 1 and it consists of the OP, CC, SRC, and Figure 3: Halt & I/O Instructions
DST fields.
IV. MICROPROCESSOR DESIGN
In Table 1, an input of 00 will extract information from a Our FPGA-based processor consists of several units. These
source register; add it to the carry bit (CI), and place the result units can be classified in two different categories. We have
in the destination register (DST). In the same fashion, an input the main components which are: a control unit, an Arithmetic
of 01 will insert the information from the source, CC, and Logic Unit (ALU), and the memory. The sub-components are:
destination addresses back into the destination address. a program counter, an instruction register, a 4-bit data register,
Finally, the input of 10 will delete the information in the multiplexers (MUX), demultiplexers (DMUX), NAND gates,
Source and Carry addresses from the destination address and and D-latches. The figure below represents the block diagram
add the result to the destination. of our processor.
The value of Carry In can be determined by the user. However,
predetermined values exist depending on CC. In fact, as shown
by Table 2, if CC is 00, CI will always be 0. Likewise, CI will
always be 1 with a CC value of 01. If the user inputs a value
of 0 for a CC of 10, the outcome will be 0. If the input value is
0 or 1 for a CC of 11, the outcome will be 1 and 0
respectively.

Figure 1: Register Instructions

Figure 4: Complete processor map

Assuming that we have the instruction “00000100” we first

used the switch registers to input the instruction, and then
stored it in the first memory location. Once the start button is
Table 1: Basic Register Instructions Table 2: Carry Bit usage based on CC bits
set on, the same instruction goes to the instruction register
which is the temporary storage for the memory and it separates
Branch Instructions are used to jump to a particular memory the instruction into four fields: OP code IR[7-6]”00”, CC
address specified by the last four instruction bits. The IR[5-4]”00”, SRC IR[3-2]”01”and DST IR[0-1]”00”. OP and
operation will only be carried out whenever the first two bits CC goes to the control unit which coordinate the different units
are 11 and the carry is positive as illustrated in Figure 2. The of the processor. For example, the program counter indicates
following three conditions result in a jump of address: CC = where the computer is in its instruction sequence and is
01, CC = 10 and CI = 1, CC = 11 and CI = 0. A CC address of incremented by the control unit. The 2-bit value of the SRC
00 will never be reached, since the conditions will not always segment which represents the address of the register containing
the actual value to be calculated goes to the MUX 1 as shown
in figure 4. The MUX then chooses a register and pick up the
value and then send it to MUXA and then to the ALU. The
instruction (SRC) + C I → ( DST ) sets C I to”0000” which
contains the value of CC, and send it to MUXB, and then to
ALU. Finally, the ALU processes the addition and outputs the
result to DMUXB. Furthermore, the 2-bit value of the DST
goes to the DMUXB as “select”, and the DMUXB transfers
the ALU’s output value to the destination register.

A. Control Unit
Our control unit is modeled as finite state machine (FSM) and
has 6 states. In the initial state, nothing happen until the start
button has been pushed. Once pushed, the control unit moves
to the zero state. In that state, an instruction is fetched from
the memory and put into the instruction Figure 5: Control Unit state diagram
register (IR ← Memory[PC ]) . The state is then upgraded
from zero to one. The instruction is then checked by the B. Arithmetic Logic Unit (ALU)
control unit. If a Register Instruction is determined, the PC is
incremented and the actual value in the source register along
An ALU is a digital circuit that calculates arithmetic
with the carry is sent to the ALU ( ALUout = ( SRC ) + C I ) . operations like: addition, subtraction, shifting and exclusive or.
The state is moved from state 1 to 2. If an Input instruction is For our case, the ALU will only be taking care of addition and
detected, the PC is incremented and the input bits are loaded subtraction. It is composed of a 4-bit full adder and a unit
into the register pointed to by the DST used to obtain the 2’complement of numbers for simpler
bits (Re g[ DST ] ← SW Re g ) and then the state goes back subtractions.
to state 0. If the instruction is Halt & Display instruction, the
PC is incremented; the machine halts, and displays the
contents of DST register ( Display ← Re g[ DST ]) . As a
result, the state is once again reset. If the instruction is
Unconditional Branch or Branch on Carry, the PC is
incremented and the address bits in the instruction register
goes to the pc (PC ← IR[0 − 3]) . The state then goes to
Figure 6: ALU structure
zero. The second state is only reached in the occurrence of a
register instruction. Depending on the op-code, the control C. Memory
unit works differently. If the Op-code is “00”, the output of Our memory is a 16-word 8-bit. Each bit of the memory
the ALU goes to the destination register (SRAM cell) in a static RAM has an AND gate, a D-latch, and
(DST ← ALUout ) and the state to zero. On the other a tri-state buffer as shown in Figure 7. When a cell’s SEL_L
hand, if the op code is “01” or “10”, then the output of the input is asserted, the stored data is placed on the cell’s output,
ALU goes back to MUX A, and the value in the destination which is connected to a bit line. When both SEL_L and WR_L
register also goes to the ALU which then adds them for are asserted, the latch is open and a new data bit is stored.
“01” ( ALUout ← ALUout + DST ) and subtracts for SRAM cells are combined in an array with additional control
logic to form a complete statistic RAM for a 16X8 SRAM. As
“10” ( ALUout ← DST − ALUout ) . The control unit then in a simple ROM, a decoder on the address lines selects a
goes to the next state. The third state serves as delay for specific row of SRAM to be accessed at any time. Once the
implementation purpose. Finally, in the fourth state the output row is decided, 8 bits data is written in the 8 SRAM or road 8-
of the ALU goes to the destination bit data to next component. Figure 8 illustrates the whole
register (DST ← ALUout ) and the state is reset. The state RAM.
diagram of our controller is shown in Figure 5.

Figure 7: Structure of an SRAM cell

 1011+0001=1100
(11 + 1= 12)

Figure 11: ALU addition operation

Memory: The 4 bits input of Decoder “0000”, which is the

first row of the memory (address A0) is selected. If the
purpose of this instruction in the position of address A0 is to
write and store, WR is also binary ‘0’, so both SEL and WR
are ‘0’, then the input Data in the D-latch will be the same as
the output of our D-latch. If Din (8 bits) is binary “10000000”,
then, ‘1’ goes through the D-latch. Because of the MUX, only
Figure 8: Memory structure
the values of first row of the memory will go to the tri-state
buffer, and then the output can be obtained.
V. IMPLEMENTATION & RESULTS
To ensure the quality of our design, all the units in the
processor were designed and tested separately. Once the
functionalities of each unit were verified they were combined
together as a block and once again tested. The following
images (captures of the testing) are the results of the
implementation of the main units.

Control Unit: The main function of the control unit is to

direct the operations of the processor. The inputs of the control
unit are taken from the instruction registers which are: OP,
CC, L and H. Depending on these inputs, the output signal
will be generated.
Figure 12: Memory simulation

Once these sub-elements were designed and tested, they were

put together to constitute our FPGA-based processor. The
simulation result of the whole processor is shown below:

Figure 9: Control Unit simulation

ALU: Results from binary addition and subtraction tested on

our ALU unit are as followed:

1010-0011=0111
(10-3=7) Figure 13: Processor simulation

Slices 132(6%)
Bells 351
Frequency 95.364MHz
Figure 10: ALU subtraction operation Minimum period 10.486 ns
Table 3: Synthesis report
 VI. CONCLUSION
We have successfully implemented an FPGA-based 8-bit
processor on Xilinx Spartan 3 board using the VHDL
language. Our processor is made of the control unit, and an
arithmetic logic unit (ALU) and a memory unit. Our processor
has a maximum frequency of 95.364 MHz and 132 slices were
utilized.

VII. ACKNOWLEDGEMENTS
The authors gratefully acknowledge the support provided by
National Science Foundation (NSF) grant number NSF –
0431818 “A Design- and Project- Oriented Innovative
Electrical Engineering Program”.

VIII. REFERENCES
[1] V. S. Balakrishnan, H. Pottinger, F. Ercal, and M.
Agarwal, Design and implementation of an FPGA based
processor for compressed images (poster abstract). In
Proceedings of the 2000 ACM/SIGDA Eighth
international Symposium on Field Programmable Gate
Arrays (Monterey, California, United States, February 10
- 11, 2000). FPGA '00. ACM, New York, NY, 218.
[2] R. Fryer, FPGA based CPU instrumentation for hard real-
time embedded system testing. SIGBED Rev. 2, 2 (Apr.
2005), 39-42.
[3] P. Yiannacouras, Rose, J., and Steffan, J. G. 2005. The
microarchitecture of FPGA-based soft processors. In
Proceedings of the 2005 international Conference on
Compilers, Architectures and Synthesis For Embedded
Systems (San Francisco, California, USA, September 24 -
27, 2005). CASES '05. ACM, New York, NY, 202-212.
[4] G. Achery, C. Trinitis, R. Buchty, "CPU-independent
assembler in an FPGA," Field Programmable Logic and
Applications, 2005. International Conference , vol., no.,
pp. 519-522, 24-26 Aug. 2005
[5] F. Mayer-Lindenberg, V. Beller, “An FPGA-based
floating-point processor array supporting a high-precision
dot product” Field Programmable Technology, 2006.
FPT 2006. IEEE International Conference on Dec. 2006
Pages: 317 – 320.
[6] Y Nagaonkar and M. L. Manwaring. “An FPGA-based
Experiment Platform for Hardware-Software Codesign
and Hardware Emulation” In proceedings of The 2006
World Congress in Computer Science, Computer
Engineering, and Applied Computing Pages: 169-174.
[7] D. Chiou, H. Sanjeliwala, D. Sunwoo, J. Z. Xu, and N.
Patil, "FPGA-based Fast, Cycle-Accurate, Full-System
Simulators," in Proceedings of the second Workshop on
Architecture Research using FPGA Platforms, held in
conjunction with HPCA-12, Austin, TX, Feb. 2006.

View publication stats