PYNQ-Board meistern: Python auf Xilinx Zynq SoCs (FPGA + ARM) – Komplettanleitung

Was ist PYNQ?

**PYNQ (Python Productivity for Zynq)** ist ein Open-Source-Framework von Xilinx (jetzt AMD), das die Programmierung von **Zynq-7000** und **Zynq UltraScale+ MPSoC** (FPGA + ARM Cortex-A9/A53) **in Python** ermöglicht. Statt VHDL/Verilog & C für Bare-Metal/Linux zu schreiben, nutzt man Python-Bibliotheken, Jupyter Notebooks und Overlays (vorkonfigurierte FPGA-Designs). Ziel: FPGA-Beschleunigung für Software-Entwickler zugänglich machen.

Wichtige PYNQ-Boards

PYNQ-Z1 Hardware-Highlights

• **FPGA:** Artix-7 (85k Logic Cells, 53.200 LUTs, 220 DSP-Slices, 4,9 Mb BRAM)
• **CPU:** Dual-Core Cortex-A9 @ 650 MHz, 512 MB DDR3
• **Video:** HDMI 1.4 Input (bis 1080p60) + Output (bis 1080p60)
• **Audio:** 24-bit Codec (Line In/Out, Mic, Headphone)
• **Erweiterung:** 2× Pmod (JA/JB), 1× Arduino Shield Header (UNO-kompatibel), 1× Raspberry Pi Header (26 Pin)
• **Konnektivität:** Gigabit Ethernet, USB 2.0 Host, USB OTG, microSD
• **Boot:** microSD mit PYNQ-Image (Linux + Python + Overlays)

Software & Ökosystem

• **PYNQ-Image:** Vorgefertigtes SD-Karten-Image (Ubuntu-basiert) mit JupyterHub, Python 3, PYNQ-Libraries, Overlays (Base, LogicTools, Video, DMA, etc.).
• **Jupyter Notebooks:** Interaktive Entwicklung, Dokumentation, Visualisierung im Browser.
• **Overlays (Bitstreams):** Vorkompilierte FPGA-Designs (.bit + .hwh + .tcl), per Python ladbar: Overlay('base.bit').
• **PYNQ Libraries:** Treiber für GPIO, PWM, IIC, SPI, UART, DMA, Video (HDMI In/Out), Audio, LogicTools (Boolean, FSM, Pattern Gen), Pmod/Arduino-Module.
• **Vivado / Vitis:** Für eigene Overlays (RTL, HLS, IP Integrator) – kostenlos (WebPACK/Edition).

Ersteinrichtung (PYNQ-Z1 / Z2)

1. Image herunterladen: pynq.io/board.html → passendes Board wählen → neueste .img.gz laden.
2. Auf microSD schreiben (≥ 8 GB, Class 10 / A1): BalenaEtcher, Raspberry Pi Imager, dd (Linux/macOS).
3. Board jumpern: JP4 (Boot Mode) → **SD** (oberste 2 Pins). JP5 (Power) → **USB** (oberste 2 Pins) für USB-Strom oder **REG** für 12 V Jack.
4. microSD einstecken (Unterseite).
5. USB-Kabel anschließen: Micro-USB an **PROG/UART** (JTAG/UART) → PC (für serielle Konsole, optional).
6. Ethernet anschließen: An Router/Switch (DHCP) oder direkt an PC (statische IP, siehe unten).
7. Einschalten: Power-Schalter → Rote LED (Power), dann Gelb/Grün (FPGA Done), dann 2× Blau blinkend + 4× Gelb/Grün = System bereit.

Netzwerk & Jupyter-Zugriff

Variante A: Über Router (empfohlen – Internet & Updates)

1. PC & PYNQ am gleichen Router (LAN/WLAN).
2. Browser: https://pynq:9090/ (mDNS) oder https://[IP]:9090/.
3. Login: **User: xilinx / Passwort: xilinx**.

Variante B: Direkt an PC (ohne Internet)

1. PC: Statische IP 192.168.2.1/24 auf Ethernet-Interface setzen.
2. PYNQ default: 192.168.2.99.
3. Browser: https://192.168.2.99:9090/.
4. Tipp: Internet für PYNQ via Internet Connection Sharing (ICS) / Bridge auf PC ermöglichen.

PYNQ vs. ZYNQ – Was ist der Unterschied?

• ZYNQ: Die SoC-Architektur (ARM + FPGA auf einem Chip) – Hardware.
• PYNQ: Das Software-Framework (Python, Jupyter, Overlays, Libraries), das auf ZYNQ-Boards läuft – Produktivitätsschicht.

Beispiel-Projekte

• Computer Vision: HDMI-In → FPGA (Bayer2RGB, Filter, Kantendetektion) → HDMI-Out / Python (OpenCV/NumPy).
• Deep Learning Inferenz: DPU (Deep Learning Processing Unit) Overlay + Vitis AI → Python-API für TensorFlow/PyTorch-Modelle auf FPGA.
• Software Defined Radio: Pmod-Radio (ADALM-PLUTO) + FPGA-Signalverarbeitung + Python-Demodulation.
• Motorsteuerung / Robotik: Encoder, PWM, PID im FPGA (deterministisch) + Python-High-Level-Steuerung.
• High-Speed Data Acquisition: ADC-Pmod → FPGA (DMA, FIFO) → Python (NumPy/Plotly).
• Network Acceleration: FPGA-Offload für TCP/IP, TLS, Kompression (SmartNIC-Konzept).

PYNQ für FPGA-Entwicklung nutzen

PYNQ ersetzt nicht Vivado/Vitis für RTL-Design, aber es **beschleunigt die Integration**: FPGA-Designer erstellen Overlays (IP-Blöcke + HLS-Kernel), Software-Entwickler nutzen sie per Python-API. Workflow: Vivado Block Design → Export Hardware (XSA) → PYNQ Overlay-Paket bauen → Python nutzen.

Fazit

PYNQ-Boards (Z1, Z2, ZU, Kria) sind die beste Einstiegskarte in die Welt der **heterogenen Beschleunigung (CPU + FPGA)** mit Python. Sie senken die Hürde für FPGA-Nutzung drastisch: Kein VHDL für Anwendungslogik nötig, schnelle Prototypen in Jupyter, riesige Library an Overlays. Für KI-Edge, Vision, SDR, Robotik, High-Speed-DAQ ideal. Starten Sie mit PYNQ-Z1/Z2 und dem offiziellen Image. Benötigen Sie Support bei Overlay-Entwicklung oder Board-Auswahl? Wir sind da.