Complex Electronics Overview
Complex
electronics (CE) encompasses programmable and designable complex
integrated circuits. “Programmable” logic devices can be
programmed by the user and range from simple chips to complex devices
capable of being programmed on-the-fly. Some types of programmable
devices are:
“Designable”
logic devices are integrated circuits that can be designed but not
programmed by the user. The design is submitted to a manufacturer for
implementation in the device. Application-Specific Integrated Circuit
(ASIC) is an example of a designable device.
In the
term complex electronics,
the complex adjective is used to distinguish between simple devices,
such as off-the-shelf ICs and logic gates, and user-creatable devices.
Specific rules for distinguishing between simple and complex
electronics are provided in the Planning for
Assurance section. A good rule of thumb is, if you can program or
design the internal logic of the device and it has more than a few
gates and connections, it is probably complex.
Note
that firmware (which is essentially software stored on a read-only
device) is not considered complex electronics. The integrated circuit
(e.g. EPROM) is simple electronics. The program stored in that device
is software, which has a defined assurance process in place.
The
sections below provide an overview of the various types of complex
electronics that are covered by this assurance process.
Complex Programmable Logic Devices (CPLD)
A
Complex Programmable Logic Device (CPLD) contains a set of simple
Programmable Logic Device (PLD) blocks whose inputs and outputs are
connected together by a global interconnection matrix. A CPLD has two
levels of programmability: each PLD block can be programmed, and then
the interconnections between the PLDs can be programmed. A key feature
of the CPLD architecture is the arrangement of logic cells on the
periphery of a central shared routing resource. CPLDs use EEPROM, SRAM,
or Flash memory to hold the interconnect information.
Field Programmable Gate Array (FPGA)
Field-programmable
gate arrays (FPGAs) use a different mechanism, based on gate-array
technology, than CPLDs. Field
programmable simply means that the device can be programmed
by the user. Many field programmable devices can be programmed with the
chip soldered to the circuit board, allowing true “in the
field” upgrades to be possible.
FPGAs
use a grid of logic gates, similar to that of an ordinary gate array.
An FPGA has a collection of simple, configurable logic blocks arranged
in an array with interspersed switches that can rearrange the
interconnections between the logic blocks. Each logic block is
individually programmed to perform a logic function (such as AND, OR,
XOR, etc.) and then the switches are programmed to connect the blocks
so that the complete logic functions are implemented. FPGAs vary in
size from tens of thousands of logic gates to over a million.
The
interconnections for the logic blocks are programmable switches. FPGAs
may use EEPROM, SRAM, antifuse, or Flash technology to store the
programming. In most larger FPGAs, the configuration is volatile, and
must be re-loaded into the device whenever power is applied or
different functionality is required.
Application Specific Integrated Circuit (ASIC)
Application
Specific Integrated Circuits (ASICs) are pretty much what their acronym
says - integrated circuits (ICs) designed for specific applications.
Unlike standard ICs which are produced by the chip manufacturers, ASICs
are designed by the end user and then produced in volume. ASICs allow a
user to combine many parts and functions into a single chip, reducing
cost and improving reliability.
ASICs
can be large or small. They are usually produced in large quantities,
and it can be very expensive to produce only a few. ASICs can include
programmable logic (FPGA, CPLD, and PAL) devices as part of the chip.
If the ASIC includes a microprocessor and other computer peripherals,
it is usually referred to as a System-on-Chip device.
System-on-Chip (SoC)
System-on-Chip
(SoC) combines all the electronics for a complete product into a single
chip. SoC’s include not only the brains (e.g. microprocessor) but
also all required ancillary electronics, such as switches, comparators,
resistors, capacitors, timing elements, and digital logic.
|
SoCs
could include:
- Digital/analog
functions
- Sensors
- I/O
- Communications
- Ready
made sub-circuits (IP)
- Programmable
devices
- Digital
Signal Processor
|
|
SoCs are
usually ASICs, though they can be designed to include programmable
logic components. SoCs can also be implemented on FPGAs. System-on-chip
versions come in several flavors:
- Soft Instruction
processor architectures allow a designer to customize the CPU
architecture. The specific instructions supported, the peripherals
available to it, and the number of registers is just some ways
these devices can be tailored for your application. Some vendors
provide mechanisms to add, delete, and create highly tailored
instructions. Design packages for these architectures sometimes
include performance tools with instant feedback on the
performance, die size and power requirements of a particular
design. With the final architecture residing in silicon, these
types of architectures are well suited for high volume, low cost
applications which formerly would have used ASICs.
- Configurable processors
are FPGA based. In these architectures, standard and
customer-derived logic engines can be easily added, modified and
extended as needed. By moving discrete logic functionality to
internal FPGA the designer gets a highly flexible logic solver,
based around a standard processor core. With FPGA logic instead of
foundry logic, the logic can be easily revised at any point in the
design cycle.
In-field or reconfigurable SoC
Most
system-on-chip (SoC) designs use what is called a platform-based
solution, where standard components like a microprocessor core make up
a significant portion of the SoC. Custom devices provide further functionality.
Some of those devices may be user-configurable (e.g. if a small FPGA or
CPLD is part of the System-on-Chip device), others may be
designer-chosen only. These types of SoC’s are usually
implemented as ASICs.
A
reconfigurable SoC provides the same kind of custom support, except
that the devices and peripherals are implemented using a reconfigurable
matrix. The software must set up the hardware before it can be used.
But from that point on, the platform-based SoC software and
reconfigurable SoC software will be very similar, assuming that the
microprocessor core is the same or similar and the functionality of the
peripherals has the same characteristics.
With
reconfigurable SoC designs, the hardware functionality can be changed
simply by altering the code that performs system initialization. So,
SoC could contain an analog-to-digital converter for one application,
and then be reconfigured for a digital-to-analog converter, or even a
totally different peripheral such as a network device, for another application.
Some elements of the reconfiguration can be performed at a later time
(after the basic hardware is initialized), allowing software
applications to reconfigure devices
FPGA microprocessors/systems
Some
system-on-chip (SoC) devices are implemented entirely on programmable
logic, such as field programmable gate arrays (FPGAs). Most
reconfigurable SoCs fall into this category. However, reconfigurable
SoCs use a fixed microprocessor with reconfigurable peripheral devices.
What if you could change your microprocessor by just reprogramming the
FPGA? What if you could customize the microprocessor for your
application, then change it when that application changes? That is what
the FPGA microprocessor systems offer.
Recent
advances in software-oriented design tools for FPGAs, combined with the
ongoing increase in device densities, create a new environment for
software developers. In this environment, the FPGA can be viewed as one
possible target (along with traditional and non-traditional processor
architectures) for a software compiler. Tools are now available to help
software engineers make use of FPGA platforms, as well as platforms
where traditional processors (or processor cores) and FPGAs are.
Reconfigurable computing
Typical
computer systems use a single microprocessor that executes instructions
sequentially. They are adaptable and configurable - you can write any
kind of operating system or run any sort of application on a
microprocessor. However, these systems trade speed for that
adaptability.
If you have
a fixed set of applications and really need more processing speed, you
want an ASIC designed to meet your needs. While you can gain
significant improvement in speed, you lose the ability to change the
processor/ASIC uses outside of a narrow range of applications. The ASIC
speed increase over general purpose microprocessors comes from a
combination of optimization for the specific purpose and the ability to
perform processes in parallel.
What if
you want speed and adaptability? To gain speed, you need to move from
the serial processing paradigm to parallel processing. One way to do
this is to use multiple processors, each performing operations in
parallel. Another way is through reconfigurable computing. Both of
these methods keep the adaptability component, allowing the user,
through software, to run a wide variety of applications.
To have
reconfigurable computing (RC), you need to have hardware that can be
reconfigured to implement specific functionality. RC systems contain
programmable hardware and may be combined with traditional
microprocessors in order to take advantage of the strengths of each
device. RC has been used in applications ranging from embedded systems
to high performance computing.
Reconfigurable
computing uses in-situ reconfigurable FPGAs as computing devices to
accelerate operations which otherwise would be performed by software.
The FPGA can be programmed with a digital circuit which implements the
function to be performed, such as a fast square root operation. The
processor can then access this function, as if it were in its own
instruction set. When the processor needs another function, such as
multiplying two numbers, the FPGA can be reprogrammed for that
function.
To make
this all work, the FPGA must be capable of being reconfigured quickly
and allow only parts of the device to be reprogrammed. Reconfiguration
has to be fast, or you quickly eat up the speed advantage you gain from
moving the functions from the microprocessor to dedicated hardware. You
would also lose too much time if the FPGA had to be entirely
reprogrammed when you just want to change part of it. Fortunately,
modern FPGAs are up to the challenge.
|
