Eingebettetes FPGA-Design: Ein vollständiger Entwicklungsprozess

Anmerkung der Redaktion: Da fortgeschrittene Algorithmen für smarte Produktdesigns weiterhin entstehen, kämpfen Entwickler oft damit, eingebettete Systeme zu implementieren, die die Verarbeitungsanforderungen dieser Algorithmen erfüllen können. FPGAs liefern die nötige Performance, und jüngste Fortschritte in Device-Fähigkeiten und Entwicklungsumgebungen haben FPGA-Design für ein breiteres Spektrum an Ingenieuren zugänglich gemacht. Dieser Auszug aus Kapitel 4 von *Architecting High‑Performance Embedded Systems* bietet eine umfassende Übersicht über FPGA-Geräte, Implementierungssprachen und den Entwicklungsprozess sowie einen praktischen Walkthrough für den Einstieg in FPGA-Design.
1: Hardware-Ressourcen
2: Implementierungssprachen
3: Entwicklungsprozess (dieser Artikel)
4: Projekt erstellen
5: Implementierung

Adaptiert aus *Architecting High‑Performance Embedded Systems*, von Jim Ledin.

Der FPGA-Entwicklungsprozess

Über diverse Applikationsdomänen hinweg folgt FPGA-Entwicklung einer gemeinsamen Sequenz von Schritten, die Ingenieure vom Konzept zur funktionalen Hardware führen. Die folgenden Abschnitte skizzieren den typischen Workflow und heben Schlüsselentscheidungen und Best Practices hervor.

Systemanforderungen definieren

Erfolgreiche FPGA-Projekte beginnen mit einer klaren, eindeutigen Definition von Systemfunktionalität, Betriebsmodi und Schlüssel-Features. Dokumentieren Sie das beabsichtigte Verhalten in einfacher Sprache und teilen Sie es mit allen Stakeholdern, um Konsens zu erzielen. Quantitative Performance-Metriken einbeziehen – wie Input-Sampling-Raten, Output-Update-Intervalle, Durchsatz, Latenz und Power-Limits – sowie Constraints zu physischer Größe, Akkulaufzeit, Temperaturbereich und Kosten. Ein vollständiges Anforderungsset stellt sicher, dass jedes Design, das alle Spezifikationen erfüllt, tragfähig ist; wenn eine technisch korrekte Lösung aus Gründen wie Kosten scheitert, liegt die Lücke wahrscheinlich in der Anforderungsphase.

Sobald Top-Level-Anforderungen vereinbart sind, zerlegen Sie das System in kohärente Subsysteme, jedes mit eigenen funktionalen und technischen Spezifikationen. In Echtzeit-Eingebetteten Systemen bildet die digitale Verarbeitungsfähigkeit typischerweise ein dediziertes Subsystem mit eigenen Constraints.

Funktionalität dem FPGA zuordnen

Wenn die digitalen Verarbeitungsanforderungen eines Systems die Fähigkeiten von Mikrocontrollern oder Prozessoren übersteigen, erwägen Sie ein FPGA. Architekturen, die von High-Speed, paralleler Hardware profitieren, sind primäre Kandidaten. Selbst wenn ein konventioneller Prozessor die Performance erfüllen könnte, kann ein FPGA Flexibilität und Upgrade-Potenzial über den Produktlebenszyklus bieten.

Nach der Entscheidung für ein FPGA ordnen Sie die relevanten Verarbeitungsaufgaben ihm zu. Definieren Sie die Input- und Output-Interfaces des FPGAs, Update-Raten und Interaktionen mit Peripheriekomponenten wie ADCs, DACs und Speichergeräten.

Erforderliche FPGA-Features identifizieren

Mit den Verantwortlichkeiten und Interfaces des FPGAs definiert, erstellen Sie eine Liste obligatorischer Device-Features. Ressourcenanforderungen berücksichtigen – Logic Cells, DSP-Blöcke, Speicher – sowie Power- und Kühlbedarf. Low-Cost, batteriebetriebene Designs können kleinere Devices mit passiver Kühlung nutzen, während High-Performance-Systeme große FPGAs mit aktiver Kühlung benötigen.

Device-Familien unterscheiden sich in verfügbaren Features; manche beinhalten integrierte ADCs, um Board-Komplexität zu reduzieren. Nutzen Sie die Anforderungen, um Kandidaten-Familien zu shortlisten, dann spezifische Modelle einzugrenzen, sobald Ressourcenschätzungen klarer werden.

FPGA-Design implementieren

Mit einem Kandidaten-Device ausgewählt und Funktionalität gemappt, beginnen Sie die Implementierung mit einer Vendor-Tool-Suite – typischerweise Xilinx Vivado oder Intel Quartus. Der Prozess startet typischerweise mit einem Top-Level-Design, das als Blockdiagramm oder direkt in HDL (Verilog oder VHDL) oder High-Level-Synthesis-Sprachen wie C/C++ ausgedrückt werden kann.

Iterieren Sie durch die folgenden Phasen, das Design verfeinernd, bis ein funktionsfähiger Bitstream produziert wird:

Design Entry
Systemlogik definieren mit HDL, Blockdiagrammen oder C/C++ Code. Diese Artefakte beschreiben das beabsichtigte Verhalten, aber nicht die physische Integration.

I/O Planning
I/O Pins zuweisen, Signalstandards setzen und physische Constraints wie Pin-Platzierung und Trace-Länge für High-Speed-Signale berücksichtigen. I/O-Constraints, zusammen mit Timing-Constraints, leiten den Syntheseprozess.

Synthese
HDL in ein Netlist konvertieren, das Logik auf die Ressourcen des gewählten FPGAs abbildet. Wenn Constraints nicht erfüllt werden können, schlägt Synthese fehl und das Design muss überarbeitet werden.

Place and Route
Netlist-Logikelemente auf spezifische FPGA-Ressourcen platzieren unter Einhaltung der Constraints. Interconnections routen, um das physische Layout zu finalisieren. Das Ergebnis ist eine vollständig spezifizierte Konfiguration.

Bitstream-Generierung
Konfigurationsdatei erstellen, die den internen SRAM des FPGAs lädt. Dieser Bitstream ist analog zu einem Software-Executable und muss bei jedem Power-On-Zyklus geladen werden, typischerweise von Onboard-Flash oder einer externen Quelle.

Nach Bitstream-Erstellung gründliche Tests durchführen, um funktionale Korrektheit zu verifizieren.

Implementierung testen
In jeder Phase testen: HDL-Logik simulieren, synthetisiertes Netlist validieren und Hardware-in-the-Loop-Tests auf dem Target-Board durchführen. Umfassendes Testen mildert seltene Bugs, die Produktglaubwürdigkeit untergraben können.

Der nächste Abschnitt detailliert ein Hands-on-Beispiel mit dem Arty A7 Board und der Vivado Tool Suite.

Reprinted with permission from Packt Publishing. Copyright © 2021 Packt Publishing

Verwandte Inhalte:

• Eingebettetes Design mit FPGAs: Hardware-Ressourcen
• Eingebettetes Design mit FPGAs: Implementierungssprachen
• Open-Source-Tools helfen FPGA-Programmierung vereinfachen
• Implementierung von Gleitkomma-Algorithmen in FPGAs oder ASICs
• FPGAs für Deep Learning nutzen
• Software-Tools migrieren GPU-Code zu FPGAs für KI-Anwendungen
• FPGAs verdrängen ASICs in Subaru Eyesight vision-basiertem ADAS

Für mehr Embedded abonnieren Sie den wöchentlichen E-Mail-Newsletter von Embedded.