FPGAs in der Arduino-Welt: Einsatz des Snō-Moduls von Alorium für vorkonfigurierte und kundenspezifische IP

Field Programmable Gate Arrays (FPGAs) ermöglichen es, Probleme mit der Hardware bei Echtzeit-Embedded-Designs zu lösen, wenn die Firmware, die auf einem Mikrocontroller oder Mikroprozessor läuft, zu langsam wäre. Außerdem bieten sie eine größere Flexibilität bei den Peripheriegeräten. Bisher bedeutete der Einsatz von FPGAs allerdings, dass es notwendig war, neue Programmiersprachen (meist Verilog oder VHDL) zu lernen, sich mit einem völlig neuen Entwicklungsfluss zur Erzeugung von FPGA-Bitströmen vertraut zu machen und möglicherweise viel Geld für eine FPGA-Entwicklungskarte auf den Tisch zu legen.

Aufgrund dieser Hindernisse sind viele Entwickler nicht bereit, FPGAs zu nutzen, obwohl sie bei der Entwicklung ein sehr hilfreiches Tool sind. Um diesen Widerstand zu überwinden, suchen einige Anbieter unter Hochdruck nach Möglichkeiten, um die FPGA-Lernkurve zu verkürzen. So hat beispielsweise Arduino die Arduino-FPGA-Entwicklungskarte ABX00022 MKR Vidor 4000 auf den Markt gebracht (siehe „Mit dem Arduino-Board MKR Vidor 4000 schnell und einfach FPGAs nutzen“). Das Arduino-Board MKR Vidor 4000 bietet einen neuen Weg zur Programmierung des FPGA, der sich nahtlos in die äußerst beliebte Integrierte Entwicklungsumgebung (IDE) von Arduino einfügt, wobei man durch spezielle Bibliothekserweiterungen von Arduino die Leistung eines FPGA erhält.

Jetzt gibt es eine neue Alternative zu den bisherigen Angeboten, zu denen auch das Arduino-Board MKR Vidor 4000 zählt. Alorium Technology hat einen etwas anderen Weg entwickelt, um die Leistung eines FPGA in die Welt der Embedded-Entwicklung von Arduino einzubringen. Der Ansatz von Alorium umfasst sowohl vorkonfigurierte IP-Blöcke für die I/O-Beschleunigung als auch individuelle IP-Blöcke.

In diesem Artikel soll kurz dargestellt werden, was für die Nutzung von FPGAs bisher notwendig war. Im Anschluss werden die Arduino-kompatiblen FPGA-Module XLR8R22M08V5U0DI und Snō SNOR20M16V3 von Alorium detailliert betrachtet. Der Artikel soll zeigen, wie Alorium seinen eigenen Dreh gefunden hat, um FPGAs im Arduino-Kontinuum zu nutzen, und zwar für den Einsatz vorkonfigurierter IP und die Erstellung individueller IP, und wie Entwickler in die Nutzung von FPGA-Modulen einsteigen können.

Beschleunigung eines Arduino

Hunderttausende Designer, Ingenieure, Entwickler, Hobbyelektroniker und Maker rund um die Welt nutzen mittlerweile verschiedene Versionen von Arduino-Entwicklungskarten, um Embedded-Systeme für die unterschiedlichsten Anwendungen zu entwickeln. Die Arduino-Karten und die Arduino-IDE sind so beliebt, weil sie benutzerfreundlich und leicht zu programmieren sind.

Als die Arduino-Nutzer jedoch begannen, die originale Arduino-Architektur für immer komplexere Anwendungen zu nutzen, hatten sie mit Leistungseinbußen zu kämpfen. Ein Teil dieser Leistungseinbußen ist auf die einfache 8-Bit-Architektur des originalen Arduino-Mikrocontrollers zurückzuführen. Ein weiterer Teil des Problems ist die Art, wie das Arduino-Softwaresystem viele Echtzeit-Peripheriegeräte über Software einbindet, obwohl der eingebettete Mikrocontroller von Arduino keinen entsprechenden Hardware-Block besitzt.

Eine Möglichkeit zur Überwindung der Leistungseinbußen besteht darin, stärkere Mikrocontroller einzusetzen, doch in einer Echtzeitumgebung sind die Einsatzmöglichkeiten von Software nun einmal begrenzt. Einige in Echtzeit arbeitende Hochgeschwindigkeitsgeräte müssen einfach in der Hardware implementiert sein. Es besteht auch die Möglichkeit, die Mikrocontroller mit einer umfangreicheren Peripherie-Hardware auszustatten, doch die geeignete Kombination an Peripheriegeräten ist von Projekt zu Projekt verschieden.

Die Hersteller von Mikrocontrollern gehen auf den Bedarf an unterschiedlichen Kombinationen von Peripheriegeräten ein, indem sie Dutzende oder in manchen Fällen sogar Hunderte Variationen einer Mikroprozessor-Familie anbieten. Das ist jedoch kein gangbarer Weg für Entwicklungskarten wie die von Arduino, da die Karten Anschlüsse mit einer ausreichenden Anzahl an I/O-Pins haben müssen, um alle Anforderungen zu erfüllen. Obwohl es inzwischen bereits zahlreiche Varianten des Arduino-Boards gibt, reichen sie immer noch nicht aus, um bei jedem Embedded-Projekt die Anforderungen zu erfüllen.

FPGAs bieten die Möglichkeiten für unterschiedliche Kombinationen von Peripheriegeräten

FPGAs stellen dem Embedded-Entwickler programmierbare Hardware zur Verfügung und erfüllen damit die Anforderungen an verschiedene, projektabhängige Kombinationen von Peripheriegeräten. Um eine Entwicklungskarte mit einem eingebetteten Mikrocontroller mit FPGA-Funktionalität auszustatten, besteht eine Möglichkeit darin, ein bestehendes Design einfach um ein FPGA zu ergänzen. Genau diesen Ansatz hat Arduino gewählt, als das Unternehmen das Arduino-Board MKR Vidor 4000 entwickelt hat. Das Board verbindet den 32-Bit-Arm®-Cortex®-M0+-basierten energiesparenden SAMD21-Mikrocontroller ATSAMD21G18A-AUT von Microchip Technology mit dem Cyclone-10-FPGA 10CL016YU484C6G von Intel.

Arduino hat die Arduino-IDE speziell für das Board MKR Vidor 4000 um mehrere Hardware-IP-Blöcke erweitert. Die Peripheriegeräte sind über zwei Hauptbibliotheken verfügbar: VidorPeripherals und VidorGraphics. Die Hardware-IP-Blöcke sind automatisch in das Cyclone 10 FPGA von Intel eingebaut, das auf dem Arduino MKR Vidor 4000 vorhanden ist, wobei die entsprechende Peripheriegeräte-Bibliothek in einem Sketch von Arduino enthalten ist (Arduino nennt ein Programm oder eine Code-Einheit „Sketch“). Die aktuelle Liste der IP-Blöcke für Peripheriegeräte umfasst:

• I²C-Ports
• SPI-Ports
• UARTs
• Hochfrequenz-PWM-Controller
• Hochgeschwindigkeits-Timer
• Sehr schnelle Quadraturdecoder
• Über Neopixel von Adafruit Industries adressierbarer RGB- und intelligenter LED-Controller

Einige dieser Peripheriegeräte wie I²C und SPI waren bereits für die bisherigen Arduino-Boards als Software-IP-Blöcke erhältlich. Der Unterschied zwischen den bisherigen Software-Implementierungen und den entsprechenden IP-Blöcken, die auf dem FPGA des Arduino-Boards MKR Vidor 4000 implementiert sind, besteht darin, dass die FPGA-Versionen der Geräte eine wesentlich bessere Leistung bieten. So ist jede I²C- und SPI-Instanziierung mit separaten programmierbaren Hardware-Blöcken im FPGA des Boards implementiert. In der Folge gibt es keine Leistungseinbußen, wenn mehrere serielle Ports instanziiert werden.

Durch die Implementierung von Peripheriegeräte-Blöcken als FPGA-Hardware und den Zugriff über die Bibliotheksmechanismen, die den Sketch-Schreibern von Arduino bereits bekannt sind, ist das FPGA auf dem Arduino-Board MKR Vidor 4000 einfach zu nutzen. Es muss keine neue Hardwarebeschreibungssprache (HDL) wie VHDL oder Verilog erlernt werden. Ganz im Gegenteil, die FPGA-basierten Peripheriegeräte sehen für den Programmierer genauso aus wie jedes andere C++-Objekt. Arduino möchte später noch weitere Hardware-IP-Blöcke für Peripheriegeräte hinzufügen.

Derzeit ist das Arduino-Board MKR Vidor 4000 noch keine allgemeine FPGA-Entwicklungskarte, da die Unterstützung für die direkte Programmierung des Cyclone 10 FPGA auf der Karte über HDL-Code fehlt. Arduino möchte fortgeschrittenen Anwendern in Zukunft erlauben, einen größeren Nutzen aus dem FPGA des Arduino-Boards MKR Vidor 4000 zu ziehen, und zwar mit Hilfe des Quartus HDL-Entwicklungstools von Intel für die FPGAs des Unternehmens.

Alorium geht einen Schritt weiter

Mit seinem OpenXLR8-Verfahren und den Xcelerator Blocks (XBs) für seine Arduino-kompatiblen FPGA-Entwicklungskarten XLR8R22M08V5U0DI und SNOR20M16V3 Snō (Abbildung 1 bzw. Abbildung 2) ist Alorium diesen Schritt bereits gegangen. Die beiden Karten basieren auf verschiedenen Versionen der FPGA-Familie MAX 10 mit integriertem Flash-Konfigurationsspeicher von Intel. XLR8 verbindet den MAX 10 10M08SAU169C8G von Intel mit einem mit ATmega328 befehlskompatiblem 8-Bit-Mikrocontroller. Der Formfaktor ist derselbe wie bei der originalen Entwicklungskarte Arduino Uno, daher ist sie mit den zahlreichen Shields und dem Zubehör von Arduino kompatibel.

Abbildung 1: Die Entwicklungskarte XLR8R22M08V5U0DI von Alorium Technology verbindet einen MAX-10-FPGA von Intel mit einem mit ATmega328 befehlskompatiblem 8-Bit-Mikrocontroller, alles im Formfaktor des Arduino Uno. (Bildquelle: Alorium Technology)

Das Snō FPGA-Modul von Alorium ist eine wesentlich kleinere Entwicklungskarte mit den Maßen 0,7 x 1,7 Zoll, wie in Abbildung 2 dargestellt. Obwohl die Snō-FPGA-Entwicklungskarte äußerlich kleiner ist, enthält sie eine größere Version des MAX-10-FPGA von Intel mit doppelt so vielen logischen Elementen: 16 K bei einem MAX-10-FPGA 10M16SAU169C8G gegenüber 8 K für die 10M08-Komponente auf der XLR8-Karte. Außerdem verfügt sie über mehr als doppelt so viele I/O-Pins (32 im Gegensatz zu 14 bei der XLR8-Karte).

Abbildung 2: Genauso wie die XLR8-Entwicklungskarte verbindet die Snō-FPGA-Entwicklungskarte von Alorium Technology einen mit ATmega328 befehlskompatiblen 8-Bit-Mikrocontroller mit einem MAX 10 von Intel – in diesem Fall dem FPGA 10M16SAU169C8G. Allerdings ist die Snō-FPGA-Entwicklungskarte wesentlich kleiner. (Bildquelle: Alorium Technology)

Darüber hinaus bietet Alorium auch die Breakout-Karte SNOMAKRR10 an, die ein Snō-FPGA-Modul aufnehmen kann und dadurch zu einer leicht überdimensionalen Karte im Arduino-Formfaktor wird, mit einem USB-Port und zusätzlichen I/O-Breakout-Pins vom FPGA. Einige Pins des Snō-FPGA-Moduls führen zu den Arduino-kompatiblen Shield-Anschlüssen auf der Breakout-Karte SnōMAKR, andere führen zu einer weiteren Steckleiste am Rand der Karte gegenüber dem USB-Anschluss (Abbildung 3).

Abbildung 3: Die Breakout-Karte SNOMAKRR10 von Alorium verwandelt die Snō-FPGA-Entwicklungskarte der gleichen Firma in einen Arduino-kompatiblen Formfaktor mit einem USB-Port und einem Onboard-Regler, so dass die Entwicklungskarte direkt über das USB-Kabel betrieben werden kann. (Bildquelle: Alorium Technology)

Die beiden FPGA-Entwicklungskarten XLR8 und Snō implementieren den 8-Bit-Mikrocontroller und seine Peripherie-Hardware in einem Chip – einem FPGA MAX 10 von Intel. Wie das umgesetzt wird, ist in Abbildung 4 zu sehen.

Abbildung 4: Die beiden FPGA-Entwicklungskarten XLR8 und Snō implementieren den mit Atmel AVR kompatiblen Mikrocontroller als Softcore im MAX-10-FPGA. (Bildquelle: Alorium Technology)

Der AVR-kompatible Mikrocontroller-Kern (unten links in Abbildung 4) ist der gleiche 8-Bit-AVR-Mikrocontroller ATmega328 von Atmel, der bei den originalen Arduino-Entwicklungskarten zum Einsatz kommt. Anstatt jedoch auf einem separaten Chip zu sitzen, ist der AVR-Mikrocontroller bei Alorium als Softcore im FPGA implementiert.

Über dem Mikrocontroller-Kern in Abbildung 4 sind fünf XBs von Alorium (XB1 bis XB5) zu sehen. XBs sind IP-Blöcke, die mit Hilfe der auf dem Chip des FPGA vorhandenen Ressourcen implementiert sind. Der AVR-Mikrocontroller kommuniziert mit den XBs auf dem Chip über eine adressierbare Registerschnittstelle. Die Entwicklungskarten XLR8 und Snō werden mit vorinstallierten XBs geliefert (auch auf GitHub verfügbar), die zu den von Arduino-Entwicklern häufig benötigten Peripheriegeräten passen, insbesondere:

• Quadratur-Dekodierung
• Servomotorsteuerung
• NeoPixel-RGB-LED-Steuerung
• verbesserter 12-Bit-A/D-Wandler
• Gleitkomma-Mathematik

Dabei ist der letzte XB auf der Liste kein eigentlicher I/O-Block für Peripheriegeräte, sondern ein Beschleuniger für Gleitkomma-Mathematik. Bei XBs kann es sich um beliebige Arten von Hardware-Beschleunigern handeln. Sie sind nicht auf I/O beschränkt.

Wählen Sie einen beliebigen Block

Beide FPGA-Entwicklungskarten XLR8 and Snō lassen sich auch im Einsatz verändern, wenn verschiedene XBs (oder mehrere Kopien desselben XB) ausgewählt und mit Hilfe des Entwicklungsflusses OpenXLR8 von Alorium im FPGA instanziiert werden. Mit dem OpenXLR8-Fluss von Alorium können die Entwickler sogar individuelle Xcelerator-Blöcke erstellen (Abbildung 5).

Abbildung 5: Der Entwicklungsfluss OpenXLR8 von Alorium ermöglicht es Entwicklern, mit den Quartus-Prime-Designtools von Intel neue Hardware-Blöcke zu erstellen und sie zur Arduino-IDE hinzuzufügen. (Bildquelle: Alorium Technology)

Derzeit erfordert die Erstellung eines individuellen XB ausreichende Kenntnisse der Hardwarebeschreibungssprachen Verilog oder VHDL und Kenntnisse im Umgang mit der FPGA-Tool-Suite Quartus von Intel – insbesondere mit Version 17.1 der Quartus Prime Lite Edition sowie mit den Mentor Graphics' ModelSim Simulationstools. Für die FPGA-Entwicklung sind Hardwarebeschreibungssprachen notwendig, da sie es dem Entwickler ermöglichen, die parallele Ausführung mehrerer Aufgaben auf standardisierte, festgelegte Weise auszudrücken. Hochsprachen (HLL) wie C und C++ sind grundsätzlich sequentielle Sprachen.

HLL-Compiler nehmen den HLL-Quellcode und übersetzen ihn in lange Sequenzen von Maschinenbefehlen, die in der Regel einer nach dem anderen ausgeführt werden. Daher sind FPGAs so viel schneller als Prozessoren – FPGAs können Tausende simultaner Aufgaben ausführen, sofern das FPGA groß genug ist. Es gibt HLL-Compiler, die in C oder C++ geschriebenen Code in eine HDL übersetzen können, die dann von herkömmlichen FPGA-Tools verarbeitet wird, doch der Designfluss OpenXLR8 von Alorium enthält derzeit keine entsprechenden HLL-Compiler.

Wenn ein XB jedoch erst einmal mit Hilfe von HDL und FPGA-Entwicklungstools entwickelt und getestet wurde, kann er in der Arduino-IDE wie jeder andere Block aus der Arduino-Bibliothek verwendet werden. Derzeit entwickelt Alorium außerdem weitere XBs für seine Arduino-IDE-Bibliotheken.

Fazit

Mit der Konstruktion ihrer jeweiligen FPGA-Entwicklungskarten wollen Arduino und Alorium Technology der Tatsache Rechnung tragen, dass die Entwickler zunehmend Embedded-Leistung von den kostengünstigen Entwicklungskarten benötigen. Obwohl die beiden Unternehmen unterschiedliche Ansätze gewählt haben, streben sie dasselbe Ziel an: Sie wollen einen Weg finden, um Embedded-Entwicklern den Zugang zu FPGAs zu ermöglichen. Auf der einfachsten Ebene besteht der Ansatz von Arduino und Alorium darin, das Hardware-Design zu vereinfachen und es auf die Auswahl von Blöcken und die Ausführung von Scripts zu reduzieren.

Der vollständige Designfluss ist derzeit jedoch noch nicht so einfach wie möglich. Arduino hat den HDL-Entwicklern noch nicht seinen gesamten FPGA-Entwicklungsfluss offen gelegt. Im Designfluss von Alorium ist das HDL-Design zwar möglich, doch es erfordert Kenntnisse in den FPGA-Designsprachen Verilog oder VHSL und Erfahrung mit Designtools.

Dennoch wird durch diese Produkte der Weg bereitet, so dass zumindest die theoretische Möglichkeit besteht, andere Fortschritte in der FPGA-Entwicklung wie C- und C++-Hardware-Compiler vorteilhaft einzusetzen. Bis dahin lässt sich ein Teil der Leistung von FPGAs mit den einfachen Verfahren nutzen, die Alorium Technology und Arduino entwickelt haben, um die Arduino-IDE zu erweitern.