In brief
As of July 2026, an Adafruit-highlighted maker project is using a Raspberry Pi RP2350 microcontroller to observe a running Zilog Z80 CPU in real time — sampling the address, data, and control lines of a 40-year-old 8-bit chip cycle-by-cycle and rendering the bus activity on a small display. The build treats the RP2350 as a purpose-built logic analyzer, sampling every M1 fetch, memory read, and I/O request the Z80 makes at a few MHz, then decoding what instruction is executing. It works because the RP2350's twelve Programmable I/O (PIO) state machines run independent of its Cortex-M33 and Hazard3 cores at up to 150 MHz, so you can hard-code a Z80 bus decoder in PIO assembly and let the ARM cores handle the display and USB. The cost of entry is under $10 for the microcontroller and a handful of pin headers, which is what makes this the sort of thing a hobbyist tries on a weekend instead of a $400 saleae capture. If you want a more general-purpose maker on-ramp before you buy a bare RP2350, the Raspberry Pi 4 8GB and the Raspberry Pi Zero W starter kit are the two boards we stock that pair best with vintage-hardware projects like this one.
What happened: the project and what the RP2350 does
The project sits at the intersection of retro-computing and modern silicon: a Z80 CPU on a breadboard, its bus lines wired directly to the GPIOs of an RP2350 running custom PIO firmware. As the Z80 executes each instruction, the RP2350 captures the address bus, the data bus, and the six control signals (M1, MREQ, IORQ, RD, WR, RFSH) then reconstructs, live, what the Z80 is doing — which opcode it fetched, which memory cell it read, which I/O port it touched. On the display you see a running trace of the Z80's brain in motion.
The Raspberry Pi RP2350 is the Pi Foundation's second-generation microcontroller, launched in August 2024 as the successor to the RP2040. It carries two 32-bit Arm Cortex-M33 cores clocked at up to 150 MHz, alongside two 32-bit Hazard3 RISC-V cores that can be swapped in as an alternate CPU pair — you choose Arm or RISC-V at boot. Compared to the RP2040 that shipped in the original Pi Pico, the RP2350 doubles SRAM to 520 KB, adds hardware floating-point on Cortex-M33, tightens power draw, and — critically for this Z80 project — expands the PIO subsystem from eight to twelve state machines across three PIO blocks.
The PIO is what makes the RP2350 an unusually good fit for observing 8-bit CPUs. Each PIO state machine is a tiny, deterministic bit-shift engine with its own program memory, capable of sampling or driving GPIOs on every clock cycle without CPU intervention. You write PIO code in a small assembly-like language, load it into the block, and it runs forever at up to the full 150 MHz system clock. For a 4 MHz Z80, that gives you roughly 37 samples per Z80 clock — plenty of headroom to detect edges, latch the address and data buses at the correct moment in each machine cycle, and time-stamp each transaction. Twelve state machines is enough to give one to the address bus, one to the data bus, one to control-signal decoding, and still have spares for a UART or display driver.
How the Z80 bus actually works
To appreciate why PIO on the RP2350 is a game-changer here, it helps to walk the Z80's bus protocol, which is different from a modern CPU's. The Z80 has a 16-bit address bus (A0-A15), an 8-bit data bus (D0-D7), and a small set of active-low control signals. Every instruction begins with an M1 cycle — the opcode fetch — during which M1 goes low, MREQ (memory request) goes low, and RD goes low; the Z80 puts the program counter onto the address bus and reads the opcode byte off the data bus. Subsequent machine cycles within the same instruction handle operand fetches, memory reads and writes, or I/O reads and writes; MREQ signals memory, IORQ signals I/O port access, and the RFSH signal drives DRAM refresh addresses during T3 and T4 of each M1 cycle — a Z80 quirk that lets it refresh dynamic RAM for free.
A logic-analyzer-style probe needs to latch the correct signals at the correct T-state of each machine cycle to know whether it just saw an opcode fetch, an operand fetch, a memory read, a memory write, or an I/O operation. Doing this in software on a general-purpose CPU is fragile — an interrupt or a cache miss can miss a cycle. Doing it in PIO is deterministic: the state machine is clock-locked, the code is a dozen instructions, and it never misses. That is the whole reason to reach for the RP2350 rather than, say, bit-banging GPIOs on a Pi 4.
Why it matters: a cheap window into vintage silicon
For makers and retro-computing enthusiasts, this project is significant not because a Z80 is exotic — a used Z80 costs roughly $2 — but because the RP2350 collapses a workflow that used to require a several-hundred-dollar Saleae Logic Pro or a benchtop analyzer down to a $5 chip and a breadboard. You can now build a permanent, always-on hardware disassembler for a retro CPU and leave it wired to the target for months of debugging. That opens up a lot of previously-expensive experiments: watching a Sinclair ZX Spectrum boot, tracing a TRS-80 Model 100 as it runs BASIC, or single-stepping through a homebrew CP/M port.
What you would actually learn from a build like this is different from what you learn using a commercial logic analyzer. A Saleae will give you cleaner waveforms, deeper capture memory, and pre-built protocol decoders — you press a button, it captures, you scroll through samples in the GUI. Building it on an RP2350 forces you to think about the Z80 bus at the T-state level, write your own decoder in PIO assembly, decide which signals matter and which you can ignore, and design a display format for the trace. You end up understanding the Z80 far more thoroughly than a plug-and-play analyzer would teach you. The tradeoff is capture depth: the RP2350 has 520 KB of SRAM, and once you burn some on firmware you have maybe 200 KB left for a rolling capture buffer, which is a few hundred thousand bus cycles — enough to watch a subroutine, not enough to record a full game session.
The source
Adafruit's blog surfaced the project in a July 2026 post; Adafruit's daily blog is the canonical place makers watch for this class of build, and their PIO tutorials are how many people learn to write RP2350 state-machine programs in the first place.
Get started: Raspberry Pi 4 and Pi Zero W as the maker on-ramp
If you want to build something like this yourself and are not yet sure which Raspberry Pi to keep on the bench, the answer is usually two boards, not one. A full-fat Raspberry Pi 4 handles the software side of a maker project — running the toolchain that compiles PIO code, hosting the disassembler that decodes captures, driving a monitor for waveform display — while a tiny board like the Pi Zero W handles the embedded end when the project needs to live inside a case.
The Raspberry Pi 4 8GB is our recommended workhorse. Quad-core Cortex-A72 at 1.5 GHz, 8 GB of LPDDR4, dual HDMI at 4Kp60, gigabit Ethernet, USB 3.0, and enough headroom to run a full Debian desktop with VS Code, the RP2350 SDK, and a live serial console to your target board. It is not the right chip to do timing-critical GPIO sampling on — the Linux kernel and the OS scheduler get in the way — but it is the right chip to develop, cross-compile, and debug on. Once your PIO program is loaded onto an RP2350 and running, the Pi 4 is where you view the captured bus trace.
The Raspberry Pi Zero W starter kit is our recommended tiny board. Single-core ARM11 at 1 GHz, 512 MB of RAM, built-in Wi-Fi, and a form factor small enough to fit inside a retro-computer enclosure. It is slow for desktop work but perfect as the always-on remote endpoint for a retro project: mount it inside your ZX Spectrum, wire its GPIOs to an RP2350 that is watching the Z80, and let it stream capture data over Wi-Fi to the Pi 4 on your desk. The starter kit bundles the board, power supply, and case — everything you need to get past the "wait, what cable does this need" stage on day one.
Pi 4 vs Pi Zero W vs Pico for vintage-hardware projects
| Board | CPU | RAM | GPIO timing | Best role in a Z80 project | Approx. street price (2026) |
|---|---|---|---|---|---|
| Raspberry Pi 4 8GB | 4x Cortex-A72 @ 1.5 GHz | 8 GB LPDDR4 | Non-deterministic (Linux) | Development host, capture viewer, code editor | $75 |
| Raspberry Pi Zero W | 1x ARM11 @ 1 GHz | 512 MB | Non-deterministic (Linux) | Embedded controller, Wi-Fi bridge, remote logger | $15 (kit) |
| Raspberry Pi Pico 2 (RP2350) | 2x Cortex-M33 @ 150 MHz | 520 KB SRAM | Deterministic (PIO) | Direct bus probe on the Z80, real-time decoder | $5 |
The pattern most experienced makers settle on is Pi 4 on the desk, Pico 2 on the target, and a Pi Zero W in between when Wi-Fi telemetry helps. All three complement each other; none of them is redundant.
How to reproduce a similar build
You do not need to wait for someone else to publish a Z80 monitor to try this yourself. A minimal reproduction plan:
- Order an RP2350 board (bare Pico 2 or a breakout with more GPIOs exposed) and a used Z80 CPU from an electronics supplier. Add a 4 MHz crystal, a 27C256 EPROM or 32 KB SRAM for the Z80's memory, and a handful of 74HC-series glue logic if you want a full working Z80 system rather than just the CPU alone.
- On your Pi 4, install the Raspberry Pi Pico SDK for RP2350 following the Raspberry Pi microcontrollers documentation — this is the canonical reference for PIO assembly, GPIO configuration, dual-core Cortex-M33 setup, and the flash tooling that gets your firmware onto the chip.
- Write a PIO program that samples the Z80's control signals on every edge of PHI (the Z80 clock), latches the address bus when M1 and MREQ are both low, and pushes 24-bit records (16-bit address plus 8-bit data plus control-signal snapshot) into a FIFO the Cortex-M33 reads.
- On the Cortex-M33 side, drain the FIFO into a ring buffer in SRAM, do a lightweight Z80 opcode decode (the Z80 instruction set is small enough to table-drive in a few kilobytes), and stream the decoded transaction stream over USB CDC to your Pi 4.
- On the Pi 4, write or borrow a Python or Rust viewer that shows the running trace — instruction, address, data, cycle type — with color-coding for opcode fetches versus reads versus writes.
Total parts cost: under $30. Total learning: a working understanding of every T-state of every machine cycle the Z80 executes.
What to know before you buy
If you have never done a bus-probing project before, start with the Pi 4 and a starter kit rather than jumping straight to a bare RP2350 and a vintage CPU. The Pi 4 gives you a full desktop-class Linux environment to build tools on, learn the SDK, run breadboard experiments, and iterate quickly. Once you are comfortable with GPIO fundamentals — pull-ups, level shifting, protecting 3.3V pins from 5V Z80 outputs — you graduate to the RP2350 and the actual target CPU. Skipping the desktop-Pi step is possible but costs you the fastest debugging loop you will ever have.
Level shifting deserves a callout: the Z80 is a 5V part, the RP2350 GPIOs are 3.3V tolerant only. You need a bus of 74LVC245 transceivers or a bank of level-shifter modules between them, or you will slowly kill the RP2350's I/O ring. Budget an extra $5 and an extra evening for this step.
FAQ
What is special about the Raspberry Pi RP2350 for projects like this?
The RP2350 is the Pi Foundation's newer microcontroller chip, with faster cores and improved programmable I/O blocks that can sample and respond to signals with precise timing. That makes it well suited to watching a vintage CPU's bus lines in real time, where you need to capture many fast-changing signals deterministically. Its low cost and flexible PIO are why makers reach for it in logic-analyzer-style retro projects.
Can a regular Raspberry Pi do the same thing as the RP2350 here?
A full Raspberry Pi 4 runs Linux and is excellent for the software side — logging, visualizing, and analyzing captured data — but its general-purpose I/O is less timing-deterministic than a microcontroller's. Many projects pair the two: a microcontroller captures the fast signals while a Pi 4 stores and displays them. The Pi 4 is the better choice when you want a full desktop-class environment driving the project.
Do I need a vintage Z80 to get into this kind of project?
No — the same techniques apply to many retro CPUs and chips, and you can start by learning the tools on modern, easily available components before moving to vintage silicon. A Raspberry Pi plus a breadboard and some logic experiments is a low-cost way to build the skills. Vintage chips like the Z80 are widely available from electronics suppliers if you want to recreate the project faithfully.
Which Raspberry Pi should a beginner buy to start maker projects?
The Raspberry Pi 4 8GB is a strong all-rounder that runs a full desktop, handles development tools, and drives a wide range of projects, making it ideal as a first board you will not outgrow quickly. The Pi Zero W is cheaper and tiny, perfect for embedded builds where size and power matter more than raw speed. Many makers eventually own both for different roles.
What else do I need besides the Pi to start electronics projects?
Beyond the board you want a quality power supply, a microSD card for the operating system, a breadboard, jumper wires, and a basic component kit with resistors, LEDs, and headers. A starter kit bundles many of these together, which simplifies the first purchase. As projects grow you may add a logic analyzer, a soldering iron, and a multimeter, but the basics are enough to follow most beginner tutorials.
