Understanding the ZYBO Architecture
Before we start building Linux systems and FPGA designs, it's worth spending a few minutes understanding what is actually on the ZYBO board.
The ZYBO is built around a Xilinx Zynq-7000 device. What makes the Zynq family interesting is that it combines two very different technologies into a single chip:
A dual-core ARM processor system
An FPGA fabric
Think of it as a Linux computer and an FPGA living inside the same package.
The Processing System (PS)
The Processing System, usually abbreviated PS, contains the ARM processors and the hardware needed to run an operating system.
Some of the major components include:
Dual-core ARM Cortex-A9 processors
DDR memory controller
Ethernet controller
USB controller
SD card interface
UART interfaces
Timers and interrupt controllers
When we boot PetaLinux, the operating system runs entirely on the ARM processors inside the PS.
You can think of the PS as a small embedded computer. It can run C programs, Python scripts, network services, web servers, and everything else you would normally expect from a Linux system.
For many projects, the PS alone is enough.
The Programmable Logic (PL)
The Programmable Logic, usually abbreviated PL, is the FPGA portion of the device.
This is where we create custom hardware using VHDL or Verilog.
Examples include:
Signal generators
Digital filters
High-speed data acquisition systems
PWM generators
Communication interfaces
Custom peripherals
Unlike software running on a CPU, hardware in the PL operates in parallel. Multiple blocks can execute simultaneously on every clock cycle.
This makes the FPGA extremely powerful for tasks that require deterministic timing or high-speed data processing.
Why Put Both Together?......
Traditionally, an embedded system might require:
A microprocessor running software
An FPGA for custom hardware
This allows the ARM processors and FPGA fabric to work together very closely.
For example:
Linux can configure FPGA registers.
FPGA hardware can generate interrupts to Linux.
Linux applications can send data to FPGA hardware.
FPGA hardware can accelerate computationally intensive tasks.
This combination is one of the main reasons the Zynq family is so popular in embedded systems.
How the PS and PL Communicate
The PS and PL are connected internally through high-speed AXI buses.
AXI (Advanced eXtensible Interface) is simply a standardized communication protocol used throughout Xilinx designs.
When we create custom hardware in Vivado, we often expose configuration registers through an AXI interface.
Linux can then access those registers just like memory locations.
For example:
Linux writes a frequency value to a register.
The FPGA signal generator receives the value.
The FPGA begins generating the requested waveform.
From the software perspective, controlling FPGA hardware can be as simple as writing to memory.
The Development Workflow
When working with a ZYBO project, the tools generally have the following responsibilities:
Vivado
Vivado is used to design the hardware system.
Examples:
Configure the Zynq Processing System
Add FPGA peripherals
Connect AXI interfaces
Generate the FPGA bitstream
PetaLinux
PetaLinux takes the hardware definition produced by Vivado and creates a bootable Linux system.
Examples:
Linux kernel
Device tree
Root filesystem
Boot images
Vitis
Vitis is used to develop software that runs on the ARM processors.
Examples:
Bare-metal applications
Linux applications
Driver development
What We Will Build
Throughout this tutorial series, we will use Linux running on the ARM processors to control custom hardware implemented in the FPGA fabric.
The ARM processors will provide the flexibility of a full operating system, while the FPGA will provide custom hardware acceleration and deterministic timing.
Understanding this PS/PL relationship is the key concept behind every Zynq project. Once it clicks, the rest of the development flow becomes much easier to understand.
