FPGA stands for Field Programmable Gate Array. An FPGA is an integrated circuit that can be programmed or configured by the customer or designer after manufacturing. This allows the FPGA to be customized to perform specific functions required for an application.
FPGAs contain programmable logic blocks and interconnects that can be programmed to implement custom digital circuits and systems. Unlike microprocessors that have fixed hardware function, the hardware logic and routing in an FPGA can be changed as needed by reprogramming. This makes FPGAs extremely versatile for many applications.
Some key capabilities and benefits of FPGAs include:
- Customized hardware functionality
- Parallel processing for high performance
- Reconfigurable digital circuits
- Prototyping and testing new device designs
- Flexible I/O configurations
- Low power consumption
- Short time to market
FPGAs are widely used for prototyping of new custom ASIC designs, specialized parallel processing applications, aerospace and defense systems, automotive systems, IoT and embedded devices, and other applications requiring flexible or high-speed processing.
Major manufacturers of FPGAs include Xilinx and Intel (formerly Altera). There are many different types of FPGAs optimized for applications like high-speed processing, DSP, low power, or high I/O density.
Brief History of FPGAs
The concept of field programmable logic devices emerged in the 1980s to fill a gap between inflexible application-specific integrated circuits (ASICs) designed for a specific task and programmable microprocessors that lacked performance for many niche needs.
In 1984, Xilinx co-founders Ross Freeman and Bernard Vonderschmitt invented the first commercially viable field-programmable gate array. This allowed circuit designers to configure the interconnections between a set of logic blocks to create custom digital circuits by programming rather than manufacturing a new chip each time.
Other FPGA companies like Actel (now Microsemi) soon followed in bringing programmable gate arrays to market. Early FPGAs were relatively simple with 1-10k gates and used in glue logic applications. As silicon manufacturing advanced, FPGA density and capabilities grew rapidly.
By the 1990s to 2000s, FPGAs with tens of thousands to over a million gates became more common. This allowed implementation of complex systems like entire microprocessors within a single FPGA chip.
FPGA architectures also evolved to add more embedded functions like memory blocks, DSP slices for math processing, programmable I/O, high-speed transceivers, and embedded microprocessor cores. Major vendors today like Xilinx and Intel produce FPGAs with billions of transistors capable of extremely sophisticated and demanding processing tasks.
FPGA Architecture Basics
The internal architecture of an FPGA consists of the following major components that can be configured:
Configurable Logic Blocks (CLBs) – The basic logic units that can implement simple Boolean functions and more complex functions. CLBs contain “look-up tables” that allow them to be programmed to perform any logic operation.
Input/Output Blocks (IOBs) – Provide the interface between the I/O pins on the FPGA chip package and the internal configurable logic. Support various signal standards.
Interconnects – The programmable routing between CLBs and IOBs. Allows flexibility in connecting internal components to implement a desired circuit function. Can include various lengths and types like global, regional, direct connects.
Memory – Many FPGAs include dedicated blocks of memory that can be used by the circuits mapped into the device. Saves integrating separate memory chips.
Embedded IP – Hard IP processor cores, DSP slices, PCIe interfaces, transceivers and other built-in functions may be included on higher performance FPGAs to optimize them for target applications.
Clock Circuitry – Managing and distributing clock signals across the FPGA is critical. Clock inputs, PLLs, DLLs, and clock buffers help achieve this.
The user programs the FPGA by specifying the Boolean logic functions for the CLBs, the interconnect wiring between blocks/IOs, use of memory and embedded IP, clocking resources, and I/O settings. This overall programming is called the configuration.
FPGA vs ASIC Differences
FPGAs differ in important ways from Application Specific Integrated Circuits (ASICs):
|User programmable after manufacturing||Custom manufactured for fixed function|
|Reconfigurable – logic can be updated||ASIC function is fixed once produced|
|Easier to prototype and implement changes||Costly and slow to change function once made|
|Parallel processing well suited for data flow applications||Often better performance and efficiency for fixed function|
|Generally lower volume applications||Higher volume justifies design costs|
|Lower development costs||Much higher development and fabrication costs|
FPGAs are more flexible and quicker to develop with but less optimized in final form factor or performance than a custom ASIC. The reconfigurability and lower cost of FPGAs make them popular for low and medium volume products where custom ASICs may not be justifiable. FPGAs are also widely used to prototype ASIC designs for testing before committing to ASIC fabrication.
FPGA Design Flow
The general workflow to implement an application with an FPGA consists of the following steps:
- Design Entry – The digital logic to be implemented is captured using a hardware description language like VHDL or Verilog or a schematic diagram. This is the source code describing the desired hardware functionality.
- Synthesis – The source code is synthesized into lower-level Boolean logic gate representations and optimized for the target FPGA architecture.
- Simulation – The design is simulated pre- and post-synthesis to verify correct functional behavior. Simulation aids debugging.
- Place and Route – The logic gates are “placed” into specific FPGA hardware resource blocks and “routed” together using available interconnect paths.
- Bitstream Generation – The placed and routed design is converted into a binary file that programs the FPGA configuration. This file is called the bitstream.
- Configuration – The bitstream is loaded into the FPGA device to actually configure its hardware resources to implement the user’s design.
- In-System Verification – The real world functionality on the FPGA is tested and debugged after configuration and integration.
FPGA vendors provide design and programming software tools to assist and automate this design flow. Popular tools include Xilinx Vivado and Intel Quartus Prime. HDL languages like VHDL and Verilog are used for design entry.
FPGA Programming Technologies
Several methods and technologies exist for programming the configurable logic in an FPGA:
SRAM Based – SRAM cells control the logic and interconnect configuration of the FPGA. Volatile, needs reconfiguring on power up. Most common approach used by major vendors.
Antifuse – One time programmable connections between logic blocks. Used in some lower cost FPGAs. Permanent once programmed.
Flash/EEPROM – Flash or EEPROM cells used for configuration cells. Allows reprogramming but nonvolatile so retains configuration on power loss.
CPLD – Complex Programmable Logic Devices have architecture between PALs and FPGAs. Smaller with more predictable timing.
Security/Encryption – Advanced FPGAs may have encryption and authentication protections on bitstreams to prevent IP theft.
SRAM programming is dominant due to its combination of reconfigurability and density. Antifuse, Flash and CPLD serve niche lower density roles. Security features help protect FPGA IP designs.
Major Applications of FPGAs
The flexibility and performance of FPGAs make them very attractive for many advanced applications including:
Aerospace and Defense – Used in guidance systems, radar processing, satellites, and mission computers where radiation-hardened FPGAs provide reconfigurable reliability.
Automotive – Implement display processing, ADAS, vision systems, powertrain control, driver assistance. Meet automotive reliability standards.
IoT/Embedded – Provide custom logic, low power consumption, and small form factors needed for sensors, wireless, and battery-powered devices.
Image/Video Processing – Hardware acceleration for algorithms like convolutional neural networks, encoding/decoding, and analytics.
AI Acceleration – FPGA inference engines that provide optimized parallel processing for neural networks and machine learning.
Prototyping – FPGAs used to model and verify functionality of new ASIC designs before manufacture.
FPGAs continue growing in capability and bridging into applications traditionally addressed by CPUs and GPUs. Their flexibility makes them the ideal choice when custom hardware acceleration is needed.
Major FPGA Companies
The two dominant vendors supplying the majority of FPGAs worldwide are Xilinx and Intel (formerly Altera):
- Founded in 1984, invented first commercially viable FPGA
- Offers broad portfolio including high-end Versal ACAPs and mid-range 7-series FPGAs
- Recently acquired by AMD for $35 billion as part of growth in adaptive computing
Intel (formerly Altera)
- Major provider of FPGAs after acquiring Altera in 2015
- Portfolio spans low-cost MAX 10 FPGAs up to flagship Stratix 10 FPGAs
- FPGAs used across Intel to prototype new products and technologies
- Leverages Intel manufacturing capability and combines x86 CPUs with FPGAs
In addition to these two FPGA giants, other companies filling specialty FPGA niches include:
- Microsemi – Radiation-tolerant FPGAs for aerospace/defense
- Lattice Semiconductor – Small, low power FPGAs for consumer devices
- QuickLogic – Low power embedded FPGA devices
- Achronix – High performance datacenter FPGAs
- Flex Logix – Low cost FPGA IP licensing
The FPGA market continues to see intense innovation and new entrants even as it consolidates around Xilinx and Intel. The growth of 5G, AI, embedded vision, and other applications is driving demand for more advanced programmable logic solutions.
Trends and Innovations in FPGAs
FPGAs continue to evolve rapidly to increase capabilities and provide advantages over other processing technologies for specialized requirements:
High Level Design – Raising design abstraction above HDLs by using C/C++, OpenCL, MATLAB, and other languages to describe FPGA behavior. This expands accessibility.
3D Packaging – Stacking FPGA dies and integrating with other dies like HBM memory enables much higher bandwidth and density.
Security – Root of trust, bitstream encryption/authentication, and other features to protect FPGA configuration and IPs from tampering or theft.
Cloud/Datacenter – Adoption in public cloud FaaS offerings and datacenter acceleration using FPGAs for their flexibility and performance per watt.
Soft MCUs – Soft microcontroller cores implemented internally within an FPGA for low cost embedded applications.
AI Acceleration – Optimized FPGA deep learning processors for inference using low precision and quantization to achieve efficiency.
FPGAs will continue to blur into adaptive computing devices as they evolve beyond basic programmable logic into heterogenous systems-on-chip. Their flexibility to reconfigure hardware logic on the fly makes them a foundational technology for the future.
Frequently Asked Questions
What are the main differences between FPGAs and CPLDs?
Complex Programmable Logic Devices (CPLDs) differ from FPGAs in several ways:
- Less logic capacity – typically thousands not millions of gates
- Based on sum-of-products architecture
- Optimized for predictable timing
- Live at power up (no configuration bitstream)
- Often lower cost and power
- Can be built-in flash/OTP instead of SRAM
So CPLDs serve simpler glue logic roles rather than implementing complex systems like FPGAs.
What are the advantages of using VHDL vs Verilog for FPGA design?
VHDL tends to be preferred for larger ASIC and FPGA designs requiring rigorous verification for manufacturability. Verilog started as a simulation language and is popular with front-end designers. Key differences:
- Strongly typed, English-like syntax
- Large set of data types
- Excellent tool support
- Suited for verification & top-down modeling
- C-like syntax, weaker typing
- Fewer data types
- Suited for behavior modeling
- Fast simulation, prototyping
- Widely used in education
How are FPGAs programmed/configured?
Most FPGAs are SRAM-based and programmed by loading a bitstream:
- Design logic is created and outputs a binary bitstream file after place & route
- On power up, bitstream loads from flash/storage into SRAM cells
- SRAM settings define logic, I/O config, routing to implement design
- This can be reprogrammed by flashing a new bitstream
So FPGAs provide complete hardware configurability via programmable SRAM-based bitstreams.
What types of CAD tools are used for FPGA design?
Common FPGA CAD tools include:
- Xilinx Vivado – For synthesis, place & route, bitstream gen
- Intel Quartus – Altera/Intel design suite
- SystemVerilog/VHDL simulators – ModelSim, Riviera-PRO
- MATLAB/Simulink – Model-based design entry
- C/C++ compilers – High level synthesis to gates
- IP libraries – FPGA vendor provided blocks
- PCB design tools – Connect FPGA pins to board
FPGA vendors like Xilinx provide integrated environments that take design entry through bitstream. Additional tools help with simulation, PCB design, IP reuse, and C-level design.
What are the main challenges when working with FPGAs?
Some common challenges with FPGA design include:
- Steep learning curve programming with HDLs like Verilog and VHDL
- Complex toolchains require expertise to optimize through the flow
- Timing closure and routing congestion as designs push capacity limits
- Power usage control and thermal management
- Debugging within hardware description languages
- Cost of tools and IP add to development overheads
- Staying current as architectures rapidly evolve
But continuous improvements in design tools, abstraction levels, and embedded debug capabilities are helping overcome these challenges.
FPGAs are integrated circuits whose logic and routing can be reconfigured after manufacturing. This provides hardware-level flexibility compared to fixed-function ASICs. FPGAs contain logic blocks, I/Os, and interconnects that can be programmed using HDL or schematic design entry.
Leading FPGA applications include aerospace/defense systems, 5G infrastructure, automotive electronics, IoT devices, and hardware acceleration for AI inferencing. Major vendors are Xilinx and Intel/Altera, but new entrants continue to push innovation in FPGAs for embedded, cloud computing, networking, and other uses.
Trends in FPGA evolution include heterogenous integration, raised abstraction levels, 3D packaging, and security. As FPGAs grow beyond basic programmable logic into adaptive computing platforms, they will play an increasingly important role in diverse electronic systems.
An Introduction to FPGA
FPGA stands for (Field Programmable Gate Array). As the name implies, the FPGA is an integrated circuit (IC) that is basically an array of logic gates and is programmed/configured by the end user in the field (wherever he is) as opposed to the designers.
What is FPGA made of..?
The basic logic gates are the core building blocks of the FPGA. It is not like the FPGA IC is full of these logic gates, but FPGA is based on digital sub-circuits carefully interconnected with each other to perform the desired function. It is like for example to make a shift register the AND gates and OR gates ICs are required, so there are two ways either to buy these individual ICs and interconnect them together to obtain the functionality of Shift register. The other way is to buy a shift register IC instead and make your design much more compact.
This is the case with FPGA assembly, the sub-circuits are already made of basic AND, OR and NOT gates and these sub-circuits are then interconnected very accurately to design the internal hardware blocks called Configurable Logic Block (CLB).The CLBs can also be defined as Look up Tables (LUT) that is programmed by Hardware Description Language (HDL) to achieve desired output.
These thousands of CLBs are then connected with IOBs to interface with external world circuitry. The IOB stands for “Input Output Blocks”. These IOBs are made of pull up, pull down resistors, buffer circuitry and inverter circuits.
Reprogram-ability of FPGA:
The biggest advantage of FGPA is its ability to be reprogrammed at the field. Its flexibility to be used as microprocessor, graphic card or image processor or all of them at the same time make it solid upper hand to basic micro-controllers or micro-processors.
These FPGAs are programed by HDL like VHDL or Verilog. Some additional features are being added nowadays in FPGAs like dedicated hard-silicon blocks for attaining functions of External Memory Controllers, RAM block, PLL, ADC and DSP block and many other components.
Difference between the Micro-controller and FPGA:
Today, many of the projects are based on micro-controllers. As our trend in developing student project, professional circuits, industrial products development is based on micro-controller based circuits, we did not got much familiarized with FPGAs.
The main difference between the micro-controller and FPGA is that, “A micro-controller is versatile IC and can be programmed in different ways to fit in various types of applications while the FPGA is a dedicated IC specifically designed to perform special functions according to the needs of a particular application”.
Another important difference is that “The FPGAs are hardware Configurable Logic Blocks (CLBs) based ICs that can be interconnected to external circuits through Hardware Description Language HDL codeby means of IOBs while micro-controllers are based on software/programming/coding where instructions are executed sequentially.”
The micro-controller / micro-processor has constraints of inability to execute multiple instructions simultaneously and also functionality you want to perform must have the availability in instructions sets of a particular controller/processor.
(The Block Diagram of 8051 Micro-controller)
FPGA vs ASIC:
The FPGAs are somewhat similar to ASIC “Application Specific Integrated Circuits” but not very much. The key difference in FPGA and ASIC is that CLBs in FPGA can be reconfigured to perform different task/operation/function but in the case of ASIC the dedicated ASIC chip will perform the same operation for the entire life time for which it was designed.
The analogy of FPGA and ASIC is that you build a house using LEGO parts, then you demolish it and built a car using same LEGO parts. These LEGO parts are same as CLBs of FPGA.
The analogy of ASIC is that you build the same house using concrete blocks and cement (not the LEGO) but now you cannot demolish it and build other thing from this. This work is permanent. Hence this is ASIC.
So the ASICs are dedicated ICs in which digital circuitry (logic gates and sequential circuits) is hardwired or permanently connected internally on silicon wafer.
FPGAs are suitable for low volume production and require much less time and money as compared toothier ASIC counterparts. FPGAs require less than a minute to reconfigure. Another important advantage is that FPGAs can be partially reconfigured and rest of FPGA portion is still working.
However, FPGAs on the other hand are slower and more power hungry due to their large area size due to dense routing programmable interconnection. This complex interconnection accounts for 90% of the total size of FPGA.
Detailed Insight of FPGA Structure:
The main constituents of FPGA are
- Configurable Logic Blocks (CLBs)
- Input Output Blocks (IOBs)
- Switch Box (SB)
- Connection Box (CB)
- Look Up Table (LUT)
- Horizontal and Vertical Routes
Configurable Logic Block (CLB):
A CLB is made up of the cluster of BLE (Basic Logic Element) through a dense interconnect scheme. A BLE has the multiplexer, SRAM and D Type Flip Flop. These three components forms the BLE and the cluster of BLEs form the CLB
Input Output Blocks (IOBs):
These are the blocks that make interconnection between the FPGA and outside circuitry. The IOBs are the end connection of the programmable routing network.
Switch Box (SB):
Switch Box is the collection of switches to connect different horizontal and vertical routes (tracks). Ability of a track to connect to multiple tracks is defined as the connectivity of SB.
Connection Box (CB):
Connection Box is the collection of switches to connect CLB to multiple routes. Ability of the CLB to connect to multiple routes/tracks is defined as the connectivity of CB
Look Up Table (LUT):
The lookup table is made of multiplexer and SRAM. A 4 input LUT requires (24) 16 SRAM bits to implement a 4 bit Boolean expression.
Horizontal and Vertical Routing Channels:
The horizontal and vertical lines/routes that creates the mesh network of FPGA
Flexibility of CB:
The flexibility of CB is defined as (FC). A FC = 1 means that all the adjacent routing channels are connected to the inputs of CLB
Flexibility of SB:
The flexibility of SB is defined as (FS). It is defined as the total number of tracks with which every track entering the SB connects to.
It is therefore concluded that FPGAs have advantages over other options like ASIC and microprocessor / micro-controller in the sense that FPGAs are handy and easily reconfigurable at the user end. It can be customized by a simple HDL code and are easily available in the market for reasonable rates between 50 to 100 USD.