Jenseits von StandardFirmata – Revisited – Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

Vor einiger Zeit wurde ich von Dr. Martyn Wheeler, einem pymata4-Benutzer, kontaktiert, um eine Anleitung zum Hinzufügen von Unterstützung für den DHT22-Feuchtigkeits-/Temperatursensor zur pymata4-Bibliothek zu erhalten. Die pymata4-Bibliothek in Verbindung mit ihrem Arduino-Pendant FirmataExpress ermöglicht es Benutzern, ihre Arduino-Geräte aus der Ferne zu steuern und zu überwachen. Innerhalb weniger Runden des E-Mail-Austauschs gelang es Dr. Wheeler, sowohl pymata4 als auch FirmataExpress zu modifizieren. Daher ist die Unterstützung der Sensoren DHT22 und DHT11 jetzt ein Standardbestandteil von pymata4 und FirmataExpress.

Im Mai 2014 habe ich einen Artikel über das Hinzufügen von Unterstützung für Firmata für zusätzliche Geräte geschrieben. Als ich über diesen Artikel nachdachte, wurde mir klar, wie viel sich verändert hat, seit ich für diesen Artikel Stift zu Papier genommen habe. Zusätzlich zu diesem Artikel hat Dr. Wheeler seine Bemühungen dokumentiert, und Sie möchten das vielleicht auch überprüfen.

FirmataExpress basiert auf StandardFirmata, und die Verzeichnisstruktur von StandardFirmata hat sich weiterentwickelt. Darüber hinaus unterscheidet sich die pymata4-API auch ein wenig von der ursprünglichen PyMata-API von 2014. Ich dachte, dies wäre der perfekte Zeitpunkt, um diesen Artikel noch einmal zu lesen und zu aktualisieren. Lassen Sie uns anhand der Arbeit von Dr. Wheeler untersuchen, wie die Funktionalität von pymata4/FirmataExpress erweitert werden kann.

Bevor wir beginnen - Einige Hintergrundinformationen zu Arduino/Firmata

Was ist Firmata? Zitat von der Firmata-Webseite: "Firmata ist ein generisches Protokoll zur Kommunikation mit Mikrocontrollern über Software auf einem Host-Computer."

Arduino Firmata verwendet eine serielle Schnittstelle, um sowohl Befehls- als auch Berichtsinformationen zwischen einem Arduino-Mikrocontroller und einem PC zu übertragen, normalerweise unter Verwendung einer seriellen / USB-Verbindung, die auf 57600 bps eingestellt ist. Die über diese Verbindung übertragenen Daten sind binär, und das Protokoll ist in einem Client/Server-Modell implementiert.

Die Serverseite wird in Form einer Arduino-Skizze auf einen Arduino-Mikrocontroller hochgeladen. Die StandardFirmata-Skizze, die in der Arduino-IDE enthalten ist, steuert die Arduino-E/A-Pins, wie vom Client befohlen. Es meldet auch Änderungen der Eingangspins und andere Berichtsinformationen an den Client zurück. FirmataExpress ist eine erweiterte Version von StandardFirmata. Es läuft mit einer seriellen Verbindungsgeschwindigkeit von 115200 bps.

Der für diesen Artikel verwendete Arduino-Client ist pymata4. Es ist eine Python-Anwendung, die auf einem PC ausgeführt wird. Es sendet sowohl Befehle an den Arduino-Server als auch empfängt Berichte von diesem. Da pymata4 in Python implementiert ist, läuft es auf Windows-, Linux- (einschließlich Raspberry Pi) und macOS-Computern.

Warum Firmata verwenden?

Arduino-Mikrocontroller sind wunderbare kleine Geräte, aber Prozessor- und Speicherressourcen sind etwas begrenzt. Bei prozessor- oder speicherintensiven Anwendungen bleibt oft keine andere Wahl, als den Ressourcenbedarf auf einen PC zu verlagern, damit die Anwendung erfolgreich ist.

Aber das ist nicht der einzige Grund für die Verwendung von StandardFirmata. Bei der Entwicklung leichterer Arduino-Anwendungen kann ein PC Tools und Debugging-Funktionen bereitstellen, die auf einem Arduino-Mikrocontroller nicht direkt verfügbar sind. Die Verwendung eines "festen" Clients und Servers hilft, die Anwendungskomplexität auf einen PC zu beschränken, der einfacher zu verwalten ist. Sobald die Anwendung perfektioniert ist, kann sie in eine benutzerdefinierte, eigenständige Arduino-Skizze übersetzt werden.

Warum pymata4 verwenden?

Als Autor bin ich natürlich voreingenommen. Abgesehen davon ist es der einzige Python-basierte Firmata-Client, der in den letzten Jahren kontinuierlich gewartet wurde. Es bietet eine intuitive und einfach zu bedienende API. Zusätzlich zu StandardFirmata-basierten Skizzen unterstützt es Firmata über WiFi für Geräte wie den ESP-8266, wenn die StandardFirmataWifI-Skizze verwendet wird.

Außerdem wurde pymata4 so konzipiert, dass es von einem Benutzer einfach erweitert werden kann, um zusätzliche Sensoren und Aktoren zu unterstützen, die derzeit nicht von StandardFirmata unterstützt werden.

Schritt 1: Das Firmata-Protokoll verstehen

Das Kommunikationsprotokoll Arduino Firmata wird vom MIDI-Protokoll abgeleitet, das ein oder mehrere 7-Bit-Bytes verwendet, um Daten darzustellen.

Firmata wurde entwickelt, um durch den Benutzer erweiterbar zu sein. Der Mechanismus, der diese Erweiterbarkeit bereitstellt, ist das System Exclusive (SysEx) Messaging-Protokoll.

Das Format einer SysEx-Nachricht, wie vom Firmata-Protokoll definiert, ist in der obigen Abbildung dargestellt. Es beginnt mit einem START_SYSEX-Byte mit einem festen Wert von hexadezimal 0xF0, gefolgt von einem eindeutigen SysEx-Befehlsbyte. Der Wert des Befehlsbytes muss im Bereich hexadezimal 0x00-0x7F liegen. Auf das Befehlsbyte folgt dann eine unbestimmte Anzahl von 7-Bit-Datenbytes. Abschließend wird die Nachricht mit einem END_SYSEX-Byte mit einem festen Wert von hexadezimal 0xF7 abgeschlossen.

Firmata-Datenkodierung/-dekodierung

Da der Nutzdatenteil einer SysEx-Nachricht aus einer Reihe von 7-Bit-Bytes besteht, fragen Sie sich vielleicht, wie man einen Wert größer als 128 (0x7f) darstellt. Firmata kodiert diese Werte, indem es sie in mehrere 7-Bit-Byte-Blöcke zerlegt, bevor die Daten über die Datenverbindung gemarshallt werden. Das niedrigstwertige Byte (LSB) eines Datenelements wird zuerst gesendet, gefolgt von ansteigend signifikanten Komponenten des Datenelements gemäß Konvention. Das höchstwertige Byte (MSB) des Datenelements ist das zuletzt gesendete Datenelement.

Wie funktioniert das?

Nehmen wir an, wir möchten einen Wert 525 in den Datenteil einer SysEx-Nachricht integrieren. Da ein Wert von 525 deutlich größer ist als ein Wert von 128, müssen wir ihn in 7-Bit-Byte-„Chunks“aufteilen oder zerlegen.

So wird das gemacht.

Der dezimale Wert von 525 entspricht dem hexadezimalen Wert von 0x20D, einem 2-Byte-Wert. Um das LSB zu erhalten, maskieren wir den Wert, indem wir ihn mit 0x7F UND-verknüpfen. Sowohl "C"- als auch Python-Implementierungen werden unten gezeigt:

// "C"-Implementierung zum Isolieren von LSB

int max_distanz_LSB = max_distanz & 0x7f; // maskiere das untere Byte # Python-Implementierung, um LSB zu isolieren max_distance_LSB = max_distance & 0x7F # maskiere das untere Byte

Nach der Maskierung enthält max_distance_LSB 0x0d. 0x20D & 0x7F = 0x0D.

Als nächstes müssen wir das MSB für diesen 2-Byte-Wert isolieren. Dazu verschieben wir den Wert von 0x20D um 7 Stellen nach rechts.

// "C"-Implementierung zum Isolieren von MSB von 2-Byte-Werten

int max_distanz_MSB = max_distanz >> 7; // das höherwertige Byte verschieben # Python-Implementierung, um das MSB mit dem 2-Byte-Wert zu isolieren max_distance_MSB = max_distance >> 7 # verschieben, um das obere Byte zu erhalten Nach dem Verschieben enthält max_distance_MSB einen Wert von 0x04.

Wenn die "chunkifizierten" gemarshallten Daten empfangen werden, müssen sie wieder zu einem einzigen Wert zusammengesetzt werden. So werden die Daten sowohl in "C" als auch in Python wieder zusammengesetzt

// "C"-Implementierung, um die 2 Byte wieder zusammenzusetzen, // 7-Bit-Werte zu einem einzigen Wert int max_distance = argv[0] + (argv[1] << 7); # Python-Implementierung, um die 2-Byte-, # 7-Bit-Werte zu einem einzigen Wert zusammenzusetzen max_distance = data[0] + (data[1] << 7)

Nach dem Zusammenbau entspricht der Wert wieder 525 dezimal oder 0x20D hexadezimal.

Dieser Zerlegungs-/Wiederzusammenbauprozess kann entweder vom Client oder vom Server durchgeführt werden.

Schritt 2: Fangen wir an

Die Unterstützung eines neuen Geräts erfordert Änderungen sowohl am Arduino-residenten Server als auch am PC-residenten Python-Client. Die Arbeiten von Dr. Wheeler werden verwendet, um die notwendigen Modifikationen zu veranschaulichen.

Der vielleicht wichtigste Schritt ist die Entscheidung, ob Sie eine vorhandene unterstützende Gerätebibliothek in die Arduino-Seite der Gleichung integrieren oder eine eigene schreiben möchten. Es wird empfohlen, dass es viel einfacher ist, eine vorhandene Bibliothek zu finden, als eine eigene von Grund auf neu zu schreiben.

Für die DHT-Geräteunterstützung basierte Dr. Wheeler seinen Erweiterungscode auf der DHTNew-Bibliothek. Sehr geschickt hat Dr. Wheeler die Funktionalität der DHTNew-Bibliothek auf die Arduino- und pymata4-Seiten der Gleichung aufgeteilt, um eine minimale Blockierung auf der Arduino-Seite zu ermöglichen.

Wenn wir uns DHTNew ansehen, führt es alle der folgenden Aktionen aus:

• Stellt den ausgewählten digitalen Pin-Ausgangsmodus ein.
• Taktet ein codiertes Signal aus, um die neuesten Feuchtigkeits- und Temperaturwerte abzurufen.
• Überprüft und meldet alle Fehler.
• Berechnet für den Menschen lesbare Temperatur- und Feuchtigkeitswerte aus den abgerufenen Rohdaten.

Um die Dinge auf der FirmataExpress-Seite so effizient wie möglich zu halten, hat Dr. Wheeler die Datenkonvertierungsroutinen vom Arduino auf pymata4 ausgelagert.

Schritt 3: FirmataExpress für DHT-Unterstützung ändern

Der FirmataExpress-Verzeichnisbaum

Nachfolgend sind alle Dateien aufgeführt, aus denen das FirmataExpress-Repository besteht. Dieser Baum ist identisch mit dem von StandardFiramata, nur dass einige der Dateinamen den Repository-Namen widerspiegeln.

Die Dateien, die geändert werden müssen, sind die mit einem Sternchen (*) daneben.

FirmataExpress

├── * Boards.h

├── Beispiele

└── FirmataExpress

│ ├── Brettx

├── * FirmataExpress.ino

│ ├── LIZENZ.txt

│ └── Makefile

├── * FirmataKonstanten.h

* FirmataDefines.h

FirmataExpress.cpp

FirmataExpress.h

FirmataMarshaller.cpp

FirmataMarshaller.h

FirmataParser.cpp

FirmataParser.h

Schauen wir uns jede der Dateien und die vorgenommenen Änderungen an.

Boards.h

Diese Datei enthält Pin-Typ-Makrodefinitionen für jeden der unterstützten Board-Typen. Es definiert die maximale Anzahl unterstützter Geräte, wenn mehr als ein Gerät unterstützt werden muss.

Für das DHT-Gerät können bis zu 6 Geräte gleichzeitig verbunden sein und dieser Wert ist definiert als:

#ifndef MAX_DHTS

#define MAX_DHTS 6 #endif

Optional können auch Pin-Typ-Makros für das neue Gerät definiert werden, entweder für alle Board-Typen oder nur für die, die Sie interessieren. Diese Makros werden hauptsächlich zu Berichtszwecken verwendet und dienen nicht der Steuerung der Geräte. Diese Makros definieren beide Pins, die das Gerät unterstützen:

#define IS_PIN_DHT(p) (IS_PIN_DIGITAL(p) && (p) - 2 < MAX_DHTS)

Sowie ein Makro zum Definieren einer Pin-Zahlen-Umwandlung.

#define PIN_TO_DHT(p) PIN_TO_DIGITAL(p)

FirmataKonstanten.h

Diese Datei enthält die Firmware-Versionsnummer, die Sie möglicherweise ändern möchten, um zu verfolgen, welche Version Sie auf Ihr Arduino geladen haben. Es enthält auch die Firmata-Nachrichtenwerte, einschließlich der Firmata-SysEx-Nachrichten.

In dieser Datei müssen Sie Ihrem Gerät eine neue Nachricht oder eine Reihe von Nachrichten zuweisen. Für das DHT wurden zwei Nachrichten hinzugefügt. Einer konfiguriert einen Pin als „DHT“-Pin und der andere als Reporternachricht, wenn die neuesten DHT-Daten an den Client zurückgesendet werden.

statische const int DHT_CONFIG = 0x64;

statische const int DHT_DATA = 0x65;

In dieser Datei werden auch Pin-Modi angegeben. Für das DHT wurde ein neuer Pin-Modus erstellt:

statische const int PIN_MODE_DHT = 0x0F; // Pin für DHT konfiguriert

Beim Hinzufügen eines neuen Pin-Modus müssen die TOTAL_PIN_MODES angepasst werden:

statische const int TOTAL_PIN_MODES = 17;

FirmataDefines.h

Diese Datei muss aktualisiert werden, um die neuen Nachrichten widerzuspiegeln, die zu FirmataConstants.h hinzugefügt wurden:

#ifdef DHT_CONFIG#undef DHT_CONFIG #endif #define DHT_CONFIG firmata::DHT_CONFIG // DHT-Anfrage #ifdef DHT_DATA #undef DHT_DATA #endif #define DHT_DATA firmata::DHT_DATA // DHT-Antwort #ifdef PIN_MODE_DHT #undef PIN_MODE_defineHT #end. MODE_defineHT #end. MODE_defineHT #endMODE_defineHT::PIN_MODE_DHT

FirmataExpress.ino

In dieser Diskussion werden wir die „Höhepunkte“der Änderungen an dieser Arduino-Skizze behandeln.

Damit FirmataExpress bis zu sechs DHT-Geräte gleichzeitig unterstützen kann, wurden 3 Arrays erstellt, um die jeweilige Pinnummer des Geräts, seinen WakeUpDelay-Wert und den Gerätetyp, dh DHT22 oder DHT11, zu verfolgen:

// DHT-Sensoren

int numActiveDHTs = 0; // Anzahl der angehängten DHTs uint8_t DHT_PinNumbers[MAX_DHTS]; uint8_t DHT_WakeUpDelay[MAX_DHTS]; uint8_t DHT_TYPE[MAX_DHTS];

Da beide Gerätetypen ungefähr 2 Sekunden zwischen den Lesevorgängen benötigen, müssen wir sicherstellen, dass wir jedes DHT innerhalb des 2-Sekunden-Zeitrahmens nur einmal lesen. Auf einige Geräte wie die DHT-Geräte und die Distanzsensoren HC-SR04 wird nur periodisch zugegriffen. Dies gibt ihnen die Zeit, mit ihrer Umgebung zu interagieren.

uint8_t nextDHT = 0; // Index in dht für das nächste zu lesende Gerät

uint8_t currentDHT = 0; // Verfolgt, welcher Sensor aktiv ist. int dhtNumLoops = 0; // Zielanzahl der Schleife b4 für den Zugriff auf ein DHT int dhtLoopCounter = 0; // Schleifenzähler

Konfigurieren und Lesen des DHT-Geräts

Wenn FirmataExpress einen SysEx-Befehl empfängt, um einen Pin für den DHT-Betrieb zu konfigurieren, überprüft es, dass die maximale Anzahl von DHT-Geräten nicht überschritten wurde. Wenn das neue DHT unterstützt werden kann, werden die DHT-Arrays aktualisiert. Wenn der DHT-Typ unbekannt ist, wird eine SysEx-String-Nachricht erstellt und an pymata4 zurückgesendet

case DHT_CONFIG: int DHT_Pin = argv[0]; int DHT_type = argv[1]; if (numActiveDHTs < MAX_DHTS) { if (DHT_type == 22) { DHT_WakeUpDelay[numActiveDHTs] = 1; aufrechtzuerhalten. Sonst if (DHT_type == 11) { DHT_WakeUpDelay [numActiveDHTs] = 18; } else { Firmata.sendString("FEHLER: UNBEKANNTER SENSORTYP, GÜLTIGE SENSOREN SIND 11, 22"); brechen; } // Testen Sie den Sensor DHT_PinNumbers[numActiveDHTs] = DHT_Pin; DHT_TYPE[numActiveDHTs] = DHT_type; setPinModeCallback(DHT_Pin, PIN_MODE_DHT);

FirmataExpress versucht dann, mit dem DHT-Gerät zu kommunizieren. Bei Fehlern bildet es eine SysEx-Nachricht mit den Fehlerdaten und sendet die SysEx-Nachricht zurück an pymat4. Die Variable _bits enthält die vom DHT-Gerät zurückgegebenen Daten zur weiteren Verarbeitung durch pymata4, falls gewünscht.

Firmata.write(START_SYSEX);

Firmata.write(DHT_DATA); Firmata.write(DHT_Pin); Firmata.write(DHT_Typ); für (uint8_t i = 0; i > 7 & 0x7f); } Firmata.write(abs(rv)); Firmata.write(1); Firmata.write(END_SYSEX);

Wenn gültige Daten zurückgegeben werden, wird die Anzahl der aktiven DHTs erhöht. Eine Variable, die verfolgt, wie viele Schleifeniterationen abgeschlossen werden müssen, bevor das nächste DHT auf Daten überprüft wird, wird ebenfalls angepasst. Diese Variable stellt sicher, dass unabhängig davon, wie viele DHTs dem System hinzugefügt werden, alle innerhalb von 2 Sekunden gelesen werden.

int rv = readDhtSensor (numActiveDHTs);

if (rv == DHTLIB_OK) { numActiveDHTs++; dhtNumLoops = dhtNumLoops / numActiveDHTs; // alles okay }

Wenn in der Loop-Funktion des Sketches ein oder mehrere DHT-Geräte konfiguriert wurden, wird das nächste DHT-Gerät gelesen. Entweder werden die gültigen Daten oder deren Fehlerstatus in Form einer SysEx-Nachricht an pymata4 zurückgegeben:

if (dhtLoopCounter++ > dhtNumLoops) { if (numActiveDHTs) { int rv = readDhtSensor (nextDHT); uint8_t current_pin = DHT_PinNumbers[nextDHT]; uint8_t current_type = DHT_TYPE[nextDHT]; dhtLoopZähler = 0; aktuelleDHT = nächsteDHT; if (nextDHT++ >= numActiveDHTs - 1) { nextDHT = 0; } if (rv == DHTLIB_OK) {// TEST CHECKSUM uint8_t sum = _bits[0] + _bits[1] + _bits[2] + _bits[3]; if (_bits[4] != Summe) {rv = -1; } } // Nachricht mit Fehlerstatus zurücksenden Firmata.write(START_SYSEX); Firmata.write(DHT_DATA); Firmata.write (aktueller_pin); Firmata.write(aktueller_Typ); for (uint8_t i = 0; i < sizeof(_bits) - 1; ++i) { Firmata.write(_bits); // Firmata.write(_bits; } Firmata.write(abs(rv)); Firmata.write(0); Firmata.write(END_SYSEX); } }

Der zur Kommunikation mit dem DHT-Gerät verwendete Code wird direkt aus der DHTNew-Bibliothek abgeleitet:

int readDhtSensor (int-Index) {

// BUFFERVAR INITIEREN, UM DATEN ZU EMPFANGEN uint8_t mask = 128; uint8_t idx = 0; // BUFFER LEEREN // memset(_bits, 0, sizeof(_bits)); for (uint8_t i = 0; i 5 BYTES for (uint8_t i = 40; i != 0; i--) { loopCnt = DHTLIB_TIMEOUT; while (digitalRead(pin) == LOW) { if (--loopCnt == 0) DHTLIB_ERROR_TIMEOUT zurückgeben; } uint32_t t = micros(); loopCnt = DHTLIB_TIMEOUT; while (digitalRead(pin) == HIGH) { if (--loopCnt == 0) DHTLIB_ERROR_TIMEOUT zurückgeben; } if ((micros() - t) > 40) { _bits[idx] |= mask; } mask >>= 1; if (mask == 0) // nächstes Byte? { mask = 128; idx++; } } return DHTLIB_OK; }

Schritt 4: Pymata4 für die DHT-Unterstützung ändern

private_konstanten.h

Um das DHT zu unterstützen, müssen wir dieser Datei sowohl den neuen Pin-Typ als auch SysEx-Nachrichten hinzufügen:

# Pin-Modi INPUT = 0x00 # Pin als Eingang gesetzt OUTPUT = 0x01 # Pin als Ausgang gesetzt ANALOG = 0x02 # Analoger Pin im AnalogInput-Modus PWM = 0x03 # Digitaler Pin im PWM-Ausgangsmodus SERVO = 0x04 # Digitaler Pin im Servo-Ausgangsmodus I2C = 0x06 # Pin im I2C-Setup enthalten STEPPER = 0x08 # Jeder Pin im Stepper-Modus SERIAL = 0x0a PULLUP = 0x0b # Jeder Pin im Pullup-Modus SONAR = 0x0c # Jeder Pin im SONAR-Modus TONE = 0x0d # Jeder Pin im Tone-Modus PIXY = 0x0e # reserviert für Pixy-Kameramodus DHT = 0x0f # DHT-Sensor IGNORE = 0x7f # DHT-SysEx-Befehlsnachrichten DHT_CONFIG = 0x64 # dht-Konfigurationsbefehl DHT_DATA = 0x65 # dht-Sensorantwort

Der hinzugefügte Pin-Typ und die SysEx-Befehle müssen den Werten in FirmataConstants.h entsprechen, die zu FirmataExpress hinzugefügt wurden.

pymata4.py

Pymata4 verwendet ein Python-Wörterbuch, um eine eingehende Firmata-Nachricht schnell einem Nachrichtenhandler zuzuordnen. Der Name dieses Wörterbuchs ist report_dispatch.

Das Format für einen Wörterbucheintrag ist:

{MessageID: [message_handler, Anzahl der zu verarbeitenden Datenbytes]}

Dem Wörterbuch wurde ein Eintrag hinzugefügt, um eingehende DHT-Nachrichten zu verarbeiten:

{PrivateConstants. DHT_DATA: [self._dht_read_response, 7]}

Die 7 Byte Daten in der Nachricht sind die Arduino-Digital-Pin-Nummer, der Typ des DHT-Geräts (22 oder 11) und die 5 Byte Rohdaten.

Die Methode _dht_read_response prüft auf gemeldete Fehler. Wenn keine Fehler gemeldet werden, werden Luftfeuchtigkeit und Temperatur mit dem aus der Arduino DHTNew-Bibliothek portierten Algorithmus berechnet.

Die berechneten Werte werden über eine vom Benutzer bereitgestellte Callback-Methode gemeldet. Sie werden auch in der internen Datenstruktur pin_data gespeichert. Der zuletzt gemeldete Wert kann durch Abfragen von pin_data mit der Methode dht_read abgerufen werden.

Konfigurieren eines neuen DHT-Geräts

Beim Hinzufügen eines neuen DHT-Geräts wird die Methode set_pin_mode_dht aufgerufen. Diese Methode aktualisiert die pin_data für digitale Pins. Es erstellt auch eine DHT_CONFIG SysEx-Nachricht und sendet sie an FirmataExpress.

Schritt 5: Einpacken

Wie wir gesehen haben, müssen Sie zum Hinzufügen von Firmata-Unterstützung für ein neues Gerät den Arduino FirmataExpress-Servercode und den Python-basierten pymata4-Clientcode ändern. FirmataExpress-Code kann schwierig zu debuggen sein. Eine Methode namens printData wurde zu FirmataExpress hinzugefügt, um das Debuggen zu unterstützen. Mit dieser Methode können Sie Datenwerte von FirmataExpress senden und auf der pymata4-Konsole drucken.

Diese Funktion erfordert sowohl einen Zeiger auf eine Zeichenfolge als auch den Wert, den Sie anzeigen möchten. Wenn der Datenwert in einer Variablen namens argc enthalten ist, können Sie printData mit den folgenden Parametern aufrufen.

printData((char*)"argc=", argc);

Bei Fragen einfach einen Kommentar hinterlassen, ich antworte gerne.

Viel Spaß beim Codieren!