Skip to content
Projects

fpgadeveloper/rpi-camera-fmc has 31 GitHub stars and 8 forks. GitHot measured 0 stars in 24 hours. Last checked 2026-11-16 03:55 UTC. Last push 2026-10-26.

How these counts are measured

Measured star growth

in 24h
0
in 7 days
Collecting history
in 15 days
Collecting history
in 1 month
Collecting history

Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.

About

Example designs and documentation for the RPi Camera FMC

Creative & Media

README.md

Original

Reference design for RPi Camera FMC

Description

This project demonstrates the Opsero RPi Camera FMC (OP068) used to connect up to 4x Raspberry Pi cameras (or compatible cameras) to one of the target FPGA/MPSoC boards listed below. The designs contain:

  • Up to 4x MIPI CSI-2 capture pipelines
  • Video Mixer IP based display pipeline to DisplayPort/HDMI output (DVI over HDMI on Versal)
  • Video Codec Unit (VCU) on the boards whose device has one

RPi Camera FMC

Important links:

Architectures

The designs in this repository fall into three main architectural categories:

  1. Zynq UltraScale+ designs – These designs integrate the ISP Pipeline IP, run embedded Linux built with PetaLinux or Yocto (AMD EDF), and output video to a DisplayPort monitor.
  2. Versal designs (VCK190, VEK280) – The same capture pipelines and Linux software as the Zynq UltraScale+ designs, built with Yocto (AMD EDF), with a DVI output (1080p60) on the board's HDMI TX connector made from free IP and an open-source TMDS encoder (no HDMI IP license needed).
  3. FPGA designs – These designs implement a simpler video pipeline, are controlled by a bare-metal application, and output video to an HDMI monitor.

Zynq UltraScale+ designs

The high level block diagram below illustrates the design: RPi Camera FMC example design

The video pipe sub-blocks are illustrated below: RPi Camera FMC video pipe

Versal designs

Display pipeline of the Versal designs: RPi Camera FMC Versal DVI display pipeline

FPGA designs

Display pipeline of the FPGA designs: RPi Camera FMC HDMI display pipeline

The video pipeline of the FPGA designs: RPi Camera FMC simple video pipe

Requirements

This project is designed for version 2025.2 of the Xilinx tools (Vivado/Vitis/PetaLinux/Yocto EDF). If you are using an older version of the Xilinx tools, then refer to the release tags to find the version of this repository that matches your version of the tools.

In order to test this design on hardware, you will need the following:

Design specific requirements

  • Zynq UltraScale+ designs:

    • PetaLinux Tools 2025.2 (PetaLinux flow), or Google's repo tool and the Yocto host packages (Yocto flow)
    • 1x DisplayPort monitor that supports 1920x1080 at 60 Hz
    • Linux build PC (or virtual machine)
  • Versal designs:

    • Google's repo tool and the Yocto host packages (Yocto flow), on a native Linux build PC
    • 1x HDMI monitor that supports 1920x1080 at 60 Hz (on the board's HDMI TX connector)
    • A microSD card of 16 GB or more
  • FPGA designs:

Target designs

FPGA designs

Target board Target design FMC Slot Cameras VCU Baremetal
App
PetaLinux
Build
Yocto
Build
Vivado
Edition
IP
License
AUBoard 15P auboard HPC 2 :x: :white_check_mark: :x: :x: Standard :free: -

Zynq UltraScale+ designs

Target board Target design FMC Slot Cameras VCU Baremetal
App
PetaLinux
Build
Yocto
Build
Vivado
Edition
IP
License
ZCU104 zcu104 LPC 4 :white_check_mark: :x: :white_check_mark: :white_check_mark: Standard :free: -
ZCU102 zcu102_hpc0 HPC0 4 :x: :x: :white_check_mark: :white_check_mark: Enterprise -
ZCU102 zcu102_hpc1 HPC1 2 :x: :x: :white_check_mark: :white_check_mark: Enterprise -
ZCU106 zcu106_hpc0 HPC0 4 :white_check_mark: :x: :white_check_mark: :white_check_mark: Standard :free: -
PYNQ-ZU pynqzu LPC 2 :x: :x: :white_check_mark: :white_check_mark: Standard :free: -
UltraZed-EV Carrier uzev HPC 4 :white_check_mark: :x: :white_check_mark: :white_check_mark: Standard :free: -

Versal designs

Target board Target design FMC Slot Cameras VCU Baremetal
App
PetaLinux
Build
Yocto
Build
Vivado
Edition
IP
License
VCK190 vck190_fmcp1 FMCP1 2 :x: :white_check_mark: :x: :white_check_mark: Enterprise -
VCK190 vck190_fmcp2 FMCP2 3 :x: :white_check_mark: :x: :white_check_mark: Enterprise -
VEK280 vek280 FMCP 3 :x: :white_check_mark: :x: :white_check_mark: Enterprise -

Notes:

  1. The Vivado Edition column indicates which designs are supported by the Vivado Standard Edition, the FREE edition which can be used without a license. Vivado Enterprise Edition requires a license however a 30-day evaluation license is available from the AMD Xilinx Licensing site.
  2. The HPC1 connector of the ZCU102 board can only support 2 cameras due to it's pin assignment. This design supports the CAM0 and CAM1 slots as labelled on the RPi Camera FMC.
  3. The pynqzu target design has video pipelines for only 2 cameras: CAM1 and CAM2 as labelled on the RPi Camera FMC. This is due to the resource limitations of the devices on this board.
  4. The auboard target design has video pipelines for only 2 cameras: CAM0 and CAM2 as labelled on the RPi Camera FMC. This is due to the resource limitations of the Artix UltraScale+ device on this board.
  5. The Versal designs support 2 or 3 cameras per FMC slot (vck190_fmcp1: CAM0, CAM2; vck190_fmcp2: CAM1, CAM2, CAM3; vek280: CAM0, CAM1, CAM3) due to the Versal XPIO (XPHY) clocking rules for the MIPI D-PHY. On the VCK190, U-Boot sets the FMC VADJ to 1.2V. The VEK280 has a fixed 1.5V VADJ: like AMD's own VEK280 board file, the design uses the 1.2V MIPI_DPHY / LVCMOS12 I/O standards on these banks, outside AMD's specified 1.2V VCCO for MIPI_DPHY (the RPi Camera FMC tolerates up to 1.8V). The vck190_fmcp1 design has been tested on hardware; vck190_fmcp2 and vek280 have not yet been tested on hardware by Opsero. See the Versal designs page of the user guide.

Software

Baremetal application

Some of these designs can be driven by a baremetal application that will configure the connected cameras and combine their video outputs into a single 1080p stream.

Embedded Linux (PetaLinux and Yocto)

The Zynq UltraScale+ based reference designs can be driven within an embedded Linux environment, built either with PetaLinux or with Yocto (AMD Embedded Development Framework). The Versal designs are built with Yocto only. The repository includes all necessary scripts and code to build both. The two images contain the same camera and display drivers and the same example scripts. The table below outlines the corresponding applications available:

Environment Available Applications
PetaLinux Built-in Linux commands, init_cams.sh, displaycams.sh
Additional tools: v4l-utils, modetest, GStreamer
Yocto (AMD EDF) Built-in Linux commands, init_cams.sh, displaycams.sh
Additional tools: v4l-utils, modetest, GStreamer, SSH server

Build instructions

Clone the repo and change into its directory:

git clone --recursive https://github.com/fpgadeveloper/rpi-camera-fmc.git
cd rpi-camera-fmc

Cross-platform build runner

All builds are driven by build.py at the repo root, on both Windows (git bash) and Linux. The build.sh / build.bat shim finds a suitable Python 3 automatically (including the one bundled with the AMD tools). Pick a target design label from the tables above (or run ./build.sh list), then run the build command for the stage(s) you want — each command builds whatever it depends on automatically and skips anything already built. On Windows without git bash, run the same commands from Command Prompt or PowerShell using build.bat (e.g. build.bat xsa --target <target>).

You don't need to source the AMD tools first — the build runner finds Vivado, Vitis and PetaLinux automatically in their standard install locations and sets up the environment each stage needs. If your tools are installed somewhere non-standard and the runner can't find them, source the tool settings yourself before running the build.

Build the Vivado project (bitstream + XSA)

./build.sh xsa --target <target>

Build the standalone application

Builds the Vitis workspace and the baremetal boot file (BOOT.BIN or bit file, depending on the device family):

./build.sh standalone --target <target>

Build PetaLinux (Linux only)

./build.sh petalinux --target <target>

Build Yocto (Linux only)

Builds the Yocto / AMD EDF image, a complete SD card image (rootfs.wic.xz) plus the BOOT.BIN that goes on the card's first partition:

./build.sh yocto --target <target>

Build everything

Builds all of the above that the target supports, then gathers the boot images into bootimages/*.zip:

./build.sh all --target <target>
./build.sh all --target all          # every target in the repo

Also available: status, clean, project — see ./build.sh --help. On Windows, the PetaLinux and Yocto stages require a Linux machine; the runner says so and prints the hand-off command. The legacy make interface still works on Linux (each Makefile now wraps build.sh) but is deprecated and will be removed at the next version update.

Launch instructions

FPGA designs

Launch Vitis, open the workspace that was generated using the make command. Select the test application and run it on the target board.

Zynq UltraScale+ and Versal designs

Log in on the console (PetaLinux: user petalinux; Yocto: user amd-edf; both ask you to set a password at the first login), then run the following command to stream video from all connected cameras to the 4 quadrants of the 1080p monitor (DisplayPort on Zynq UltraScale+, HDMI TX on Versal):

sudo displaycams.sh

If less than 4 cameras are physically connected, the unused quadrants of the monitor will be blue. On the Versal boards, the SD card needs BOOTAA64.EFI in EFI/BOOT/ of the first partition as well as BOOT.BIN (both are in the boot image zip), and the monitor goes on the HDMI TX connector (the top port of the stacked HDMI connector on the VCK190); the dvi-status command checks the DVI output. The user guide describes how to configure the cameras with init_cams.sh, capture frames with v4l2-ctl, and adjust the ISP settings.

Contribute

We strongly encourage community contribution to these projects. Please make a pull request if you would like to share your work:

  • if you've spotted and fixed any issues
  • if you've added designs for other target platforms
  • if you've added software support for other cameras

Thank you to everyone who supports us!

The TODO list

  • Develop PYNQ support
  • Add a standalone application for the Zynq and ZynqMP designs
  • Add VCU example scripts
  • Get a Genesys-ZU board and test the design on hardware.
  • Software support for more cameras (this will be an ongoing task due to the number of cameras available).

About us

Opsero Inc. is a team of FPGA developers delivering FPGA products and design services to start-ups and tech companies. Follow our blog, FPGA Developer, for news, tutorials and updates on the awesome projects we work on.