How to Build ROS 2 Humble for an AMD ZCU102 with Yocto

iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more

ROS 2 Humble can be integrated into a Yocto/OpenEmbedded image for the AMD ZCU102 using the upstream meta-ros layers, but the available project and AMD documentation does not establish a prevalidated, end-to-end Humble image for a particular ZCU102 revision and AMD board-support release. Treat this as a stack you must pin, build, boot, and verify—not as a ready-made board image.

The simplest upstream starting point identified by meta-ros is Yocto Kirkstone with ROS 2 Humble. Separately, AMD’s current EDF board documentation lists ZCU102 machine targets. Those two facts do not prove that a particular AMD target and framework release work with that older Yocto/ROS pairing. The key is to select mutually compatible versions first, then validate the board boot path and ROS runtime on the actual kit.

#	Preview	Product	Price
1		AMD ZU15EG Development Board Zynq UltraScale+ ARM FPGA Platform with 4GB DDR4 PS 2GB DDR4 PL FMC HPC...	$1,348.00	Buy on Amazon

What you are building

The goal is an embedded Linux image built with Yocto/OpenEmbedded that contains ROS 2 Humble packages and runs ROS nodes on the ZCU102’s Linux application-processing side. meta-ros is the upstream integration route: its OpenEmbedded layers add ROS support to Yocto-based Linux distributions.

This is different from installing ROS on a desktop Linux distribution, and it is not the same as putting ROS directly on the programmable logic (PL) or the real-time processor cores. Yocto assembles the target operating-system image and package set; AMD’s board-support configuration supplies the board-specific machine, kernel, device-tree, and boot integration; meta-ros supplies ROS recipes and related integration. All three parts must fit the same build.

#1 Best Overall

AMD ZU15EG Development Board Zynq UltraScale+ ARM FPGA Platform with 4GB DDR4 PS 2GB DDR4 PL FMC HPC SFP HDMI SATA MIPI AI Video Processing Educational Kit (LCD Package)

• ARM plus FPGA Hybrid Architecture:Powered by AMD Xilinx Zynq UltraScale Plus XCZU15EG with ARM Cortex-A53 and FPGA logic, delivering powerful heterogeneous computing performance for embedded development.
• Large-Capacity DDR4 Memory:Equipped with 4GB DDR4 for ARM (PS) and 2GB DDR4 for FPGA (PL), ideal for high-speed data processing, real-time signal processing, and AI acceleration workloads.
• Rich High-Speed Interfaces:Includes FMC HPC, SFP, SATA, MIPI CSI, Mini DisplayPort, and 4K HDMI input and output. Perfect for image processing, video capture, and ultra-high bandwidth applications.
• Ideal for AI and Video Applications:Widely used in artificial intelligence, 4K video systems, edge computing, and deep learning inference. Supports DisplayPort interface for high-resolution display integration.
• Full Development Resources Included:Comes with schematics, Verilog HDL demos, and hands-on experiment guidelines. Supports fast prototyping for research, education, and product development.

$1,348.00

Buy on Amazon

Choose and pin the software stack before building

The meta-ros project identifies Kirkstone plus Humble as its easiest starting combination. Its repository also maintains a support table showing Humble against multiple Yocto releases and their lifecycle dates. Check that live table when selecting a branch: support statements and lifecycle windows can change, and a listed ROS/Yocto pairing is not proof that every recipe works for every board configuration.

AMD EDF documentation version 26.06.1 lists ZCU102 machine names, but that does not show that the corresponding AMD framework release is compatible with Kirkstone or has been tested with Humble. Do not combine a machine name found in newer AMD documentation with an older Yocto release by assumption. Match the AMD framework and board layer to the selected Yocto series, and verify the exact layer branches and dependencies before starting a long build.

Record these inputs

• Yocto series and source revisions: record the release branch and exact revisions of Poky and every layer, rather than relying on moving branch heads.
• AMD framework and board-support release: use the documentation and layers for that specific release, and confirm that they target the Yocto series you chose.
• Machine: select the machine configuration documented for the pinned AMD release. AMD’s EDF 26.06.1 page lists zynqmp-zcu102-sdt-full and zynqmp-zcu102-multidomain; their availability and meaning are framework-version dependent.
• ROS distro and layer branch: use the Humble layer branch that matches your Yocto series according to the meta-ros support table.
• Image and package selection: decide which ROS packages, middleware dependencies, networking tools, and application packages the target actually needs. No quantitative package-footprint figures are established in the cited sources.
• Hardware and boot details: record the board revision, boot medium and mode, image-generation procedure, and any custom device-tree or peripheral configuration.

Set up the AMD board base

Start from the AMD-supported Yocto framework and the board configuration for your chosen release, not from a generic ZynqMP image. The machine configuration determines board-specific integration; it is not interchangeable merely because two targets refer to the ZCU102. Consult AMD’s Evaluation Board Product Information for the documented machine targets and follow the instructions matching the framework release you actually use.

The physical target is the AMD Zynq UltraScale+ MPSoC ZCU102 Evaluation Kit. AMD’s ZCU102 Evaluation Board User Guide (UG1182), revision 1.7 dated 2023-02-21, documents the board and its platform. The kit is hardware, not a prebuilt Humble/Yocto solution. Use the applicable release documentation to generate and program boot artifacts; do not assume that a generic Yocto image file can be copied to an SD card and booted without the AMD-specific boot and image flow.

Add meta-ros and the ROS packages you need

Bring the meta-ros layers into the pinned Yocto build and select the ROS distro layer and recipes corresponding to Humble and your chosen Yocto series. The repository describes kas as an option for cloning repositories and starting a build; its build/kas README contains the project’s setup instructions. Use those instructions against the branch combination you have pinned, and include the AMD layers required by the matching framework.

Then add the required ROS packages to your image configuration through the recipes or package groups available in that branch. Keep the target set deliberate: a headless robot controller, for example, may not need desktop-oriented packages. Resolve target dependencies in the Yocto build rather than assuming that a package available on desktop Ubuntu is available in the selected layers. The correct package names and dependency closure depend on the layer branch and image design, so verify them in the checked-out metadata rather than copying a package list from another distribution or board.

Before building, check that the active configuration resolves to the intended MACHINE, that the layer branches align with the selected Yocto series, and that the image includes the ROS packages you chose. Preserve the build configuration and source revisions so that another engineer can reproduce what you tested.

Build, boot, and validate in stages

1. Build the AMD board image first. Confirm that the unmodified board-support image builds for the selected machine. This isolates AMD layer, kernel, device-tree, and boot integration from ROS-related issues.
2. Add meta-ros and build again. Resolve recipe and dependency errors at the Yocto layer level. Keep the exact error logs and configuration used; a successful parse or build for a different machine is not evidence for this target.
3. Generate boot media using the matching AMD procedure. Follow the framework’s documented image and boot-artifact instructions for the ZCU102 and selected boot mode. Check the board guide for hardware setup and switches, rather than guessing from a different ZynqMP board.
4. Confirm Linux boot and basic hardware access. Verify that the target reaches a shell, recognizes the expected interfaces, and has the network and peripherals needed by your application before diagnosing ROS.
5. Check the ROS installation on target. Confirm that the intended Humble packages are present and that a minimal node can run. Test the actual middleware and network configuration required for communication between target and host.
6. Exercise the application under its real conditions. Validate device drivers, message flow, startup behavior, and timing with the intended workload. Record the board revision, image identity, runtime configuration, and test results; no performance, build-time, memory, or package-size measurements are established by the cited documentation.

For a reproducible report, include the AMD framework release, Yocto series, all layer revisions, MACHINE, image name, ROS distro branch and package selection, build host, board revision, boot medium and procedure, and the runtime checks performed. Without those details, “Humble on ZCU102 with Yocto” is too broad to establish what combination was actually built.

Know which ZCU102 processors run which work

The ZCU102 uses a Zynq UltraScale+ MPSoC platform. AMD’s board and platform documentation describes Cortex-A53 application processing, Cortex-R5 real-time processing, and programmable logic. A conventional Yocto Linux image with ROS nodes runs those nodes on the Linux application-processor side—normally the Cortex-A53 environment.

The real-time cores and PL are not automatically part of that Linux-hosted ROS execution model. Work requiring hard real-time behavior may need a separate real-time design and an explicitly engineered communication path to Linux. PL acceleration likewise requires hardware design, integration, drivers or interfaces, and application software. The cited board sources describe platform capabilities, not latency or performance for any particular ROS workload.

Troubleshoot by layer

• BitBake parse or recipe failures: check layer compatibility, branch selection, missing dependencies, and whether the requested recipe exists for the pinned series.
• C++ or middleware build errors: isolate the failing recipe and inspect its target dependencies and build configuration before changing unrelated board settings.
• Image boots incorrectly or not at all: return to the AMD release-specific boot and image procedure; verify machine selection, boot artifacts, media preparation, and board setup.
• ROS nodes run but do not discover peers: inspect network reachability and the DDS/middleware configuration on both endpoints, including interface selection and any network filtering.
• Peripheral access fails: check whether the kernel, device tree, drivers, and permissions in the image support the device on the selected board configuration.
• Timing or application behavior is inadequate: measure the workload on the actual target and determine whether Linux scheduling is sufficient or whether real-time cores or PL engineering are required.

These are diagnostic categories, not claims of known ZCU102-specific defects. The cited sources do not document a complete reproducible Humble-plus-AMD-Yocto image with validated boot and runtime behavior.

What the available documentation establishes

The meta-ros project establishes an upstream ROS-to-Yocto route and identifies Kirkstone with Humble as an easy starting point; AMD’s EDF board documentation lists ZCU102 machine targets; and AMD’s UG1182 board guide documents the hardware. AMD also lists ZCU102 as an evaluation kit for developers in its UG1137 Boards and Kits documentation, version 2025.1 dated 2025-06-25.

Together, those sources support a practical integration approach, not a guarantee that a specific combination builds or boots. End-to-end compatibility remains unestablished until the exact layer revisions, AMD machine configuration, image, and board revision are built and validated together.

Quick Recap

Bestseller No. 1

AMD ZU15EG Development Board Zynq UltraScale+ ARM FPGA Platform with 4GB DDR4 PS 2GB DDR4 PL FMC HPC SFP HDMI SATA MIPI AI Video Processing Educational Kit (LCD Package)

$1,348.00

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.