FPGA-Eingebettetes Design meistern: Ein praktischer Implementierungsleitfaden

Die Verfügbarkeit leistungsfähigerer FPGAs und effektiverer Programmierumgebungen hat die FPGA-Implementierung allgemein zugänglich gemacht, doch der Einsatz von FPGAs kann einschüchternd wirken.

Redaktioneller Hinweis: Da fortschrittliche Algorithmen für smarte Produktdesigns entstehen, kämpfen Entwickler oft damit, eingebettete Systeme zu implementieren, die den damit verbundenen Verarbeitungsanforderungen gerecht werden. FPGAs können die erforderliche Leistung liefern, aber das Design mit FPGAs galt lange als Domäne von FPGA-Programmierexperten. Heute jedoch haben leistungsfähigere FPGAs und effektivere Entwicklungsumgebungen die FPGA-Entwicklung allgemein zugänglich gemacht. In diesem Auszug, Kapitel 4 aus dem Buch „Architecting High-Performance Embedded Systems“, bietet der Autor eine umfassende Übersicht über FPGA-Geräte, Implementierungssprachen und den FPGA-Entwicklungsprozess sowie einen detaillierten Walkthrough, wie Sie FPGAs in Ihrem eigenen Design einsetzen können. Der vollständige Auszug wird in der folgenden Serie von Folgen präsentiert: 1: Hardware-Ressourcen
2: Implementierungssprachen
3: Entwicklungsprozess
4: Projekt erstellen
5: Implementierung (dieser Artikel)

Adaptiert aus „Architecting High-Performance Embedded Systems“ von Jim Ledin.

Logikverhalten testen

Es ist wichtig, das Verhalten der Logik mithilfe von Simulation zu testen, bevor man versucht, sie im FPGA auszuführen. Dies liegt daran, dass es in der Simulationsumgebung viel einfacher ist, Probleme zu erkennen und zu beheben, als mit der Logik, die im FPGA läuft. Die Vivado-Simulationswerkzeuge stellen das Schaltverhalten sehr gut dar:

1. Im Sources-Teilfenster rechtsklicken auf Simulation Sources und Add Sources… auswählen:

Abbildung 4.18 – Menüauswahl Add Sources… für Simulation Sources

2. Im Dialog Add Sources sicherstellen, dass Add or create simulation sources ausgewählt ist, dann Next klicken.
3. Im Dialog Add or Create Simulation Sources auf Create File klicken.
4. Dateinamen vhdl eingeben und OK klicken.
5. Finish klicken, um den Dialog Add or Create Simulation Sources zu schließen, dann OK im Define Module-Dialog und Yes, wenn gefragt wird, ob man diese verwenden möchte.
6. Doppelklick auf Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) unter Simulation Sources. Den automatisch eingefügten Inhalt des vhdl-Editorfensters löschen und folgenden Code in den Adder4TestBench.vhdl-Editor eingeben:

library IEEE;   use IEEE.STD_LOGIC_1164.ALL;   use IEEE.NUMERIC_STD.ALL; entity ADDER4_TESTBENCH is end entity ADDER4_TESTBENCH; architecture BEHAVIORAL of ADDER4_TESTBENCH is   component ADDER4 is     port (       A4       : in    std_logic_vector(3 downto 0);       B4       : in    std_logic_vector(3 downto 0);       SUM4     : out   std_logic_vector(3 downto 0);       C_OUT4   : out   std_logic     );   end component;   signal a            : std_logic_vector(3 downto 0);   signal b            : std_logic_vector(3 downto 0);   signal s            : std_logic_vector(3 downto 0);   signal c_out        : std_logic;   signal expected_sum5: unsigned(4 downto 0);   signal expected_sum4: unsigned(3 downto 0);   signal expected_c   : std_logic;   signal error        : std_logic; begin   TESTED_DEVICE: ADDER4     port map (       A4     => a,       B4     => b,       SUM4   => s,       C_OUT4 => c_out     );   TEST: process   begin     -- Test all combinations of two 4-bit addends (256 total tests)     for a_val in 0 to 15 loop       for b_val in 0 to 15 loop         -- Set the inputs to the ADDER4 component         a <= std_logic_vector(to_unsigned(a_val, a'length));         b <= std_logic_vector(to_unsigned(b_val, b'length));         wait for 1 ns;         -- Compute the 5-bit sum of the two 4-bit values         expected_sum5 <= unsigned('0' & a) + unsigned('0' & b);         wait for 1 ns;         -- Break the sum into a 4-bit output and a carry bit         expected_sum4 <= expected_sum5(3 downto 0);         expected_c    <= expected_sum5(4);         wait for 1 ns;         -- The 'error' signal will only go to 1 if an error occurs         if ((unsigned(s) = unsigned(expected_sum4)) and             (c_out = expected_c)) then           error <= '0';         else           error <= '1';         end if;         -- Each pass through the inner loop takes 10 ns         wait for 7 ns;       end loop;     end loop;     wait;   end process TEST; end architecture BEHAVIORAL;

Dieser Code testet die 4-Bit-Addierer-Funktionalität, indem er alle Kombinationen von 4-Bit-Zahlen an die A4- und B4-Eingänge des Adder4-Components anlegt. Er vergleicht die SUM4- und C_OUT4-Ausgänge des Adder4-Components mit unabhängig berechneten Werten für dieselben Eingänge. Nach jeder Additionsoperation wird das error-Signal auf 0 gesetzt, wenn die Adder4-Ausgänge den erwarteten Werten entsprachen, oder auf 1, falls ein Missmatch vorliegt.

Der Code in Adder4TestBench.vhdl ähnelt herkömmlicher Software-Code in der Art, wie er verschachtelte for-Schleifen verwendet, um alle Test-Eingabekombinationen auf das zu testende Adder4-Component anzuwenden. Code, der im Simulationsmodus läuft, ist nicht synthetisierbar, was bedeutet, dass er nicht rein eine Hardware-Logikschaltung darstellt und traditionelle softwareähnliche Operationen wie die iterative Ausführung von for-Schleifen ermöglicht.

Wie in physikalischen Schaltungen können Signale, die im Testbench-Code mit dem <=-Operator Werte zugewiesen bekommen, nicht im selben Zeitpunkt in nachfolgenden Ausdrücken verwendet werden. Dies liegt daran, dass die Simulationsumgebung die realen Ausbreitungsverzögerungen abbildet, die selbst in winzigen FPGA-Geräten signifikant sind. Die drei wait for 1 ns;-Anweisungen im Testbench-Code pausieren die Schaltungsoperationen, um Ausbreitungsverzögerung zuzulassen. Diese 1 ns Verzögerungen geben Zeit, damit die kurz vor dem wait-Statement berechneten Signalwerte sich ausbreiten können, um in der folgenden Anweisung verwendet zu werden. Die abschließende wait for 7 ns;-Anweisung in der inneren Schleife ist eine Pause, die es uns erlaubt, die Ergebnisse jeder Iteration der Simulationsschleifen in der Signaltrace-Anzeige klar zu sehen.

7. Rechtsklick auf Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) unter Simulation Sources und Automatic Update and Compile Order auswählen. Dies setzt ADDER4_TESTBENCH als Top-Level-Objekt für den Simulationslauf:

Abbildung 4.19 – Menüauswahl für Automatic Update and Compile Order

8. Run Simulation klicken, dann Run Behavioral Simulation im Flow Navigator-Fenster, um in den Simulationsmodus zu wechseln. Falls die Editor-Dateien noch nicht gespeichert wurden, werden Sie dazu aufgefordert. Save klicken. Die Simulation wird dann ausgeführt:

Abbildung 4.20 – Menüauswahl Run Behavioral Simulation

9. Wenn das SIMULATION-Fenster öffnet, auf den Maximieren-Button im Simulationsausgabefenster mit dem Titel Untitled 1 klicken:

Abbildung 4.21 – Simulationsergebnisfenster

Die gesamte simulierte Zeit pro Durchlauf der inneren Schleife beträgt 10 ns. Da es 256 Durchläufe der Schleife in Adder4TestBench.vhdl gibt, beträgt die Simulationslaufzeit 2560 ns.

10. Simulationslaufzeit auf 2560 ns in der oberen Toolbar einstellen (Schritt 1 in der folgenden Abbildung), den linken Neustart-Button drücken (Schritt 2), dann den rechten Button drücken, um die Simulation für 2560 ns laufen zu lassen (Schritt 3), und schließlich den Zoom Fit-Button (Schritt 4) drücken, um den Simulationsausgabedatenbereich an das Fenster anzupassen:

Abbildung 4.22 – Simulationsergebnisse vom Anfang bis zum Ende des Laufs

Sie können die Lupensymbole verwenden, um auf einen beliebigen Punkt des Traces zu zoomen und die Ergebnisse jeder Additionsoperation während des Tests zu beobachten. Zum Beispiel zeigt die folgende Abbildung, dass die Dezimalwerte 6 und 2 addiert wurden, um das Ergebnis 8 mit einem Carry von 0 zu erzeugen. Diese Werte entsprechen den erwarteten Werten, wodurch error auf 0 gesetzt wurde. Das error-Signal ist für alle 256 Testfälle 0, was bedeutet, dass unsere Logikschaltung alle Tests bestanden hat:

Abbildung 4.23 – Hineingezoomte Ansicht der Simulationsergebnisse

11. Simulationsmodus schließen, indem man auf das X in der blauen SIMULATION-Leiste über dem Datentrace klickt. OK klicken, wenn gefragt wird, ob man die Simulation schließen möchte.

Nachdem der Verhaltenstest bestanden wurde, definieren wir die im Design verwendeten I/O-Signale.

I/O-Signale definieren

Unser nächster Schritt ist es, die Ein- und Ausgänge unserer Schaltung mit Hardware-Geräten auf dem Arty-Board zu verbinden. Die Eingänge werden die Board-Schalter und Taster sein, die Ausgänge LEDs.

Die folgenden Schritte erstellen eine Constraints-Datei, die die I/O-Pins beschreibt, die wir auf dem FPGA-Gerät verwenden, und die Funktionen, die mit diesen Pins auf dem Arty-Board verbunden sind. Constraints-Dateien haben die Erweiterung xdc:

1. Im Sources-Teilfenster rechtsklicken auf Constraints und Add Sources… auswählen.
2. Im Add Sources-Dialog sicherstellen, dass Add or create constraints ausgewählt ist, dann Next klicken.
3. Im Add or Create Constraints-Dialog auf Create File klicken.
4. Dateinamen Arty-A7-100.xdc (oder Arty-A7-35.xdc falls für Ihr Gerät passend) eingeben und OK klicken.
5. Finish klicken, um den Add or Create Constraints-Dialog zu schließen.
6. Constraints-Quellbaum erweitern und Arty-A7-35.xdc doppelklicken.
7. Digilent stellt vorkonfigurierte Constraints-Dateien für Arty A7-Boards bereit. Besuchen Sie https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-35-Master.xdc und kopieren Sie den gesamten Inhalt des Browserfensters in das Arty-A7-35.xdc-Editorfenster in Vivado. Falls für Ihr Gerät passend, verwenden Sie stattdessen die Datei unter https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-100-Master.xdc.
8. Alle I/O-Pins sind in der Constraints-Datei durch das #-Zeichen am Zeilenanfang auskommentiert. Die entsprechenden Zeilen in der Datei entkommentieren, indem man das #-Zeichen vom Zeilenanfang entfernt. Wir werden die in den folgenden Abschnitten aufgelisteten Pins in der Arty-A7-100.xdc-Datei verwenden: Switches, RGB LEDs (aber nur led0_g, die erste grüne LED), LEDs und Buttons. Die folgende Abbildung zeigt diese Zeilen nach dem Entkommentieren:

Abbildung 4.24 – Constraints-Editor-Fenster

Im nächsten Abschnitt erstellen wir eine Top-Level-VHDL-Datei, die den Addierer-Code mit den I/O-Geräten verbindet.

Top-Level-VHDL-Datei erstellen

Als Nächstes erstellen wir eine Top-Level-VHDL-Datei, die unseren 4-Bit-Addierer-Component mit den entsprechenden Board-I/O-Signalen verbindet:

1. Im Sources-Teilfenster rechtsklicken auf Design Sources und Add Sources… auswählen.
2. Im Add Sources-Dialog sicherstellen, dass Add or create design sources ausgewählt ist, dann Next klicken.
3. Im Add or Create Design Sources-Dialog auf Create File klicken.
4. Dateinamen vhdl eingeben und OK klicken.
5. Finish klicken, um den Add or Create Design Sources-Dialog zu schließen, dann OK im Define Module-Dialog und Yes, wenn gefragt wird, ob man diese verwenden möchte.
6. vhdl unter Design Sources doppelklicken. Den automatisch eingefügten Inhalt des ArtyAdder.vhdl-Editorfensters löschen und folgenden Code in den ArtyAdder.vhdl-Editor eingeben:

-- Load the standard libraries library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity ARTY_ADDER is    port (        sw         : in STD_LOGIC_VECTOR (3 downto 0);        btn        : in STD_LOGIC_VECTOR (3 downto 0);        led        : out STD_LOGIC_VECTOR (3 downto 0);        led0_g     : out STD_LOGIC    ); end entity ARTY_ADDER; architecture BEHAVIORAL of ARTY_ADDER is -- Reference the previous definition of the 4-bit adder component ADDER4 is port (    A4       : in   std_logic_vector(3 downto 0);    B4       : in   std_logic_vector(3 downto 0);    SUM4     : out  std_logic_vector(3 downto 0);    C_OUT4   : out  std_logic ); end component; begin ADDER : ADDER4    port map (      A4        => sw,      B4        => btn,      SUM4      => led,      C_OUT4     => led0_g    ); end architecture BEHAVIORAL;

Dieser Code ordnet die Signalnamen für die I/O-Geräte, die in Arty-A7-100.xdc als sw (4 Schalter), btn (4 Taster), led (4 einfarbige LEDs) und led0_g (der grüne Kanal der ersten mehrfarbigen LED) benannt sind, den ADDER4-Ein- und Ausgängen zu.

Während VHDL nicht case-sensitiv ist, ist die Verarbeitung von xdc-Constraints-Dateien in Vivado case-sensitiv. Die in der xdc-Datei verwendeten Groß-/Kleinschreibungen bei I/O-Gerätenamen müssen identisch sein, wenn sie in einer VHDL-Datei referenziert werden. Speziell müssen die I/O-Signalnamen in VHDL in dieser Datei klein geschrieben sein, weil sie in der Constraints-Datei klein geschrieben sind.

Wir sind nun bereit, unser Design für das Arty-Board zu synthetisieren, zu implementieren und zu programmieren. 

FPGA-Bitstream synthetisieren und implementieren

Alternativ können Sie Generate Bitstream auswählen, und Vivado führt alle erforderlichen Schritte aus, einschließlich Synthese, Implementierung und Bitstream-Generierung ohne weitere Benutzereingriffe. Tritt ein fataler Fehler auf, stoppt der Prozess und Fehlermeldungen werden angezeigt. Führen Sie die folgenden Schritte aus, um den Bitstream zu generieren:

1. Generate Bitstream klicken, um den Build zu starten. Sie werden gefragt, ob Sie Texteditoren speichern möchten. Save klicken. Sie werden informiert, dass keine Implementierungsergebnisse vorliegen und gefragt, ob es OK ist, Synthese und Implementierung zu starten. Yes klicken:

Abbildung 4.25 – Menüauswahl Generate Bitstream

2. Der Launch Runs-Dialog wird dann angezeigt. Sie können einen Wert für Number of jobs bis zur Anzahl der Prozessorkerne in Ihrem Computer wählen. Mehr Kerne beschleunigen den Prozess, können aber Ihre Maschine verlangsamen, wenn Sie sie während eines langen Builds weiter nutzen möchten. OK klicken, um den Build zu starten:

Abbildung 4.26 – Launch Runs Dialog

3. Während des Build-Prozesses zeigt Vivado den Status in der oberen rechten Ecke des Hauptfensters an. Falls nötig, können Sie den Build-Prozess abbrechen, indem Sie auf Cancel neben der Statusanzeige klicken:

Abbildung 4.27 – Kompilierungsstatusanzeige

4. Wenn der Build-Prozess abgeschlossen ist, vorausgesetzt es gab keine fatalen Fehler, erscheint ein Bitstream Generation Completed-Dialog. Obwohl andere Optionen angeboten werden, fahren wir direkt mit dem Herunterladen des Bitstreams auf das Arty-Board fort. Open Hardware Manager auswählen und OK klicken:

Abbildung 4.28 – Bitstream Generation Completed Dialog

Als Nächstes laden wir den Bitstream in den FPGA herunter.

Bitstream auf das Board herunterladen

Führen Sie die folgenden Schritte aus, um den Bitstream auf ein Arty A7 Board herunterzuladen:

1. Der HARDWARE MANAGER-Dialog erscheint und zeigt No hardware target is open an.
2. Verbinden Sie Ihr Arty A7-35 oder A7-100 Board per USB mit dem Computer. Warten Sie einige Sekunden, bis das Board erkannt wird, dann klicken Sie auf Open target, dann Auto Connect:

Abbildung 4.29 – Open target und Auto Connect Auswahl

3. Nach einigen Sekunden sollte Vivado anzeigen, dass das Board verbunden ist. Program device klicken, um den FPGA-Bitstream auf das Arty-Board herunterzuladen. Sie werden aufgefordert, eine Bitstream-Datei auszuwählen. Wenn Sie die gleiche Verzeichnisstruktur wie in diesem Beispiel verwendet haben, befindet sich die Datei unter C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bit:

Abbildung 4.30 – Program Device Dialog

4. Program klicken, um das Programm auf das FPGA-Gerät herunterzuladen und zu starten.
5. Sie können nun den Betrieb des Programms mit den Arty I/Os testen. Stellen Sie alle vier Schalter auf aus (bewegen Sie die Schalter in Richtung der benachbarten Boardkante) und drücken Sie keine der vier Taster. Alle vier grünen LEDs sollten aus sein.
6. Wenn Sie einen einzelnen Schalter einschalten oder einen Taster drücken, sollte die entsprechende grüne LED leuchten. Das Einschalten beliebiger Schalterkombinationen bei gleichzeitigen Drücken beliebiger Taster addiert die entsprechenden 4-Bit-Zahlen und beleuchtet die LEDs mit dem Ergebnis. Falls ein Carry auftritt (z. B. SW3 einschalten und BTN3 gleichzeitig drücken), leuchtet die grüne Carry-LED.

Der hier durchgeführte Programmierprozess speicherte das Programm im FPGA-RAM. Wenn Sie die Stromversorgung des FPGA-Boards zyklisch ein- und ausschalten, müssen Sie den Programmiervorgang wiederholen, um das Programm neu zu laden. Alternativ können Sie die FPGA-Konfigurationsdatei im onboard Flash-Speicher speichern, wie im folgenden Abschnitt beschrieben.

Bitstream in den onboard Flash-Speicher programmieren

Damit der FPGA bei jedem Einschalten des Arty-Boards konfiguriert wird, muss die FPGA-Konfigurationsdatei in den Flash-Speicher auf dem Board geschrieben werden. Wenn der MODE-Jumper installiert ist, versucht der FPGA beim Einschalten, eine Konfigurationsdatei vom onboard Flash-Speicher herunterzuladen. Dieser Speicher befindet sich in einem separaten Chip neben dem Artix-7 FPGA. Folgen Sie diesen Schritten, um die Konfigurationsdatei in den Flash-Speicher zu programmieren:

1. Installieren Sie den MODE-Jumper auf dem Arty-Board, falls noch nicht vorhanden.
2. Rechtsklick auf Generate Bitstream und Bitstream Settings… auswählen.
3. Im Settings-Dialog das Kontrollkästchen neben -bin_file aktivieren und OK klicken:

Abbildung 4.31 – Bitstream Settings Dialog

4. Im Haupt-Vivado-Dialog Generate Bitstream klicken und den Bitstream-Generierungsprozess wiederholen. Cancel klicken, wenn der Bitstream Generation Completed-Dialog erscheint.

5. Im Hardware-Dialog rechtsklicken auf die FPGA-Teilenummer (xc7a100t_0) und Add Configuration Memory Device… auswählen:

Abbildung 4.32 – Menüauswahl Add Configuration Memory Device…

6. s25fl127 in das Search-Feld eingeben. Dies sollte eine passende Teilenummer anzeigen. Das Teil auswählen und OK klicken:

Abbildung 4.33 – Add Configuration Memory Device Dialog

7. Es erscheint ein Dialog mit der Frage Do you want to program the configuration memory device now? OK klicken.
8. Es erscheint ein Program Configuration Memory Device-Dialog, der den Konfigurationsdateinamen anfordert. Auf den …-Button rechts von Configuration file klicken und C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bin auswählen. OK klicken:

Abbildung 4.34 – Program Configuration Memory Device Dialog

9. Der Programmiervorgang dauert einige Sekunden. Sie sollten eine Erfolgsmeldung erhalten, nachdem die Datei in den Board-Flash-Speicher programmiert wurde:

Abbildung 4.35 – Program Flash Complete Dialog

Danach wird bei jedem Power-Cycling des Boards das 4-Bit-Addierer-Programm geladen und ausgeführt. Mit den von uns verwendeten Einstellungen für das Laden der Konfigurationsdatei dauert es lange, bis das Programm geladen ist. Um das Warten auf das Laden des Programms durch den FPGA zu vermeiden, können Sie die Geschwindigkeit des Ladens der Konfigurationsdatei verbessern, indem Sie die folgenden Schritte ausführen:

1. Open Synthesized Design im Flow Navigator auswählen.
2. Im Vivado-Hauptmenü Tools/Edit Device Properties… auswählen.
3. Im General-Tab Enable Bitstream Compression auf TRUE setzen.
4. Im Configuration-Tab Configuration Rate (MHz) auf 33 setzen, dann OK klicken.
5. Bitstream erneut generieren und Flash-Speicher wie beschrieben programmieren. Sie müssen das Konfigurations-Speichergerät entfernen und wieder hinzufügen, um die Option für Neuprogrammierung anzuzeigen.
6. Hardware Manager schließen.
7. Arty-Board USB-Kabel abziehen und wieder einstecken. Das Programm sollte beim Einschalten praktisch augenblicklich starten.

Dieser Abschnitt präsentierte ein Beispiel für einfache kombinatorische Logik, die mit Signalen an den FPGA-I/O-Pins interagiert. Die Absicht war, Sie mit der Vivado-Tool-Suite vertraut zu machen und zu demonstrieren, wie die Tools verwendet werden, um einen vollständigen FPGA-Entwicklungszyklus durchzuführen.

Zusammenfassung

Dieses Kapitel begann mit einer Diskussion über den effektiven Einsatz von FPGAs in Echtzeit-Eingebetteten Systemarchitekturen und fuhr fort mit einer Beschreibung standardmäßiger FPGA-Geräte und der Low-Level-Komponenten, die sie enthalten. Die Bandbreite der FPGA-Designsprachen, einschließlich HDLs, Blockdiagramm-Methoden und populärer Software-Programmiersprachen wie C/C++, wurde vorgestellt. Ein Überblick über den FPGA-Entwicklungsprozess wurde gegeben. Das Kapitel endete mit einem vollständigen Beispiel eines FPGA-Entwicklungszyklus, beginnend mit einer Anforderungsspezifikation und endend mit einem funktionalen System, implementiert auf einem kostengünstigen FPGA-Entwicklungsboard.

Nach Abschluss dieses Kapitels sollten Sie wissen, wie FPGAs effektiv in Echtzeit-Eingebettete-Systemarchitekturen angewendet werden können und die Komponenten innerhalb eines FPGA-Integrierten Schaltkreises verstehen. Sie haben etwas über die Programmiersprachen gelernt, die im Design von FPGA-Algorithmen verwendet werden, die Schritte im FPGA-Entwicklungszyklus und die Abfolge der Schritte im FPGA-Entwicklungsprozess verstanden.

Das nächste Kapitel wird den FPGA-Entwicklungsprozess erweitern, um einen vollständigen Ansatz für die Architekturierung von Echtzeit-Eingebetteten Systemen mit FPGAs zu bieten. Es wird auch die Entwicklung eines Prototyps eines hochleistungsfähigen eingebetteten Systems, eines digitalen Oszilloskops, beginnen, das als Beispiel für die folgenden Kapitel dienen wird.

Nachdruck mit Genehmigung von Packt Publishing. Copyright © 2021 Packt Publishing

---

Jim Ledin ist CEO von Ledin Engineering, Inc. Jim ist Experte für eingebettete Software- und Hardware-Design, Entwicklung und Test. Er ist auch erfahren in eingebetteter System-Cybersicherheitsbewertung und Penetrationstests. Er hat einen B.S. in Luft- und Raumfahrttechnik von der Iowa State University und einen M.S. in Elektrotechnik und Informatik vom Georgia Institute of Technology. Jim ist registrierter professioneller Elektroingenieur in Kalifornien, Certified Information System Security Professional (CISSP), Certified Ethical Hacker (CEH) und Certified Penetration Tester (CPT).

---

Verwandte Inhalte:

• Eingebettetes Design mit FPGAs: Hardware-Ressourcen
• Eingebettetes Design mit FPGAs: Implementierungssprachen
• Eingebettetes Design mit FPGAs: Entwicklungsprozess
• Open-Source-Tools vereinfachen FPGA-Programmierung
• Implementierung von Floating-Point-Algorithmen in FPGAs oder ASICs
• FPGAs für Deep Learning nutzen
• Software-Tools migrieren GPU-Code auf FPGAs für KI-Anwendungen

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

Power over Ethernet (PoE) Grundlagen: DC-Stromversorgung über Datenkabel Automobil-MCU-Markt 2021 mit 23 % Wachstum auf 7,6 Mrd. $ trotz Lieferengpässen