FPGA:er i Arduino-världen: Använd Aloriums Snō-modul för både förkonfigurerad och anpassad IP

Fältprogrammerbara gatematriser (FPGA:er) ger ett sätt att lösa inbäddade designproblem i realtid med maskinvara när fast programvara som körs på en mikrostyrenhet eller en mikroprocessor skulle vara för långsam. De möjliggör även flexibel kringutrustning. Dock innebär användning av FPGA:er inlärning av nya programmeringsspråk (normalt Verilog eller VHDL), inlärning av ett helt nytt utvecklingsflöde för att generera FPGA-bitströmmar och möjligen att lägga en betydande mängd pengar på ett FPGA-utvecklingskort.

På grund av dessa hinder är många konstruktionstekniker tveksamma till att använda FPGA:er trots att de är ett mycket användbart verktyg i designverktygslådan. För att övervinna det här motståndet arbetar några leverantörer hårt med att förkorta inlärningskurvan för FPGA. Till exempel introducerade Arduino FPGA-utvecklingskortet Arduino ABX00022 MKR Vidor 4000 (se, "Tillämpa FPGA:er snabbt och enkelt med Arduino MKR Vidor 4000"). Arduino MKR Vidor 4000 lägger till ett sätt att programmera FPGA som är smidigt integrerat i den populära Arduino-integrerade utvecklingsmiljön (IDE) samtidigt som prestanda på FPGA-nivå uppnås med särskilda Arduino-bibliotekstillägg.

Nu finns ett nytt alternativ till de tidigare erbjudandena som innefattar Arduino MKR Vidor 4000-kortet. Alorium Technology har tagit fram ett något annorlunda sätt att lägga till FPGA-prestanda i den Arduino-inbäddade utvecklingsmiljön. Aloriums metod möjliggör både förkonfigurerade IP-block för I/O-acceleration samt skräddarsydda IP-block.

Den här artikeln går kortfattat igenom de traditionella sätten att använda FPGA:er. Den tar sedan en fördjupad titt på Aloriums Arduino-kompatibla XLR8R22M08V5U0DI och Snō SNOR20M16V3 FPGA-moduler. Artikeln visar hur Alorium har lagt till sin egen version av FPGA-användning i Arduino-området för både användning av förkonfigurerad IP och skapande av anpassad IP samt hur konstruktörer kan börja tillämpa FPGA-modulerna.

Hur du snabbar upp en Arduino

Hundratusentals konstruktörer, tekniker, utvecklare, hobbyanvändare och tillverkare runt om i världen använder nu olika versioner av Arduino-utvecklingskortserien för att utveckla inbäddade system för ett stort urval tillämpningar. Arduino-korten och Arduino IDE har blivit så populära för att de är väldigt enkla att använda och programmera.

I takt med att Arduino-användarna har fortsatt att ta den ursprungliga Arduino-arkitekturen till allt mer komplexa tillämpningar har de stött på prestandaproblem. En del av prestandaproblemen har varit den enkla 8-bitarsarkitekturen hos den ursprungliga Arduino-mikrostyrenheten. En annan del av problemet är hur Arduino-programvarusystemet implementerar många realtidskringenheter med programvara när Arduinos inbäddade mikrostyrenhet inte har ett motsvarande maskinvarublock.

Ett sätt att åtgärda det här prestandaproblemet är att använda kraftfullare mikrostyrenheter, men det programvara kan fortfarande bara åstadkomma begränsade resultat i en realtidsmiljö. Vissa höghastighets-, realtidskringenheter måste helt enkelt implementeras i maskinvara. Det är även möjligt att specificera mikrostyrenheter med maskinvarubaserad kringutrustning, men rätt blandning av kringutrustning varierar från projekt till projekt.

Mikrostyrenhetstillverkarna har hanterat behovet av olika kringutrustningskombinationer genom att erbjuda dussintals eller ibland till och med hundratals variationer i en mikrostyrenhetsfamilj. Dock är det inte en hållbar metod för kortnivåprodukter som Arduino på grund av behovet av kontakter på korten med tillräckliga I/O-stift för att uppfylla alla behov. Även om det nu finns många Arduino-kortvarianter räcker de inte för att uppfylla behoven i alla inbäddade projekt.

FPGA:er uppfyller behovet av en varierad kringutrustningsblandning

Genom att göra programmerbar maskinvara tillgänglig för inbäddningskonstruktören kan FPGA:er uppfylla behovet för en kringutrustningsblandning som varierar från projekt till projekt. Ett sätt att lägga till FPGA-funktion till ett inbäddad mikrostyrenhetskort är att helt enkelt lägga till en FPGA till en befintlig konstruktion. Det är den metod Arduino valde när de konstruerade Arduino MKR Vidor 4000-kortet. Kortet kombinerar Microchip Technologys 32-bitars Arm® Cortex®-M0+-baserad ATSAMD21G18A-AUT SAMD21 lågeffektmikrostyrenhet med Intels 10CL016YU484C6G Cyclone 10 FPGA.

Arduino har lagt till flera maskinvaru-IP-block till Arduino IDE specifikt för MKR Vidor 4000-kortet. Dessa kringenheter är tillgängliga till två huvudbibliotek: VidorPeripherals och VidorGraphics. Dessa maskinvaru-IP-blocks konstrueras automatiskt i Intel Cyclone 10 FPGA på Arduino MKR Vidor 4000 när det relevanta kringutrustningsbiblioteket ingår i en Arduino sketch – namnet som Arduino använder för ett program eller en kodenhet. Det aktuella utbudet av kringutrustnings-IP-block inkluderar:

• I²C-portar
• SPI-portar
• UART-enheter
• PWM-styrenheter med hög frekvens
• Höghastighetstimers
• Höghastighetskvadraturavkodare
• Adafruit Industries Neopixel adresserbar RGB smart LED-styrenhet

Några av dess kingenheter som I²C och SPI, fanns redan tillgängliga som programvaru-IP-block för tidigare Arduino-kort. Skillnaden mellan dessa tidigare programvaruimplementationer och motsvarande IP-block som implementerats på Arduino MKR Vidor 4000-kortets FPGA är att FPGA-versionerna an dessa kringenheter ger mycket bättre prestanda. Till exempel implementeras varje I²C- och SPI-instans med separata programmerbara maskinvarublock inuti kortets FPGA. Det innebär att det inte sker någon prestandaförlust vid användning av flera sådana serieportar.

Genom att implementera perifera block som FPGA-maskinvara och göra dem tillgängliga med samma biblioteksmekanism som redan är bekant för Arduino sketch-skrivare gör Arduino MKR Vidor 4000-kortet FPGA:er lätta att använda. Inget nytt maskinvarubeskrivningsspråk (HDL), som VHDL eller Verilog att lära sig. FPGA-baserade kringenheter ser ut som alla andra C++-objekt från programmerarens synvinkel. Arduino planerar att lägga till flera sådana maskinvaru-IP-block senare.

Arduino MKR Vidor 4000-kortet är inte ännu ett allmänt FPGA-utvecklingskort eftersom det saknar stöd för direkt programmering av det kortinterna Cyclone 10 FPGA med HDL-kod. Arduino planerar att tillåta mer avancerade användare att få ut mer av Arduino MKR Vidor 4000-kortets FPGA med Intels Quartus HDL-utvecklingsverktyg för företagets FPGA:er.

Alorium tar nästa steg

Alorium har redan tagit steget med sin OpenXLR8-metodik och Xcelerator Blocks (XBs) för sina Arduino-kompatibla XLR8R22M08V5U0DI- och SNOR20M16V3 Snō FPGA-utvecklingskort (figur 1 och figur 2). Båda korten baseras på olika versioner av Intel MAX 10 FPGA-familjen med integrerat flash-konfigurationsminne. XLR8 kombinerar Intel 10M08SAU169C8G MAX 10 med en 8-bitars mikrostyrenhet som är kompatibel med ATmega328-instruktioner. Den använder samma formfaktor som det ursprungliga Arduino Uno-utvecklingskortet, så den är kompatibel med de många Arduino-skärmningarna och tillbehören.

Figur 1: Alorium Technologys XLR8R22M08V5U0DI-utvecklingskort kombinerar en Intel MAX 10 FPGA med en 8-bit ATmega328 instruktionssatskompatibel styrenhet, allt i en Arduino Uno-formfaktor. (Bildkälla: Alorium Technology)

Alorium Snō FPGA-modulen är ett mycket mindre utvecklingskort på 0,7 x 1,7 tum, enligt figur 2. Trots att Snō FPGA-utvecklingskortet är fysiskt mindre integrerar det en större version av Intel MAX 10 FPGA med dubbelt så många logiska element: 16 k i en 10M16SAU169C8G MAX 10 FPGA jämfört med 8 k i 10M08-enheten på XLR8-kortet. Det har även fler än dubbelt så många I/O-stift (32 jämfört med 14 på XLR8-kortet).

Figur 2: Som XLR8-utvecklingskortet kombinerar Alorium Technologys Snō FPGA-utvecklingskort en 8-bitars ATmega328-instruktionssatskompatibel mikrostyrenhet med en Intel MAX 10 – i det här fallet är det 10M16SAU169C8G FPGA. Dock är Snō FPGA-utvecklingskortet mycket mindre. (Bildkälla: Alorium Technology)

Alorium erbjuder även SNOMAKRR10-breakout-kortet som har plats för en Snō FPGA-modul och omvandlar det till ett något överdimensionerat Arduino-formfaktorkort med USB-port och ytterligare I/O-utbrytningsstift från FPGA. Några av Snō FPGA-modulens stift är kopplade till SnōMAKR-breakout-kortets Arduino-kompatibla skärmningsstiftlister, medan andra är kopplade till en extra stiftlist längs kanten på kortet som sitter mittemot USB-uttaget (figur 3).

Figur 3: Aloriums SNOMAKRR10-breakout-kort omvandlar företagets Snō FPGA-utvecklingskort till en Arduino-kompatibel formfaktor med USB-uttag och en regulator på kortet så att USB-kabeln kan driva utvecklingskortet direkt. (Bildkälla: Alorium Technology)

Både XLR8- och Snō FPGA-utvecklingskortet implementerar 8-bitarsmikrostyrenheten och dess maskinvarukringutrustning på ett chip – ett Intel MAX 10 FPGA. Figur 4 visar hur detta åstadkoms.

Figur 4: Både XLR8- och Snō FPGA-utvecklingskortet implementerar den Atmel AVR-kompatibla mikrostyrenheten som en programvarubaserad kärna inuti MAX 10 FPGA. (Bildkälla: Alorium Technology)

Den AVR-kompatibla mikrostyrenhetskärnan (nere till vänster i figur 4) är samma Atmel ATmega328 8-bitars AVR-mikrostyrenhet som användes i de ursprungliga Arduino-utvecklingskorten. Istället för at sitta på ett separat chip implementeras dock Aloriums version av AVR-mikrostyrenheten som en programvarubaserad kärna i FPGA.

Fem Alorium XB:er (XB1 till XB5) visas över mikrostyrenhetskärnan i figur 4. XB-enheter är IP-block som implementeras med FPGA:ernas resurser på kortet. AVR-mikrostyrenheten kommunicerar med XB:erna på kortet via ett adresserbart registergränssnitt. XLR8- och Snō-utvecklingskortet levereras med förinstallerade XB:er (finns också på GitHub) som motsvarar kringutrustning som ofta behövs av Arduino-utvecklare inklusive:

• Kvadraturavkodning
• Servomotorkontroll
• NeoPixel RGB LED-kontroll
• Förbättrad, 12-bitars ADC
• Flytande punkt-beräkningar

Observera att den sista XB-enheten på listan ovan inte verkligen är ett I/O-periferiblock. Det är en accelerator med flytande punkt-beräkningar. XB-enheter kan vara en typ av maskinvaruaccelerator. De är inte begränsade till I/O.

Välj valfritt block

Både XLR8- och Snō FPGA-utvecklingskorten kan uppdateras i fältet genom att välja olika XB-enheter (eller flera kopior av samma XB) som ska instansieras i FPGA med Aloriums OpenXLR8-utvecklingsflöde. Utvecklare kan även skapa anpassade Xcelerator-block med Aloriums OpenXLR8-flöde (figur 5).

Figur 5: Aloriums OpenXLR8-utvecklingsflöde låter konstruktörerna skapa nya maskinvarublock med Intels Quartus Prime-designverktyg och lägga till dem till Arduino IDE. (Bildkälla: Alorium Technology)

Att skapa en anpassad XB kräver för närvarande kunskaper i Verilog- eller VHDL-maskinvaruspråken och bekantskap med Intel Quartus FPGA-verktygssviten – särskilt version 17.1 av Quartus Prime Lite Edition, och Mentor Graphics ModelSim-simuleringsverktyg. HDL:er är nödvändiga för FPGA-utveckling eftersom de gör det möjligt för konstruktören att uttrycka parallellt utförande av flera uppgifter på ett standardiserat, väldefinierat sätt. Högnivåspråk (HLL) som C och C++ är sekventiella språk.

HLL-kompilatorer tar HLL-källkod och översätter den till långa sekvenser av maskinanvisningar, som normalt körs en åt gången. Därför är FPGA:er mycket snabbare än processorer – FPGA:er kan köra tusentals uppgifter samtidigt, givet att det är en tillräckligt stor FPGA. Det finns HLL-kompilatorer som kan översätta kod som skrivits i C eller C++ till en HDL, som sedan behandlas av konventionella FPGA-verktyg, men dessa HLL-kompilatorer är för närvarande inte en del av Aloriums OpenXLR8-designflöde.

När en XB har utformats och felsökts med HDL- och FPGA-utvecklingsverktyg kan den användas i Arduino IDE som alla andra Arduino-biblioteksblock. Alorium utvecklar också för närvarande ytterligare XB:er för sina Arduino IDE-bibliotek.

Slutsats

Genom att skapa sina FPGA-utvecklingskort har både Arduino och Alorium Technology uppmärksammat konstruktörernas växande behov av mer inbäddad prestanda i de här kostnadseffektiva utvecklingskorten. Trots att de två företagen har tagit något olika vägar är de båda på väg mot samma slutmål: att hitta ett sätt att göra FPGA:er mer tillgängliga för fler utvecklare av inbäddad teknik. På den grundläggande nivån har både Arduino och Alorium gjort maskinvarukonstruktionen lika enkel som att välja block och köra skript.

För tillfället har det fullständiga konstruktionsflödet ännu inte blivit så enkelt som möjligt. Arduino har inte öppnat sitt fullständiga FPGA-utvecklingsflöde för HDL-utvecklare än. Aloriums designflöde tillåter HDL-design, men det kräver kunskap om FPGA-designspråken Verilog eller VHSL och förknippade verktyg.

Dock har dörren öppnats av dessa produkter, så det är åtminstone teoretiskt möjligt att dra nytta av andra framsteg inom FPGA-utvecklingen, inklusive C- och C++-baserade maskinvarukompilatorer. Under tiden är det möjligt att extrahera en del av FPGA:s kapacitet med de enkla metoder som Alorium Technology och Arduino har utvecklat för att lägga till dessa förmågor till Arduino IDE.