Mikrocontroller-Board: Das neue Arduino-Board Giga R1 WiFi

Weil es gerade en vogue zu sein scheint, starte ich mit dem obligatorischen Hintergrundwissen von ChatGPT zum Giga R1. Meine Anfrage an ChatGPT lautete "Schreibe einen Artikel zum Arduino Giga R1":

Der Pragmatische Architekt – Michael Stal

Prof. Dr. Michael Stal arbeitet seit 1991 bei Siemens Technology. Seine Forschungsschwerpunkte umfassen Softwarearchitekturen für große komplexe Systeme (Verteilte Systeme, Cloud Computing, IIoT), Eingebettte Systeme, und Künstliche Intelligenz. Er berät Geschäftsbereiche in Softwarearchitekturfragen und ist für die Architekturausbildung der Senior-Software-Architekten bei Siemens verantwortlich.

"Der Arduino Giga R1 ist eine Weiterentwicklung der beliebten Arduino-Plattform, die speziell für den Einsatz in professionellen und industriellen Anwendungen entwickelt wurde. Diese neueste Version des Arduino-Boards bietet zahlreiche Verbesserungen und Funktionen, die es zu einer leistungsstarken und flexiblen Lösung für eine Vielzahl von Projekten machen.

Eine der auffälligsten Verbesserungen beim Arduino Giga R1 ist seine erhöhte Leistungsfähigkeit. Das Board ist mit einem leistungsstarken 32-Bit-ARM-Mikrocontroller ausgestattet, der in der Lage ist, hohe Rechengeschwindigkeiten zu erreichen und eine Vielzahl von Anwendungen zu unterstützen. Dies ermöglicht es dem Arduino Giga R1, komplexe Anwendungen wie Bild- und Spracherkennung sowie maschinelles Lernen zu unterstützen.

Eine weitere wichtige Verbesserung beim Arduino Giga R1 ist seine erweiterte Konnektivität. Das Board verfügt über eine Vielzahl von Schnittstellen, einschließlich Ethernet, USB, CAN-Bus und RS485. Diese Schnittstellen ermöglichen es dem Board, mit anderen Geräten und Systemen zu kommunizieren und eine nahtlose Integration in eine breite Palette von Anwendungen zu ermöglichen.

Darüber hinaus verfügt der Arduino Giga R1 über eine umfangreiche Bibliothek von Bibliotheken und Tools, die es Entwicklern erleichtern, Anwendungen für das Board zu erstellen. Diese Bibliotheken umfassen eine Vielzahl von Funktionen, einschließlich Sensorsteuerung, Datenerfassung, Datenanalyse und drahtloser Konnektivität. Dies ermöglicht es Entwicklern, komplexe Anwendungen schnell und einfach zu erstellen und anzupassen."

Doch damit genug zu den erstaunlich präzisen ChatGPT-Erkenntnissen.

Warum Giga?

Der Name "Giga" soll wohl darauf hinweisen, dass das neue Mikrocontroller-Board in allen Belangen wesentlich mehr leisten kann als ein Arduino Mega-Board. Das betrifft die eingesetzten Prozessoren, die Art und Zahl der Schnittstellen und etliches mehr. Arduino Giga und Mega haben den Formfaktor gemeinsam. Zum detaillierten Leistungsspektrum des Giga komme ich später noch. Auch vom Preislichen (68,70 Euro im offiziellen Arduino-Store) ähnelt der Arduino Giga mehr seinen Arduino-Pro-Cousins aus der Portenta-Serie und reiht sich damit zwischen den Produktfamilien Arduino und Arduino Pro ein. Es erreicht den Benutzer mit einem unten angebrachten transparenten Acrylboden, der zur (elektrischen) Absicherung dient, plus einer anschließbaren Antenne für drahtlose Kommunikation.

Unter der Haube

Eine wichtige Ergänzung in diesem Zusammenhang ist, dass das Board zwei 32-Bit-ARM-Kerne integriert. Der Chip von ST Microelectronics (STM32H747XI) enthält einen mit 240 MHz getakteten Cortex-M4 und einen mit 480 MHz getakteten Cortex-M7. Zu beiden Kernen kommt zusätzlich jeweils eine Floating Point Unit (FPU) mit doppelter Präzision. Der M7 verfügt über einen L1-Cache. Das Board integriert zudem eine Memory Protection Unit und Hardware zur digitalen Signalverarbeitung.

Durch die zwei Kerne ergibt sich die Möglichkeit, zwei Programme auf unterschiedlichen Prozessoren laufen zu lassen, zum Beispiel ein rechenintensives Hauptprogramm auf dem M7 und eine Motoransteuerung oder eine Anwendung zur Erfassung von Sensorwerten auf dem M4. Als Sprachen zur Programmierung stehen primär MicroPython sowie C/C++ zur Verfügung. Für die unabdingbare Kommunikation und Synchronisation zwischen den Programmen auf M4 und M7 existiert in der zugehörigen Arduino-Bibliothek ein entsprechender RPC-Mechanismus, der Funktionsaufrufe zwischen dem M4 und dem M7 gestattet. Das Board bietet 1 MByte Arbeitsspeicher und 2 MByte Flashspeicher, der sich in zwei Bereiche für die beiden Microcontroller partitionieren lässt. Wer nur den M7 nutzt, kann die vollen 2 MByte Flashspeicher für das dort laufende Programm nutzen. Auf dem Board befinden sich des Weiteren 8 MByte SDRAM, die Entwickler mit SDRAM.malloc() allokieren, benutzen, und danach mit SDRAM.free() freigeben können (siehe Header SDRAM.h). Über einen QSPI-Anschluss sind weitere 16 MByte externer Flashspeicher angeschlossen, die Entwickler zur Datenablage verwenden können, wobei die Firmware des Giga R1 die Dateisysteme FATFS und littleFS unterstützt. Nach den hierfür erforderlichen Konfigurationsschritten ist der Flashspeicher ebenfalls als externes USB Flash Drive nutzbar.

Grundlage des Giga ist Mbed OS, ein quelloffenes, echtzeitbasiertes, und ressourcenschonendes Betriebssystem für IoT-Boards, das sich um Aspekte wie Konnektivität, Sicherheit, Speicher, Gerätemanagement, Supportbibliotheken und Treiber kümmert. Es integriert auch RTOS, das Mechanismen für nebenläufige Threads beisteuert.

Noch mehr Tiefgang

Als Eingangsspannung erlaubt Giga zwischen 6V und 24V, während die Betriebsspannung wie bei modernen Boards 3,3V beträgt. Wer also vorhandene Schaltungsentwürfe verwendet, die sich auf den Arduino Mega (oder Uno) mit seinen 5V Betriebsspannung stützen, sollte etwas Zeit für das Redesign einplanen. In diesem Fall bietet es sich an, einen Logic Level Konverter oder einen selbst gebauten Spannungsteiler zu verwenden. Jeder digitale Port bietet mit rund 8 mA relativ wenig Energie. Als kompatible Shields gibt Arduino das aktuelle Motion-Shield, das Relay-Shield, das Ethernet-Shield und das Motorsteuerungs-Shield für den Mega an.

Zur Zusammenarbeit über USB fungieren ein USB-C und ein USB-A Anschluss. Ersterer dient der Programmierung, unterstützt HID (Human Interface Design) und versorgt das Board mit Strom, sofern keine anderen Spannungsquellen angeschlossen sind, letzterer erlaubt als USB-Host die Zusammenarbeit mit Massenspeichern oder Tastaturen.

Ein dediziertes Modul (Murata LBEE5KL1DX-883) ist für die Kommunikation über WiFi (802.11b/g/n mit 65 Mbps) und Bluetooth/BLE (Versionen 5.X und 4.2) zuständig. Dem Arduino Giga R1 liegt zu diesem Zweck eine passende, über eine Micro UFL Verbindung anschließbare Antenne bei – auf dem Board selbst ist keine Antenne integriert. Über ein entsprechendes Shield lässt sich zusätzlich huckepack ein Ethernetanschluss hinzufügen. Was Bluetooth LE betrifft, nutzen Anwendungen für Version 4.2 den zugehörigen Arduino-Stack, während der Cordio-Stack die BLE Versionen 5.X unterstützt.

Für Bus-orientierte Kommunikation mit angeschlossener Hardware stehen vier UARTs, drei I2C-Anschlüsse, zwei SPI-Ports und eine CAN-Anbindung (über einen notwendigen externen Transceiver) zur Verfügung.

Ein ATECC608A-MAHDA-T Crypto-Modul von MICROCHIP sorgt für Sicherheitsfunktionen wie Verschlüsselung und Authentifizierung.

Ein- und Ausgänge

An Ein-/Ausgabe-Ports gibt es 76 digitale Pins, 12 analoge Ausgabepins sowie 12 PWM-fähige Pins, was für die meisten Anwendungen problemlos genügen sollte. Über Digital-Analog-Konverter lassen sich an zwei analogen Pins entsprechende Umwandlungen bewerkstelligen, was etwa bei der Audioausgabe notwendig ist. Da das Board wie üblich etliche Pins mit verschiedenen Funktionen belegt, sollte der Entwickler das natürlich beim Schaltungsentwurf berücksichtigen. Alle GPIO-Pins (Pins 22 bis 75) lassen sich Interrupt-gesteuert nutzen, was dem Programmierer hilft, schnell auf externe Ereignisse zu reagieren, etwa dem Anliegen eines Sensorwerts oder dem Betätigen eines Pushbutton.

Ein VRTC-Eingang erlaubt den kontinuierlichen Betrieb der Echtzeituhr, ein OFF-Pin das Ausschalten des Boards von außen. Es empfiehlt sich, nach Start des Boards die aktuelle Zeit über WiFi über einen NTP (Network Time Protocol)-Server zu beziehen und die Echtzeituhr damit zu füttern.

Darüber hinaus integriert der Giga R1 Anschlüsse für Kameras (zum Beispiel Arducam über die Pins: I2C + D54-D67), Mikrofone beziehungsweise Audio (DAC0, DAC1, A7) und Anzeigen (über D1N, D0N, D1P, D0P, CKN, CKP + D68-D75) sowie einen JTAG-Konnektor für Debugging/Programmer-Hardware. Intern besitzt der Mikrocontroller einen 2D-Grafikbeschleuniger mit einer Auflösung von bis zu 1024x768 Bildpunkten.

Damit eröffnet sich eine Fülle von Anwendungsgebieten. Als mögliche Anwendungen des Arduino Giga R1 beschreibt das Product Reference Manual zum Beispiel 3D-Drucker, Audioverarbeitungshardware, Geräte zur Datenakquisition, Signalverarbeitung sowie Robotikanwendungen.

Wer mehr technische Details zum Giga R1 benötigt, kann entsprechende Dokumentation auf der Arduino-Seite finden.

Über den BOOT0-Knopf auf dem Board lässt sich durch Gedrückthalten beim Hochfahren des Boards ein OTA (Over the Air)-Firmware-Update auslösen. Mittels des RST-Buttons lassen sich Programme resetten (einfaches drücken) oder das Board in den Bootloader-Modus versetzen (zweifaches drücken kurz hintereinander), um das Board zu (re-)programmieren. Die rote LED blinkt 4 mal schnell und viermal langsam, sofern innerhalb der Mbed-OS-Firmware ein Fehler erkannt wurde.

IDE und Programmierung

Zum Entwickeln von Anwendungen eignen sich Arduino IDE 1.8.X sowie deren Nachfolger: die Arduino IDE 2.0.X. Alternativ lassen sich auch der Arduino Webeditor und die Arduino-IoT-Cloud verwenden. Eine passende Platform-IO- beziehungsweise Visual-Studio-Code-Anbindung gab es zum Zeitpunkt der Artikelerstellung noch nicht. Beim Einsatz von MicroPython bieten sich stattdessen die Thonny IDE oder das Arduino Lab für MicroPython an. Auf der Webseite zum Giga R1 steht allerdings der Hinweis, dass die Unterstützung von MicroPython momentan noch experimentell sei. Jedenfalls lässt sich ein MicroPython-Programm auf einem der beiden Kerne nutzen, während auf dem anderen C++-Code läuft. Freilich können auf beiden Kernen auch C++- oder MicroPython-Programme laufen.

Ich habe zum Test die Arduino IDE 2.0.5 verwendet. Über das Menü Tools>Manage Library installieren Nutzer die Unterstützung für Mbed OS Giga Boards v4.0.2 über den Boardmanager.

Nach der Board-Installation können Nutzer über das File>Examples-Menü auf exemplarische Sketches zugreifen, entweder auf allgemeine oder spezifische für ein STM32H747_System.

Der IDE müssen wir noch mitteilen, wie sich der M4-Kern und der M7-Kern den Flashspeicher aufteilen sollen.

Und außerdem, auf welchen Kern die IDE den aktuellen Sketch uploaden soll.

In der Arduino IDE findet sich im Tools-Menü nach der Installation des angeschlossenen Giga-Boards die Konfiguration.

Für die Kommunikation zwischen beiden Kernen existiert eine RPC-Bibliothek.

Programmbeispiel für die Kommunikation zwischen M7 und M4

Um zwischen beiden Kernen kommunizieren zu können, bedarf es entsprechender Funktionalität zwischen den Kernen. Zu beachten sind zwei Tatsachen: Der M4 kann nicht auf den seriellen Monitor schreiben. Stattdessen nutzt der Sketch des M4 die Routine RPC.println().

Die RPC-Bibliothek nutzt der M4-Core zur Kommunikation mit dem M7-Core:

#include <RPC.h> // Inkludieren der RPC-Bibliothek

Initialisierung der RPC-Bibliothek:

void setup() { // Einmal ausgeführt
 RPC.begin(); // Initialisierung
}

Das Programm auf dem M4 sendet kontinuierlich eine Zeichenkette an den Sketch im M7:

void loop() {
 // put your main code here, to run repeatedly:
 RPC.println("Hello World!"); // Schreiben von Info an den M7 Core
}

 

Im M7-Core empfangen wir die Information und schreiben sie auf den seriellen Monitor. Hier spielt die zweite Tatsache eine Rolle: Der M4 startet nicht von selbst. Das erledigt der Aufruf von RPC.begin() im M7-Kern.

Das Programm auf dem M7 baut eine Verbindung auf dem seriellen Monitor auf, und initialisiert die Kommunikation. Zugleich dient RPC.begin() zum Booten des M4:

#include <RPC.h>

void setup() {
// put your setup code here, to run once:
 →Serial.begin(9600); // Starten der Kommunikation 
                      // mit seriellem Monitor
 →RPC.begin(); // Starten der >Kommunikation mit M4
}

In der Schleife werden kontinuierlich die vom M4 empfangenen Daten gelesen:

void loop() {
 String buffer = ""; // Einlesen der Nachricht vom M4
 while (RPC.available()) {
 buffer += (char)RPC.read();
}

 

Anschließend wird die empfangene Zeichenkette auf dem seriellen Monitor geschrieben:

if (buffer.length() > 0) {
 Serial.print(buffer); // Schreiben derselben Information 
                       // zum seriellen Monitor
 }
}

 

Auf dem seriellen Monitor sehen wir nun - wenig überraschend - die folgende Ausgabe:

Wir können im Sketch abfragen, ob der Sketch auf dem M4 läuft:

if (currentCPU() == "M4") {
 //run M4 code
}

 

oder auf dem M7:

if (currentCPU() == "M7") {
 //run M7 code
}

Zum Testen des WiFi-Moduls auf dem Giga R1 WiFi habe ich einen Beispielssketch aus File>Examples genutzt (WiFiWebClient (c) Tom Igoe). Das Programm verbindet sich zu einem WLAN-Netzwerk, zeigt die zugehörigen Netzwerkdaten an, nimmt Verbindung zum Server example.com auf, und holt sich die Seite index.html, die es dann im seriellen Monitor ausgibt.

Das folgende Beispielsprogramm ist für den Portenta H7 geschrieben, läuft aber auch auf dem Arduino Giga R1 WiFi:

/*
 Web client

This sketch connects to a website 
(http://example.com) using the WiFi module.

This example is written for a network using WPA encryption. For
 WEP or WPA, change the Wifi.begin() call accordingly.

Circuit:
 * Arduino Portenta H7

created 13 July 2010
 by dlf (Metodo2 srl)
 modified 31 May 2012
 by Tom Igoe
 */

 

Wir verwenden die WiFi-Bibliothek:

#include <WiFi.h>

Zum Zugriff auf das WLAN benötigen wir SSID und Passwort. Diese sollten normalerweise in einer Headerdatei wie arduino_secrets.h abgelegt sein:

#include "arduino_secrets.h" 
///////please enter your sensitive data in the 
///////Secret tab/arduino_secrets.h
char ssid[] = "#########"; // your network SSID (name)
char pass[] = "#########"; // your network password 
                           // (use for WPA, or use as key for WEP)
int keyIndex = 0; // your network key Index number 
                  // (needed only for WEP)

Es soll ein Zugriff auf den Host example.com erfolgen:

int status = WL_IDLE_STATUS;
// if you don't want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
// IPAddress server(93,184,216,34); // IP address for 
                                    // example.com (no DNS)
char server[] = "example.com"; // host name for example.com 
                               // (using DNS)

 

Der Arduino-Sketch fungiert als Web-Client:

WiFiClient client;

Zunächst etabliert der Sketch die Verbindung zum seriellen Monitor:

void setup() {
 //Initialize serial and wait for port to open:
 Serial.begin(9600);
 while (!Serial) {
 ; // wait for serial port to connect. 
   // Needed for native USB port only
 }

 

... und überprüft, ob das Board über ein WiFi-Modul verfügt:

// check for the WiFi module:
 if (WiFi.status() == WL_NO_SHIELD) {
 Serial.println("Communication with WiFi module failed!");
 // don't continue
 while (true);
 }

 

Nun kommt es zum Verbindungsaufbau mit der angegebenen WLAN-Netzwerk-ssid und dem Schlüssel pass als Basis:

// attempt to connect to Wifi network:
 while (status != WL_CONNECTED) {
 Serial.print("Attempting to connect to SSID: ");
 Serial.println(ssid);
 // Connect to WPA/WPA2 network. 
 // Change this line if using open or WEP network:
 status = WiFi.begin(ssid, pass);

 

Drei Sekunden werden abgewartet. Im Erfolgsfall sehen wir die Ausgabe der WiFi-Client-Konfiguration:

// wait 3 seconds for connection:
 delay(3000);
 }
 Serial.println("Connected to wifi");
 printWifiStatus();

 

Anschließend verbindet sich der Sketch mit dem gewünschten Host. Angefordert wird die Seite index.html:

Serial.println("\nStarting connection to server...");
 // if you get a connection, report back via serial:
 if (client.connect(server, 80)) {
 Serial.println("connected to server");
 // Make a HTTP request:
 client.println("GET /index.html HTTP/1.1");
 client.print("Host: ");
 client.println(server);
 client.println("Connection: close");
 client.println();
 }
}

 

Solange Daten des Hosts anliegen, werden diese am seriellen Monitor ausgegeben:

void loop() {
 // if there are incoming bytes available
 // from the server, read them and print them:
 while (client.available()) {
 char c = client.read();
 Serial.write(c);
 }

 

Ist die Übertragung beendet, kommt es zum Verbindungsabbau:

// if the server's disconnected, stop the client:
 if (!client.connected()) {
 Serial.println();
 Serial.println("disconnecting from server.");
 client.stop();

 

Der Sketch endet in einer Endlosschleife:

// do nothing forevermore:
 while (true);
 }
}

 

Die Methode printWifiStatus() gibt zunächst das verbundene WLAN-Netz (SSID) aus:

void printWifiStatus() {
 // print the SSID of the network you're attached to:
 Serial.print("SSID: ");
 Serial.println(WiFi.SSID());

 

Danach informiert er über die dem Board zugewiesene IP-Adresse:

// print your board's IP address:
 IPAddress ip = WiFi.localIP();
 Serial.print("IP Address: ");
 Serial.println(ip);

 

Zu guter Letzt kommt es noch zur Ausgabe der Signalstärke:

// print the received signal strength:
 long rssi = WiFi.RSSI();
 Serial.print("signal strength (RSSI):");
 Serial.print(rssi);
 Serial.println(" dBm");
}

 

Die Ausgabe des obigen Programmes schaut wie folgt aus:

Beispiel: Sensor lesen

Das nachfolgende Beispiel arbeitet wieder mit zwei Sketches. Der erste läuft unter dem M7-Core. Die Methode A0Lesen() dient dem Auslesen des Sensorwerts am analogen Port A0. Dazu bindet und registriert der Code die Methode unter dem Namen A0Lesen als über RPC aufrufbare Methode. In loop() empfängt der M7 alle Meldungen des M4 und gibt sie anschließend auf dem seriellen Monitor aus. Wie bereits erwähnt kann Code auf dem M4 nicht auf den seriellen Monitor zugreifen, sondern muss dazu den Umweg über den M7 nutzen:

// Demo-Code für den M7-Core
#include "Arduino.h"
#include "RPC.h"

void setup() {
 RPC.begin();
 Serial.begin(115200);

// Binden/Registrieren der Methode A0Lesen()
 RPC.bind("A0Lesen", A0Lesen);
}

void loop() {
 // Alles einlesen, was vom M4 kommt
 String buffer = "";
 while (RPC.available()) {
 buffer += (char)RPC.read(); // Buffer auffuellen
 }
 if (buffer.length() > 0) {
 Serial.print(buffer); // und ausgeben
 }
}

/*
Hier wird der aktuelle Wert vom analogen Eingang A0 gelesen
und zurueckgeliefert
*/
int A0Lesen() {
 int result = analogRead(A0);
 return result;
}

 

Im M4-Core nutzen wir einen eigenen Thread sensorThread, der die Methode sensor_lesen() ausführt. Dieser ruft jede Sekunde die RPC-Methode A0Lesen() auf, um den aktuellen Sensorwert zu erfassen. Dann sendet er über RPC.println() eine Nachricht an den M7, die dieser am seriellen Monitor ausgibt.

Demo-Code für den M4-Core:

#include "Arduino.h"
#include "RPC.h"

using namespace rtos;

Thread sensorThread;

void setup() {
 RPC.begin();
 Serial.begin(115200);

/*
 Starte neuen Thread, der die Funktion sensor_lesen ausfuehrt
 */
 sensorThread.start(sensor_lesen);
}

void loop() {
}


// Code für den Thread
void sensor_lesen() {
 while (true) {
 delay(1000); // 1 Sekunde warten
 // Aufruf der Funktion A0Lesen im M7
 auto result = RPC.call("A0Lesen").as<int>();
 RPC.println("Result is " + String(result));
 }
}

 

Am seriellen Monitor sehen wir dann eine Ausgabe wie die folgende:

Alles gut oder was?

Momentan lässt die Zahl der für den Giga verfügbaren Software wie etwa Treiber und Bibliotheken noch viel Luft nach oben. Das ist allerdings der Tatsache geschuldet, dass naturgemäß in einem so frühen Stadium noch nicht viel davon existieren kann. Ein Ökosystem muss sich erst entwickeln. Der Preis erscheint etwas hoch. Dem ist allerdings entgegenzusetzen, dass sich das Giga R1 Board leistungstechnisch eher auf den Höhen der Potenta-Boards, speziell dem Portenta H7 Lite bewegt und eine hervorragende Plattform für Edge-Anwendungen wie KI bietet. Wer also lediglich ein Board für kleinere beziehungsweise weniger anspruchsvolle Problemstellungen sucht, ist mit anderen preisgünstigeren Arduino Boards, ESP32-Boards oder dem Raspberry Pi Pico W besser bedient.

Was die Kommunikation mit der Außenwelt betrifft, lässt das Giga-Board kaum Wünsche offen. Das gilt sowohl für Kommunikation mit anderer Software via WiFi und Bluetooth als auch für die systemnahe Kommunikation mit Peripherie. Die Zahl der verfügbaren Schnittstellen ist üppig.

Das Konzept der zwei Microcontroller und der anderen Schnittstellen entspringt der Portenta-Familie und hat deutliche Vorteile bei der Implementierung leistungshungiger Embedded Systeme. Die Positionierung des Giga R1 als Highend-Board zwischen den industriellen Arduino-Produkten und Arduino-Boards für größere Maker-Projekte ist daher sicher gerechtfertigt.

Das soll es im Wesentlichen zu den Leitungsdetails des Arduino Giga R1 WiFi gewesen sein. In zukünftigen Folgen sprechen wir über konkrete Anwendungen. ()