FPGA Embedded Ontwerp Beheersen: Een Praktische Implementatiegids

De beschikbaarheid van krachtigere FPGA's en effectievere programmeeromgevingen heeft FPGA-implementatie breed toegankelijk gemaakt, maar het gebruik van FPGA's kan intimidierend lijken.

Opmerking van de redacteur: Naarmate geavanceerde algoritmen voortkomen voor slimme productontwerpen, worstelen ontwikkelaars vaak met het implementeren van embedded systemen die de bijbehorende verwerkingsvereisten kunnen halen. FPGA's kunnen de vereiste prestaties leveren, maar ontwerpen met FPGA's is lang beschouwd als beperkt tot het domein van FPGA-programmeerexperts. Vandaag de dag heeft de beschikbaarheid van krachtigere FPGA's en effectievere ontwikkelomgevingen FPGA-ontwikkeling breed toegankelijk gemaakt. In dit fragment, Hoofdstuk 4 uit het boek Architecting High-Performance Embedded Systems, biedt de auteur een uitgebreide review van FPGA-apparaten, implementatietalen en het FPGA-ontwikkelproces alsook een gedetailleerde walkthrough van hoe u aan de slag kunt met het implementeren van FPGA's in uw eigen ontwerp. Het complete fragment wordt gepresenteerd in de volgende reeks afleveringen:

• 1: Hardwarebronnen
• 2: Implementatietalen
• 3: Ontwikkelproces
• 4: Een project bouwen
• 5: Implementatie (dit artikel)

Geaccepteerd vanuit Architecting High-Performance Embedded Systems, door Jim Ledin.

De logica-gedrag testen

Het is belangrijk om het gedrag van logica te testen met simulatie voordat u probeert het in de FPGA te draaien. Dit is omdat het veel makkelijker is om problemen in de simulatieomgeving te detecteren en op te lossen dan met de logica die binnen de FPGA draait. De Vivado-simulatietools doen een uitstekende job bij het representeren van circuitgedrag:

1. In het Sources sub-venster, rechtsklik op Simulation Sources en selecteer Add Sources…:

Figuur 4.18 – Add Sources… menu selectie voor Simulation Sources

2. In het Add Sources dialoog, zorg dat Add or create simulation sources geselecteerd is, klik dan op Next.
3. In het Add or Create Simulation Sources dialoog, klik op Create File.
4. Voer de bestandsnaam vhdl in en klik op OK.
5. Klik op Finish om het Add or Create Simulation Sources dialoog te sluiten, klik dan op OK in het Define Module dialoog en klik op Yes wanneer gevraagd of u zeker bent dat u deze wilt gebruiken.
6. Dubbelklik op Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) onder Simulation Sources. Verwijder de automatisch ingevulde inhoud van de vhdl editor-venster en voer de volgende code in de Adder4TestBench.vhdl editor in:

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 alle combinaties van twee 4-bit optelgetallen (256 totale tests)     for a_val in 0 to 15 loop       for b_val in 0 to 15 loop         -- Stel de invoeren in voor het 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;         -- Bereken de 5-bit som van de twee 4-bit waarden         expected_sum5 <= unsigned('0' & a) + unsigned('0' & b);         wait for 1 ns;         -- Splits de som in een 4-bit uitgang en een carry-bit         expected_sum4 <= expected_sum5(3 downto 0);         expected_c    <= expected_sum5(4);         wait for 1 ns;         -- Het 'error' signaal gaat alleen naar 1 als er een fout optreedt         if ((unsigned(s) = unsigned(expected_sum4)) and             (c_out = expected_c)) then           error <= '0';         else           error <= '1';         end if;         -- Elke doorloop van de inner lus duurt 10 ns         wait for 7 ns;       end loop;     end loop;     wait;   end process TEST; end architecture BEHAVIORAL;

Deze code oefent de 4-bit optelfunctionaliteit door alle combinaties van 4-bit getallen aan elk van de A4 en B4 ingangen van het Adder4 component te presenteren. Het vergelijkt de SUM4 en C_OUT4 uitgangen van het Adder4 component met onafhankelijk berekende waarden voor dezelfde invoeren. Na elke opteloperatie wordt het error signaal op 0 gezet als de Adder4 uitgangen overeenkwamen met de verwachte waarden, of op 1 als er een mismatch is.

De code in Adder4TestBench.vhdl lijkt op traditionele softwarecode in de manier waarop geneste for-lussen alle test-invoerv combinaties toepassen op het Adder4 component onder test. Code die in simulatiemodus draait is non-synthesizable, wat betekent dat het niet puur een hardware-logicacircuit vertegenwoordigt en capabel is van traditionele software-achtige operaties, zoals de iteratieve uitvoering van for lussen.

Echter, net als in fysieke circuits, kunnen signalen die waarden toegewezen krijgen in de testbench-code met de <= operator niet op hetzelfde moment in tijd gebruikt worden in opvolgende expressies. Dit is omdat de simulatieomgeving de real-world effecten van propagatievertraging vertegenwoordigt, wat significant is zelfs binnen kleine FPGA-apparaten. De drie wait for 1 ns; statements in de testbench-code pauzeren circuitoperaties om propagatievertraging toe te laten. Deze 1 ns vertragingen voorzien tijd voor de signaalwaarden die net voor de wait statement berekend zijn om te propageren zodat ze gebruikt kunnen worden in de volgende statement. De laatste wait for 7 ns; statement in de inner lus is een pauze die ons laat duidelijk de resultaten zien van elke iteratie van de simulatie-lussen in de signaaltrace-weergave.

7. Rechtsklik Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) onder Simulation Sources en selecteer Automatic Update and Compile Order. Dit stelt ADDER4_TESTBENCH in als het top-level object voor de simulatie-run:

Figuur 4.19 – Menu selectie om Automatic Update and Compile Order in te stellen

8. Klik op Run Simulation, dan Run Behavioral Simulation in het Flow Navigator venster om simulatiemodus te betreden. Als u de editor-bestanden nog niet opgeslagen heeft, wordt u gevraagd dit te doen. Klik op Save. De simulatie zal dan draaien:

Figuur 4.20 – Run Behavioral Simulation menu selectie

9. Wanneer het SIMULATION venster opent, klik op de maximizeer-knop in het simulatie-uitvoervenster met de titel Untitled 1:

Figuur 4.21 – Simulatie resultaten venster

De totale gesimuleerde tijd van elke doorloop van de inner lus is 10 ns. Omdat er 256 doorlopen zijn door de lus in Adder4TestBench.vhdl, is de tijd om de simulatie te draaien 2560 ns.

10. Stel de simulatie-looptijd in op 2560 ns in de bovenste toolbar (stap 1 in de volgende figuur), druk op de linkse herstartknop (stap 2), druk dan op de rechtse knop om de simulatie te draaien voor 2560 ns (stap 3), en tenslotte druk op de Zoom Fit knop (stap 4) om het simulatie-uitvoerdatabereik te schalen om in het venster te passen:

Figuur 4.22 – Simulatieresultaten van start tot einde van de run

U kunt de vergrootglas-iconen gebruiken om in te zoomen op elk punt van de trace en de resultaten te observeren van elke opteloperatie die tijdens testen uitgevoerd werd. Bijvoorbeeld, de volgende figuur toont de decimale waarden 6 en 2 werden opgeteld om het resultaat 8 met een carry van 0 te produceren. Deze waarden komen overeen met de verwachte waarden, wat ervoor zorgde dat error op 0 gezet werd. Het error signaal is 0 voor alle 256 testgevallen, wat aangeeft dat ons logica-circuit alle tests doorstond:

Figuur 4.23 – Ingezoomd overzicht van de simulatie resultaten

11. Sluit simulatiemodus door op de X in de blauwe SIMULATION balk boven de datatrace te klikken. Klik op OK wanneer gevraagd of u de simulatie wilt sluiten.

Na het doorstaan van behaviorale testen, zullen we de I/O-signalen definiëren die in het ontwerp gebruikt worden.

I/O-signalen definiëren

Onze volgende stap is de in- en uitgangen van ons circuit te verbinden met hardware-apparaten op het Arty-board. De invoeren zullen de board-schakelaars en drukknoppen zijn, en de uitgangen zullen LED's zijn.

De volgende stappen creëren een constraints-bestand dat de I/O-pinnen beschrijft die we op het FPGA-apparaat zullen gebruiken en de functies die aan die pinnen op het Arty-board zijn verbonden. Constraints-bestanden hebben de xdc-extensie:

1. In het Sources sub-venster, rechtsklik Constraints en selecteer Add Sources….
2. In het Add Sources dialoog, zorg dat Add or create constraints geselecteerd is, klik dan op Next.
3. In het Add or Create Constraints dialoog, klik op Create File.
4. Voer de bestandsnaam Arty-A7-100.xdc in (of Arty-A7-35.xdc als passend voor uw apparaat) en klik op OK.
5. Klik op Finish om het Add or Create Constraints dialoog te sluiten.
6. Vouw de Constraints bronnenboom uit en dubbelklik op Arty-A7-35.xdc.
7. Digilent levert vooraf ingevulde constraints-bestanden voor de Arty A7-boards. Bezoek https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-35-Master.xdc en kopieer de gehele inhoud van het browservenster in het Arty-A7-35.xdc editor-venster in Vivado. Als passend voor uw apparaat, gebruik het bestand op https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-100-Master.xdc in plaats daarvan.
8. Alle I/O-pinnen zijn in het constraints-bestand gecommentarieerd door het # teken aan het begin van elke regel. Uncomment de juiste regels in het bestand door het # teken aan het begin van elke regel te verwijderen. We zullen de pinnen gebruiken die in de volgende secties in het Arty-A7-100.xdc bestand gelist zijn: Switches, RGB LEDs (maar alleen led0_g, de eerste groene LED), LEDs, en Buttons. De volgende figuur toont deze regels nadat ze ge-uncomment zijn:

Figuur 4.24 – Constraints editor venster

In de volgende sectie zullen we een top-level VHDL-bestand creëren dat de adder-code interfaceert met de I/O-apparaten.

Een top-level VHDL-bestand creëren

We zullen nu een top-level VHDL-bestand creëren dat ons 4-bit adder-component verbindt met de bijbehorende board I/O-signalen:

1. In het Sources sub-venster, rechtsklik op Design Sources en selecteer Add Sources….
2. In het Add Sources dialoog, zorg dat Add or create design sources geselecteerd is, klik dan op Next.
3. In het Add or Create Design Sources dialoog, klik op Create File.
4. Voer de bestandsnaam vhdl in en klik op OK.
5. Klik op Finish om het Add or Create Design Sources dialoog te sluiten, klik dan op OK in het Define Module dialoog en klik op Yes wanneer gevraagd of u zeker bent dat u deze wilt gebruiken.
6. Dubbelklik op vhdl onder Design Sources. Verwijder de automatisch ingevulde inhoud van de ArtyAdder.vhdl editor-venster en voer de volgende code in de ArtyAdder.vhdl editor in:

-- Laad de standaardbibliotheken 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 -- Referentie de vorige definitie van het 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;

Deze code mapt de signaalnamen voor de I/O-apparaten genoemd in Arty-A7-100.xdc als sw (4 schakelaars), btn (4 drukknoppen), led (4 enkleurige LED's), en led0_g (de groene kanaal van de eerste multi-kleur LED) naar de ADDER4 in- en uitgangen.

Hoewel VHDL niet case-gevoelig is, is de verwerking van xdc constraints-bestanden in Vivado case-gevoelig. De case gebruikt in I/O-apparaatnamen gedefinieerd in het xdc bestand moet identiek zijn wanneer gerefereerd in een VHDL-bestand. Specifiek, de I/O-signaalnamen in VHDL moeten lowercase zijn in dit bestand omdat ze lowercase zijn in het constraints-bestand.

We zijn nu klaar om ons ontwerp te synthetiseren, implementeren en programmeren voor het Arty-board.

De FPGA-bitstream synthetiseren en implementeren

Alternatief kunt u Generate Bitstream selecteren en Vivado zal alle vereiste stappen uitvoeren, inclusief synthetisatie, implementatie en bitstream-generatie zonder verdere gebruikersinterventie. Als een fatale fout optreedt, stopt het proces en worden foutmeldingen getoond. Voer de volgende stappen uit om de bitstream te genereren:

1. Klik op Generate Bitstream om de build te starten. U kunt gevraagd worden of u de teksteditors wilt opslaan. Klik op Save. U kunt geïnformeerd worden dat er geen implementatieresultaten beschikbaar zijn en gevraagd of het OK is om synthetisatie en implementatie te lanceren. Klik op Yes:

Figuur 4.25 – Generate Bitstream menu selectie

2. Het Launch Runs dialoog verschijnt dan. U kunt een waarde selecteren voor Number of jobs tot het aantal processorkernen in uw computer. Meer kernen maken het proces sneller, maar het kan uw machine vertragen als u wilt doorgaan met gebruiken tijdens een lange build. Klik op OK om de build te starten:

Figuur 4.26 – Launch Runs dialoog

3. Tijdens het build-proces toont Vivado de status in de rechterbovenhoek van het hoofdvenster. Indien nodig, kunt u het build-proces annuleren door op Cancel naast de statusweergave te klikken:

Figuur 4.27 – Compilatiestatus weergave

4. Wanneer het build-proces compleet is, assummerende er geen fatale fouten waren, verschijnt een Bitstream Generation Completed dialoog. Hoewel andere opties aangeboden worden, zullen we direct doorgaan met het downloaden van de bitstream naar het Arty-board. Selecteer Open Hardware Manager en klik op OK:

Figuur 4.28 – Bitstream Generation Completed dialoog

Vervolgens zullen we de bitstream in de FPGA downloaden.

De bitstream naar het board downloaden

Voer de volgende stappen uit om de bitstream naar een Arty A7-board te downloaden:

1. Het HARDWARE MANAGER dialoog verschijnt en geeft No hardware target is open aan.
2. Verbind uw Arty A7-35 of A7-100 board met de computer via USB. Wacht een paar seconden voor het board herkend wordt, klik dan op Open target, dan Auto Connect:

Figuur 4.29 – Open target en Auto Connect selecties

3. Na een paar seconden moet Vivado aangeven dat het board verbonden is. Klik op Program device om de FPGA-bitstream naar het Arty-board te downloaden. U wordt gevraagd een bitstream-bestand te selecteren. Als u dezelfde directory-structuur als dit voorbeeld gebruikt, bevindt het bestand zich op C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bit:

Figuur 4.30 – Program Device dialoog

4. Klik op Program om het programma naar het FPGA-apparaat te downloaden en te starten.
5. U kunt nu de werking van het programma testen met de Arty I/O. Zet alle vier schakelaars in de uit positie (beweeg de schakelaars naar de aangrenzende boardrand) en druk op geen van de vier drukknoppen. Alle vier groene LED's zouden uit moeten zijn.
6. Als u een individuele schakelaar inschakelt of een drukknop indrukt, zou de corresponderende groene LED aan moeten gaan. Het inschakelen van elke combinatie van schakelaars terwijl u een willekeurig aantal drukknoppen indrukt, zal de corresponderende 4-bit getallen optellen en de LED's laten branden met het resultaat. Als er een carry is (bijvoorbeeld, schakel SW3 in en druk BTN3 tegelijkertijd), zal de groene carry LED oplichten.

Het programmeerproces dat hier uitgevoerd werd, slaat het programma op in FPGA-RAM. Als u de voeding van het FPGA-board cycelt, moet u het programmeerproces herhalen om het programma opnieuw te laden. Alternatief kunt u het FPGA-configuratiebestand in onboard flash-geheugen opslaan zoals beschreven in de volgende sectie.

De bitstream programmeren naar onboard flash-geheugen

Om de FPGA telkens te configureren wanneer spanning aan het Arty-board wordt aangeleverd, moet het FPGA-configuratiebestand opgeslagen worden in flash-geheugen op het board. Als de MODE-jumper geïnstalleerd is, zal de FPGA proberen een configuratiebestand van onboard flash-geheugen te downloaden bij power-on. Dit geheugen bevindt zich in een aparte chip naast de Artix-7 FPGA. Volg deze stappen om het configuratiebestand naar flash-geheugen te programmeren:

1. Installeer de MODE jumper op het Arty-board als deze nog niet zit.
2. Rechtsklik Generate Bitstream en selecteer Bitstream Settings….
3. In het Settings dialoog, vink het vakje naast -bin_file aan en klik op OK:

Figuur 4.31 – Bitstream settings dialoog

4. In de hoofd-Vivado-dialoog, klik op Generate Bitstream en herhaal het bitstream-generatieproces. Klik op Cancel wanneer het Bitstream Generation Completed dialoog verschijnt.

5. In het Hardware dialoog, rechtsklik het FPGA-deelnummer (xc7a100t_0) en selecteer Add Configuration Memory Device…:

Figuur 4.32 – Add Configuration Memory Device… menu selectie

6. Typ s25fl127 in het Search veld. Dit zou één matchend deelnummer moeten opleveren. Selecteer het deel en klik op OK:

Figuur 4.33 – Add Configuration Memory Device dialoog

7. U krijgt een dialoog te zien met de vraag Do you want to program the configuration memory device now? Klik op OK.
8. Dit opent een Program Configuration Memory Device dialoog die de configuratiebestandsnaam vraagt. Klik op de … knop rechts van Configuration file en selecteer C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bin. Klik op OK:

Figuur 4.34 – Program Configuration Memory Device dialoog

9. Het programmeerproces duurt enkele seconden. U moet een succesbericht ontvangen nadat het bestand in het board flash-geheugen geprogrammeerd is:

Figuur 4.35 – Program Flash complete dialoog

Hierna zal telkens u de board-voeding cycelt, het 4-bit adder-programma laden en draaien. Het duurt lang voordat het programma laadt met de instellingen die we voor configuratiebestandsladen gebruikten. Om te wachten op het laden van het programma door de FPGA te vermijden, kunt u de snelheid van configuratiebestandsladen verbeteren door de volgende stappen uit te voeren:

1. Selecteer Open Synthesized Design in Flow Navigator.
2. In het Vivado-hoofdmenu, selecteer Tools/Edit Device Properties….
3. In het General tabblad, zet Enable Bitstream Compression op TRUE.
4. In het Configuration tabblad, zet Configuration Rate (MHz) op 33, klik dan op OK.
5. Genereer de bitstream opnieuw, en programmeer het flash-geheugen zoals beschreven. U moet het configuratiegeheugendevice verwijderen en opnieuw toevoegen om de optie voor herprogrammering te tonen.
6. Sluit Hardware Manager.
7. Trek de Arty-board USB-kabel eruit en steek hem weer in. Het programma zou bij power-on virtueel direct moeten beginnen te draaien.

Deze sectie presenteerde een voorbeeld van eenvoudige combinatorische logica die interacteert met signalen op de FPGA I/O-pinnen. De bedoeling was u vertrouwd te maken met de Vivado-toolsuite en te demonstreren hoe de tools gebruikt worden om een complete FPGA-ontwikkelcyclus uit te voeren.

Samenvatting

Dit hoofdstuk begon met een discussie over het effectieve gebruik van FPGA's in real-time embedded systeemarchitecturen en vervolgde met een beschrijving van standaard FPGA-apparaten en de laag-niveau componenten die ze bevatten. De reeks FPGA-ontwerptalen, inclusief HDL's, blokdiagram-methoden en populaire software-programmeertalen zoals C/C++, werd geïntroduceerd. Een overzicht van het FPGA-ontwikkelproces werd gepresenteerd. Het hoofdstuk concludeerde met een compleet voorbeeld van een FPGA-ontwikkelcyclus, beginnend met een vereistenstelling en eindigend met een functioneel systeem geïmplementeerd op een laagkost FPGA-ontwikkelbord.

Na voltooiing van dit hoofdstuk, zou u moeten weten hoe FPGA's effectief toegepast kunnen worden in real-time embedded systeemarchitecturen en de componenten binnen een FPGA-geïntegreerde circuit begrijpen. U heeft geleerd over de programmeertalen gebruikt in het ontwerp van FPGA-algoritmen, de stappen in de FPGA-ontwikkelcyclus, en de volgorde van stappen in het FPGA-ontwikkelproces begrepen.

Het volgende hoofdstuk zal het FPGA-ontwikkelproces uitbreiden om een complete aanpak te bieden voor het architecten van real-time embedded systemen met FPGA's. Het zal ook de ontwikkeling beginnen van een prototype high-performance embedded systeem, een digitale oscilloscoop, dat zal dienen als voorbeeld voor de volgende hoofdstukken.

Herprinted met toestemming van Packt Publishing. Copyright © 2021 Packt Publishing

Gerelateerde Inhoud

• Embedded ontwerp met FPGA's: Hardwarebronnen
• Embedded ontwerp met FPGA's: Implementatietalen
• Embedded ontwerp met FPGA's: Ontwikkelproces
• Open-source tools helpen FPGA-programmering vereenvoudigen
• Drijvende-komma algoritmen implementeren in FPGA's of ASICs
• FPGA's benutten voor deep learning
• Software-tools migreren GPU-code naar FPGA's voor AI-toepassingen

Voor meer Embedded, abonneer u op de wekelijkse e-mailnieuwsbrief van Embedded.