Für das Einrichten eines Open-Source-Development-Kits auf einem Debian Mini-PC mit 8 GB RAM für die Sipeed-Boards Tang Nano 9K, Tang Primer 20K/25K sowie das große Tang Mega 138K (alle basieren auf Gowin-FPGAs) nutzen Sie am besten die Kombination aus der OSS CAD Suite und dem All-in-One-Programmiertool openFPGALoader. [1]
Da das Tang Mega 138K (GW5AST-Chip) modernere DSPs und Architekturen besitzt, wird die Unterstützung dafür im Open-Source-Stack (via Project Apicula) stetig ausgebaut. 8 GB RAM sind für diese FOSS-Toolchain absolut ausreichend. [2]
1. Toolchain installieren (OSS CAD Suite)
Die OSS CAD Suite bündelt alle notwendigen Open-Source-Werkzeuge wie Yosys (Synthese) und nextpnr (Place & Route) vorkompiliert in einer Sandbox. [3]
Paket herunterladen: Laden Sie das aktuelle Linux-Archiv (normalerweise x86_64) aus den GitHub Releases der OSS CAD Suite herunter.
Entpacken (z. B. nach /opt):
sudo mkdir -p /opt/oss-cad-suite sudo tar -xvf oss-cad-suite-linux-x86_64-*.tgz -C /opt/oss-cad-suite --strip-components=1
Pfade in Ihrer Shell (z. B. ~/.bashrc) aktivieren:
export PATH="/opt/oss-cad-suite/bin:$PATH"
Hinweis: Nach dem Neuladen des Terminals stehen Ihnen yosys, nextpnr-gowin und das Python-Paket apicula direkt zur Verfügung. [4]
2. Flashing-Tool einrichten (openFPGALoader)
Da das proprietäre Gowin-Programmiertool unter Linux oft Hürden aufwirft, ist openFPGALoader die beste, quelloffene Alternative für alle Tang-Boards. [5]
Abhängigkeiten auf Debian installieren:
sudo apt update sudo apt install libftdi1-2 libftdi1-dev libusb-1.0-0-dev cmake g++ pkg-config zlib1g-dev
openFPGALoader bauen & installieren:
git clone https://github.com cd openFPGALoader && mkdir build && cd build cmake .. make -j$(nproc) sudo make install
Udev-Rules einrichten (Wichtig für USB-Zugriff ohne sudo):
sudo cp ../99-openfpgaloader.rules /etc/udev/rules.rules/ sudo udevadm control --reload-rules && sudo udevadm trigger sudo usermod -aG plugdev $USER
(Danach einmal aus- und wieder einloggen)
3. Der Open-Source-Workflow (Skript-Beispiel)
Ein typischer Synthese- und Programmierdurchlauf im Terminal sieht für ein einfaches Verilog-Projekt (src/top.v) wie folgt aus:
Schritt A: Synthese (Yosys)
Erzeugt ein JSON-Netzwerk. Parameter "-family gw1n" (für Nano 9K) oder "-family gw5a" (für Mega 138K) nutzen.
yosys -p "readverilog src/top.v; synthgowin -family gw5a -json project.json"
Schritt B: Place & Route (nextpnr)
Für Tang Nano 9K (GW1NR-LV9QN88PC6/I5):
nextpnr-gowin --json project.json --write route.json --device GW1NR-LV9QN88PC6/I5 --family GW1N-9C --cst src/constraints.cst
Für Tang Mega 138K:
nextpnr-gowin --json project.json --write route.json --device GW5AST-LV138PG484AC1/I0 --family GW5A-138 --cst src/constraints.cst
Schritt C: Bitstream generieren (Apicula)
gowin_pack -d GW5A-138 -o pack.fs route.json
Schritt D: Auf das Board laden (openFPGALoader)
Schließen Sie Ihr Board per USB an den Mini-PC an:
In den flüchtigen SRAM laden (zum Testen):
openFPGALoader -b tangnano9k pack.fs# oder für das Mega: openFPGALoader -b tangmega138k pack.fs
Dauerhaft in den Flash-Speicher schreiben:
openFPGALoader -b tangmega138k -f pack.fs
💡 Wichtiger Praxis-Tipp für das Tang Mega 138K
Die Open-Source-Unterstützung für die brandneue 22nm GW5A-Architektur des 138K-Megaboards wächst rasant, ist bei extrem komplexen Hard-IP-Blöcken (wie dem integrierten PCIe-Core oder den Hochgeschwindigkeitstransceivern) jedoch manchmal noch experimentell. [6] Sollten Sie für das Mega-Board hochentwickelte herstellereigene IP-Blöcke benötigen, empfiehlt es sich, zusätzlich die offizielle Gowin V1.9.9+ (Commercial Edition) herunterzuladen. Diese lässt sich unter Debian komplett headless (ohne GUI) über die Kommandozeile (gw_sh Tcl-Shell) in Verbindung mit Makefiles oder VS Code nutzen, was auf einem schlanken Mini-PC extrem performant läuft. [7] Möchten Sie primär mit Verilog / SystemVerilog arbeiten, oder planen Sie den Einsatz von grafischen Oberflächen wie VS Code mit TerosHDL? Ich kann Ihnen zeigen, wie Sie die Toolchain nahtlos dort einbinden.
[1] https://github.com [2] https://github.com [3] https://www.reddit.com [4] https://www.reddit.com [5] https://www.youtube.com [6] https://wiki.sipeed.com [7] https://www.reddit.com
Das ist eine hervorragende Wahl. Für Verilog (und SystemVerilog) ist der Open-Source-Stack unter Linux extrem schnell und mächtig. Auf Ihrem Mini-PC mit 8 GB RAM wird die Kompilierung in Sekundenbruchteilen durchlaufen, da kein schwerer GUI-Ballast im Hintergrund läuft.
Um das Arbeiten so komfortabel wie möglich zu machen, richten wir jetzt eine schlanke, professionelle Entwicklungsumgebung mit Visual Studio Code (VS Code), Linting (Fehlererkennung beim Tippen) und Simulations-Tools ein.
1. Editor & Erweiterungen einrichten
Installieren Sie VS Code auf Ihrem Debian-System und fügen Sie die wichtigsten Erweiterungen für Verilog hinzu:
VS Code installieren:
sudo apt update sudo apt install code
Erweiterungen installieren: Öffnen Sie VS Code (code .) und installieren Sie über den Extension-Marktplatz (Strg+Shift+X):
TerosHDL oder Verilog-HDL/SystemVerilog (von mshr-h) – für Syntax-Highlighting und Autovervollständigung.
- Digitaljs (optional) – visualisiert Ihr Verilog-Design direkt in VS Code als interaktiven Schaltplan.
2. Live-Fehlererkennung (Linting) installieren
Damit Ihnen Tippfehler oder Syntaxfehler sofort beim Schreiben rot unterstrichen werden (wie in modernen Programmiersprachen), nutzen wir Verilator.
Verilator unter Debian installieren:
sudo apt install verilator
In VS Code aktivieren: Öffnen Sie die Einstellungen (Strg + ,), suchen Sie nach Verilog Linter und stellen Sie den Linter auf verilator um.
3. Simulation & Testbenches (Wichtig vor dem Flashen)
Bevor Sie den Code auf Ihr Tang-Board laden, sollten Sie ihn immer auf dem PC simulieren. Das spart Zeit und schont die Hardware. Dazu nutzen wir Icarus Verilog und den Waveform-Viewer GTKWave.
Werkzeuge installieren:
sudo apt install iverilog gtkwave
Ein einfaches Simulations-Beispiel: Erstellen Sie eine Testbench-Datei namens tb_top.v:
`timescale 1ns/1psmodule tb_top; reg clk = 0; wire led;
// Ihr Hauptmodul einbinden (z.B. ein LED-Blinker) top uut (.clk(clk), .led(led));
always #10 clk = ~clk; // 50 MHz Takt simulieren
initial begin $dumpfile("simulation.vcd"); // Erzeugt die Waveform-Datei $dumpvars(0, tb_top); #1000; // Simuliere für 1000 Nanosekunden $finish; endendmodule
Simulation im Terminal starten:
iverilog -o sim.out src/top.v tb_top.v vvp sim.out gtkwave simulation.vcd
Es öffnet sich GTKWave, wo Sie Ihre Signale (Takte, Register, Ausgänge) visuell analysieren können.
4. Das Projekt automatisieren (Makefile)
Damit Sie nicht jedes Mal die langen Befehle für Yosys, nextpnr und openFPGALoader eintippen müssen, erstellen Sie im Projektordner eine Datei namens Makefile. Hier ist eine Vorlage für das Tang Nano 9K:
Projekteinstellungen
BOARD = tangnano9k DEVICE = GW1NR-LV9QN88PC6/I5 FAMILY = GW1N-9C
SRCS = src/top.v CONSTRAINTS = src/constraints.cst
all: pack.fs
1. Synthese
project.json: $(SRCS) yosys -p "readverilog $(SRCS); synthgowin -family gw1n -json project.json"
2. Place & Route
route.json: project.json $(CONSTRAINTS) nextpnr-gowin --json project.json --write route.json --device $(DEVICE) --family $(FAMILY) --cst $(CONSTRAINTS)
3. Bitstream packen
pack.fs: route.json gowin_pack -d $(FAMILY) -o pack.fs route.json
4. Auf das Board laden (SRAM)
load: pack.fs openFPGALoader -b $(BOARD) pack.fs
5. Dauerhaft in den Flash schreiben
flash: pack.fs openFPGALoader -b $(BOARD) -f pack.fs
clean: rm -f project.json route.json pack.fs sim.out simulation.vcd
.PHONY: all load flash clean
Wie Sie es nutzen: Wenn Sie Ihren Code geändert haben, tippen Sie im VS Code-Terminal einfach:
- make zum Kompilieren.
- make load zum direkten Testen auf dem angeschlossenen Board.
Möchten Sie als Erstes ein einfaches „Hello World“-Projekt (z. B. eine blinkende LED) für eines Ihrer Boards aufsetzen, um die Toolchain direkt zu testen? Wenn ja, für welches der drei Boards (Tang Nano 9K, 20K/25K oder Mega 138K) soll ich Ihnen den passenden Verilog-Code und die dazugehörige Pin-Belegungsdatei (.cst) erstellen?