Skip all navigation and jump to content

Jump to site navigation

NASA Logo

+ Visit NASA.gov

Assurance Process for Complex Electronics

Home

Complex Electronics background

Complex Electronics Assurance Process

TECHNIQUES

CHECKLISTS

Site Map

CE Overview

COMPLEX ELECTRONICS overview

Complex Electronics DESIGN PROCESS

MAP TO PROJECT LIFE CYCLE

Print this section

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.

 

FirstGov logo

+ NASA Privacy, Security, Notices

NASA

Curator: Richard Plastow
NASA Official: Cynthia Calhoun
Last Updated: 02/23/2006