Open Source Robotics

A curated collection of high-quality open source robotics projects, tools, and software to propel the robotics community forward.

FPGA

  • Also called: field-programmable gate array
  • Category: Control › Feedback control
  • Tags: embedded-hardware, hardware-acceleration, edge-computing, real-time, neural-network-inference

A field-programmable gate array: a chip of configurable logic, memory and routing that is wired into a custom digital circuit by loading a configuration, instead of running a program.

Definition

An FPGA, or field-programmable gate array, is an integrated circuit whose logic is defined after manufacture. It contains a large array of small configurable logic blocks, built from lookup tables and flip-flops, connected by programmable routing, together with dedicated blocks such as on-chip RAM, multiply-accumulate (DSP) units, clock managers and high-speed I/O. A configuration file, the bitstream, sets every lookup table and routing switch so that the chip behaves as a specific digital circuit. In most devices the configuration is held in volatile memory and reloaded from flash at power-up.

Designs are written in hardware description languages such as Verilog or VHDL, or in C or C++ through high-level synthesis, and are then synthesized, placed and routed by vendor tools, a process that can take from minutes to hours. Unlike a CPU or GPU executing instructions, an FPGA implements the computation itself as hardware: many operations run in parallel every clock cycle, data streams through pipelines, and timing is fixed to the clock cycle. Clock rates are lower than CPUs, and on-chip memory is small, so large models or data must stream from external memory, which limits throughput. SoC FPGAs, such as the Xilinx Zynq family, combine the programmable fabric with ARM processor cores on one chip, so Linux and ROS can run beside custom hardware.

These properties make FPGAs strong where latency must be low and predictable, where many simple operations run in parallel, or where data has unusual widths. In robotics they generate PWM and run current loops for motor drives, decode encoders, read and preprocess camera, lidar and event-camera streams, compute stereo disparity, and run neural networks quantized to low precision. Binarized neural networks fit especially well, because their multiply-accumulate operations reduce to XNOR and bit-count logic that maps directly onto lookup tables.

Why it matters

Robots need fast, deterministic processing close to sensors and actuators, often within a tight power budget. FPGAs fill the gap between microcontrollers, which may be too slow, GPUs, which use more power and have less predictable latency, and custom chips (ASICs), which are too costly to make in small volumes.

Key applications

  • Motor drives: PWM generation, current loops and encoder decoding
  • Low-latency preprocessing of camera, lidar and event-camera data
  • Stereo depth and feature extraction for visual odometry on small robots
  • Quantized and binarized neural network inference on embedded robots
  • Real-time I/O for CNC machines and industrial motion control
  • Radiation-tolerant processing for space robotics

In practice

A humanoid's hand-eye pipeline runs on an SoC FPGA board. The ARM cores run Linux and ROS nodes for high-level control, while the fabric holds a pipeline that receives camera frames directly, resizes them and feeds a partially binarized autoencoder whose weights fit in on-chip RAM. The engineers quantize the network in software first, check that accuracy holds, then generate the hardware with a high-level synthesis tool and verify timing. The latent features reach the controller with a fixed delay every frame, at a fraction of the power a GPU would draw, but each change to the network means another synthesis run.

Common misconceptions

  • An FPGA runs your program like a fast processor — it is configured into a circuit; software runs on it only through processor cores, hard or built from the fabric
  • FPGAs are always faster than GPUs — GPUs usually win on large floating-point workloads, while FPGAs win on latency, determinism and low-precision streaming
  • Changing an FPGA design is like recompiling software — synthesis and place-and-route are slow, and designs must meet timing
  • On-chip memory is plentiful — it is small, so large networks need external memory or aggressive quantization

Who should know this

  • Embedded and electronics engineers designing robot controllers
  • Perception engineers moving pipelines onto low-power hardware
  • Researchers deploying quantized neural networks on robots
  • Motor-drive and motion-control designers

Related technologies

  • Verilog and VHDL
  • High-level synthesis (HLS)
  • SoC FPGAs such as Xilinx Zynq
  • FINN binarized neural network framework
  • GPU
  • ASIC

Related terms

  • BLDC Motor
  • Encoder
  • PID Controller
  • Event Camera
  • Visual Odometry

Related projects

  • GENESIS: World's fastest physics engine: 43M FPS for embodied AI learning
  • Cartographer: Google's real-time 2D and 3D SLAM system for multi-platform robotics
  • FAST-LIVO2: Fast, direct LiDAR-inertial-visual odometry from HKU-MARS, published in IEEE T-RO
  • Dora AI: Dataflow middleware for AI robotics applications, built in Rust
  • OpenMind OM1: AI-native operating system for robots with modular perception, cognition, and action
  • Fast DDS: eProsima's high-performance DDS middleware — the default transport under ROS 2

Videos

  • EEVblog #496 - What Is An FPGA?: EEVblog
  • Introduction to FPGA Part 1 - What is an FPGA? | Digi-Key Electronics: DigiKey

This website requires JavaScript to function properly. Please enable JavaScript to explore our collection of open source robotics projects.