Meet the ZYBO
So… you’ve got a ZYBO. At first glance, it looks like a normal dev board. Some LEDs, some ports, a chip in the middle — nothing too crazy.
Then you realize that chip is the Zynq-7000, which is basically a dual-core ARM Cortex-A9 sitting right next to a full FPGA, and now things start to feel a little different.
To understand why this matters, it helps to compare it to what you’ve probably used before.
Microcontrollers
With a microcontroller (like the MSP430, STM32, etc.), the flow is simple:
Write C → compile → flash → run
All the hardware is fixed. You don’t change it — you just use what’s there.
FPGAs
With a traditional FPGA, the flow flips:
Write VHDL/Verilog → synthesize → implement → program
Now you are the hardware designer. There is no CPU unless you build one, and nothing happens until you define it.
Zynq (ZYBO)
The ZYBO sits right in the middle — and that’s where things get interesting. You get:
A real processor (ARM Cortex-A9) that can run C or Linux
A real FPGA where you can build custom hardware
And the workflow becomes:
Define hardware (Vivado) → run software (Linux or C) → make them talk
You’re no longer just writing software or just designing hardware - you're building a system.
This is what makes the ZYBO powerful — and also why it can feel a bit overwhelming at first. In this series, we’re going to break that complexity down and turn this board into a fully functional embedded system, starting with Linux and then working our way into custom hardware and real projects.
And no — we’re not starting with blinking an LED.
Project Scope
The goal here is simple:
Turn the ZYBO into a fully functional embedded Linux system, and then start bending it to our will.
We’re going to:
Set up the hardware platform in Vivado
Boot PetaLinux on the board
Get access to UART, Ethernet, USB, and other peripherals
Set up Vitis for developing software on the ARM core
This gives us a complete workflow:
Hardware (Vivado) → System (PetaLinux) → Software (Vitis)
Once that foundation is in place, we’ll start doing things that actually justify using a Zynq device:
Interact with hardware directly from Linux
Write software that controls memory-mapped peripherals
Build drivers and interfaces
Eventually push into things like HDMI and SDR integration
This isn’t a one-off tutorial — this is the starting point for everything that comes after.
Tools (Equipment and Software)
This is the equipment and/or parts list you will need to complete this series of tutorials:
ZYBO Z7 board (Z7-10 or Z7-20)
SD card (for booting Linux)
A computer that can run Xilinx tools without catching fire
Software
Vivado — hardware design
Vitis — software development (bare-metal, later on)
PetaLinux tools — building the Linux system
Serial terminal (PuTTY, TeraTerm, etc.)
Implementation (The How)
We’re going to break this into a few focused steps. Each one has its own walkthrough so this page doesn’t turn into a novel. Just click on the links below.
Understanding the ZYBO Architecture
PS vs PL, what lives where, and why it matters.
Development Workflow
What Vivado and Vitis actually do, and how they fit together.
Vivado Hardware Setup
Build the base hardware platform (PS configuration, peripherals, etc.).
PetaLinux Setup
Take the hardware and turn it into a bootable Linux system.
Vitis Setup
Set up the environment for writing and deploying software to the ARM cores.
First Boot & Validation
Boot Linux, connect over UART/SSH, and make sure everything actually works.
Outcome (Did it work)
If everything worked, you should now have:
A ZYBO that boots into Linux from an SD card
UART console access
Ethernet connectivity (SSH into the board)
USB support
A stable platform you can build on
More importantly, you now have a system where software and hardware can actually work together.
At this point, we’ve barely touched the FPGA — and that’s about to change. Next up, we’ll start interacting with hardware from Linux and then move into building our own custom logic in the PL. And eventually… we’ll make this thing push pixels over HDMI.
