FPGA Programming

What Is FPGA Programming?

A field-programmable gate array (FPGA) is an electronic device that includes digital logic circuitry you can program to customize its functionality. Because the logic in the FPGA is programmed specifically to perform your application, it can execute this functionality faster and with less power consumption than software instructions running on a general-purpose application processor. An FPGA that also includes a processor on the device is called a system-on-chip, or SoC FPGA.

How Do You Program an FPGA?

If you are starting from an algorithm in MATLAB^® or Simulink^®, you will first need to partition the design from the stimulus and analysis, defining the inputs and outputs of the hardware partition.

Partitioning the elements of your test bench from the algorithm intended for hardware targeting.

The major steps in FPGA programming are:

Hardware architecture design. In the case of an SoC FPGA, the hardware-software SoC architecture.
Design. This is the process of creating the hardware logic itself, typically by writing register-transfer logic (RTL) using a hardware description language (HDL) such as VHDL^® or Verilog^®. The goal is to match the functionality of the algorithm while operating on a continuous stream of data, using fixed-point operations for efficiency.
Verification. This step ensures that the design works as intended before FPGA programming. This can be as simple as a VHDL testbench or Verilog testbench; commercial projects typically use a methodology such as the Universal Verification Methodology (UVM).
Synthesis. This technology transforms the RTL to digital logic gates and attempts to meet your register-to-register clock frequency goals while minimizing use of the resources on the FPGA.
Integration. An FPGA contains a lot of dedicated resources already—the pins, the clock signal, input/output processing such as analog-to-digital converters (ADC), and interfaces to off-chip memory and other devices on the board. An SoC FPGA also has dedicated registers that both the hardware and software can use to communicate with each other. Your design will need to plug into this “reference design.”
Implementation. This is the process of determining which physical resources on the FPGA to program with which logic, and how to connect (route) them. This produces the bitstream that is loaded onto the device for FPGA programming.
Lab testing and debug. After FPGA programming, you can run using real input or test input. The first few tries often involve figuring out why it does not work and how to fix it. Most of the time this is due to problems in the design step that were not identified in the verification step.

A typical workflow from algorithm design to FPGA programming.

FPGA Programming with MATLAB and Simulink

If you model your algorithms in MATLAB and Simulink, you can focus on designing the algorithm and hardware architecture. The major steps for FPGA programming with MATLAB and Simulink are:

Adding hardware architecture. You will need to adapt your algorithms to add hardware architecture to process a continuous stream of data, typically with fixed-point data types. Simulink offers a time-based visual environment for hardware architecture design. A best practice is to simulate this version of your design and compare the results with your golden algorithm results.
Code generation. Once you have a hardware-ready design, HDL Coder™ generates target-independent Verilog or VHDL RTL with links back to the model for debugging and traceability for functional safety workflows such as DO-254 and ISO 26262.
Integration. You will still need a reference design for HDL Coder to plug your algorithm into for FPGA programming. Many are available as Hardware Support Packages, or from your FPGA board vendor.
Synthesis and implementation. HDL Coder can generate scripts and projects for RTL synthesis, and it has integrated with synthesis and implementation tools from AMD, Altera, and Microsemi to provide automated FPGA programming workflows.

Refining your algorithm with hardware detail, then generating synthesizable RTL to target an FPGA development kit or a custom board.

Verification. The simplest way to verify that your RTL functions the same as your algorithm is to use HDL Verifier™ to cosimulate the RTL running in Mentor Graphics^® Questa^® or Cadence^® Xcelium™ together with your design and testbench in MATLAB and Simulink. Be sure to test as many scenarios and corner cases as you can before FPGA programming because debugging on the FPGA provides far less visibility and requires longer iterations. You can use Simulink Test™ to programmatically run and manage your test cases, and Simulink Coverage™ to measure how well you have verified your design.
Lab testing and debug. HDL Verifier enables you to insert logic to drive data into the FPGA from MATLAB as an AXI Master, and to insert logic to capture data from signals internal to the FPGA for debug. You can use MATLAB and Simulink to debug your FPGA directly, whether you are using them for your FPGA programming workflow or not.

Cosimulating your MATLAB and Simulink together with your implemented design running in a supported simulator or on an FPGA board.

Examples and How To

Running an Audio Filter on Live Audio Input Using a Zynq Board - Example
Getting Started with Targeting Altera SoC Devices - Example
Verify HDL Implementation of PID Controller Using FPGA-in-the-Loop - Example

Videos

Fixed-Point Made Easy for FPGA Programming (30:45) - Video
Targeting Algorithms to Microchip FPGAs using MATLAB and Simulink (20:05) - Video
Getting Started with the Avnet ZUBoard (4 videos) - Video Series
From Algorithms to FPGA / ASIC Implementation with MATLAB and Simulink (57:05) - Video
Hardware Architecture Design (8:13) - Video
DO-254 (8:25) - Video
ISO 26262 (3:06) - Video

News and Articles

Converting MATLAB Algorithms into Serialized Designs for HDL Code Generation - Article
You Don't Always Need to Convert to Fixed Point for FPGA or ASIC Deployment - Article
Enabling Model-Based Design for DO-254 Certification Compliance - White Paper

FPGA Programming FAQs

FPGA programming is the process of customizing the digital logic circuitry in a field-programmable gate array to perform specific applications.

The major steps include hardware architecture design, design (writing RTL using an HDL), verification, synthesis, integration with reference designs, implementation to generate a bitstream, and lab testing and debug.

An HDL is a language such as VHDL, Verilog, or SystemVerilog that is used to describe the behavior of digital circuitry. The register-transfer logic (RTL) layer of HDLs can be used as an input to logic synthesis tools that automate the generation of netlists.

MATLAB and Simulink allow you to focus on algorithm and hardware architecture design, then use HDL Coder to automatically generate synthesizable Verilog, VHDL, or SystemVerilog RTL code, eliminating the need to manually write HDL.

Verification ensures your design works as intended before programming the FPGA, using testbenches or methodologies like UVM to catch design problems early.

Synthesis transforms RTL code into digital logic netlists while attempting to meet clock frequency goals and minimize resource usage on the FPGA.

After loading the bitstream onto the device, you run tests using real or test input, and HDL Coder enables you to drive data from MATLAB and capture internal FPGA signals for debugging.

An SoC FPGA is a field-programmable gate array that also includes a hardened processor on the device, creating a system-on-chip with both programmable logic and software capabilities.

See also: HDL Coder, HDL Verifier

Try for Free

Get MATLAB, Simulink, and more.

Start now