Your browser does not seem to support JavaScript. As a result, your viewing experience will be diminished, and you have been placed in read-only mode.

Please download a browser that supports JavaScript, or enable it if it's disabled (i.e. NoScript).

Firmware mithilfe der Arduino IDE flashen

Tipps, Tricks & Tutorials

2790

Anmelden zum Antworten

cooper zuletzt editiert von cooper
Es gibt eine sehr einfache Möglichkeit, *.bin-Dateien mithilfe der Arduino IDE zu flashen. *.bin-Dateien sind fertig kompilierte Programme - auch bekannt als Firmware. Ein sehr bekanntes Beispiel dafür ist zum Beispiel die Tasmota-Firmware für den ESP.

Ich möchte euch hier eine Möglichkeit zeigen, das Flashen einer Firmware mithilfe der Arduino IDE durchzuführen.

Dieses Verfahren funktioniert sowohl unter Windows, als auch unter Mac. Wahrscheinlich funktioniert das genauso unter Linux. Das habe ich aber nicht getestet.

Vorbereitungen

Geht in der Arduino IDE zuerst auf Datei - Voreinstellungen
und setzt dann einen Haken bei Ausführliche Ausgabe während: [✓] Hochladen

Beachte: Erst mit dem Bestätigen auf [Ok] - unten am Fenster - wird die Einstellung gespeichert.

Wählt danach aus der Liste der Boards das Board aus, auf das ihr eure gewünschte Firmware flashen möchtet.

Auf das Board wird zuerst ein Dummy-Programm geschrieben. Es kann sich dabei auch um ein leeres Programm handeln. Das Hochladen des Programms liefert uns die Daten die wir brauchen, um die gewünschte eigene Firmware zu flashen.

Im Monitor der Arduino IDE findet ihr nach dem Upload eine Ausgabe, über die Pfade die für das Hochladen verwendet werden.
```
Der Sketch verwendet 256312 Bytes (24%) des Programmspeicherplatzes. Das Maximum sind 1044464 Bytes.
Globale Variablen verwenden 26804 Bytes (32%) des dynamischen Speichers, 55116 Bytes für lokale Variablen verbleiben. Das Maximum sind 81920 Bytes.
D:\Users\cooper\AppData\Local\Arduino15\packages\esp8266\tools\python3\3.7.2-post1/python3 D:\Users\cooper\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.6.3/tools/upload.py --chip esp8266 --port COM4 --baud 921600 --before default_reset --after hard_reset write_flash 0x0 D:\Users\cooper\AppData\Local\Temp\arduino_build_165769/Blink.ino.bin 
```
Wichtig ist nur die letzte der drei Zeilen. Kopiert euch diese Zeile am besten in ein Textprogramm.

Diese Zeile schreibt die Firmware auf das Board - die gerade eben durch die Arduino IDE kompilierte .ino Datei.
```
D:\Users\cooper\AppData\Local\Arduino15\packages\esp8266\tools\python3\3.7.2-post1/python3 D:\Users\cooper\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.6.3/tools/upload.py --chip esp8266 --port COM4 --baud 921600 --before default_reset --after hard_reset write_flash 0x0 D:\Users\cooper\AppData\Local\Temp\arduino_build_165769/Blink.ino.bin 
```
Diesen Befehl kann man nutzen, um jede andere *.bin-Datei auf das ausgewählte Board zu laden.

Ersetzt dafür einfach den letzen Pfad in der Zeile, mit dem Pfad der *.bin-Datei, die ihr auf das Board schreiben wollt.

Der Pfad:
```
D:\Users\cooper\AppData\Local\Temp\arduino_build_165769/Blink.ino.bin
```
wird zu
```
D:\Users\cooper\Desktop\tasmota-DE.bin
```
Der neue Befehl zum Schreiben auf das Board lautet also dann:
```
D:\Users\cooper\AppData\Local\Arduino15\packages\esp8266\tools\python3\3.7.2-post1/python3 D:\Users\cooper\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.6.3/tools/upload.py --chip esp8266 --port COM4 --baud 921600 --before default_reset --after hard_reset write_flash 0x0 D:\Users\cooper\Desktop\tasmota-DE.bin 
```
Firmware flashen

Druckt Win + R und startet die Eingabeaufforderung in dem ihr cmd eintippt.

Kopiert den Befehl zum Schreiben auf das Board und fügt ihn ein.
Anschließend wird die Datei D:\Users\cooper\Desktop\tasmota-DE.bin auf das Board geschrieben.

Falls du eine andere, noch einfachere Möglichkeit suchst, eine Firmware auf deinen Arduino oder ESP zu flashen, kannst du gerne diesen Beitrag von mir hier als Anhalt nutzen:

Natives HomeKit-Schloss Firmware für den ESP8266 D1 Mini.

Dort zeige ich kurz und knackig, wie man mithilfe des NodeMCU PyFlasher eine Firmware flashen kann.
1 Antwort Letzte Antwort
Antworten Zitieren 1

Ähnliche Themen

Dateien auf dem ESP8266 speichern - Das SPIFFS Dateisystem auf dem ESP
arduino-ide d1-mini dateisystem esp8266 spiffs
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

1903
Aufrufe

Wenn es darum geht, Inhalte auf dem ESP8266 zu speichern, stolpert man immer wieder über die selben Begriffe. EEPROM, SPIFFS oder RTC Memory. Alle drei Varianten lassen es zu, Daten auf dem ESP zu speichern. Eine Variante schauen wir uns heute genauer an: Das SPIFFS Dateisystem auf dem ESP8266.
Das SPIFFS Dateisystem
Mit dem SPIFFS Dateisystem können wir auf dem Flash-Speicher zugreifen als wäre es ein Dateisystem auf dem Computer. Wir können Dateien anlegen, Dateien lesen und auch Dateien schreiben. Das Beste an der ganzen Sache ist: die gespeicherten Dateien überleben sowohl einen Deep Sleep als auch einen kompletten Reboot.

Die Größe des SPIFF richtet sich nach dem verwendeten ESP8266-Modell. Während ein D1 Mini mit einem SPIFFS von bis zu 3MB daherkommt, schafft es der ESP01-S gerade mal auf bis zu 512KB - immer noch mehr als genug für viele Anwendungen. In diesem Tutorial verwende ich einen ESP8266 D1 Mini.

Die Größe des SPIFFS kann mithilfe der Arduino IDE eingestellt werden. Geht dazu über das Menü auf folgenden Punkt:
Arduino IDE └── Werkzeuge └── Flash Size ├── 4M (no SPIFFS) ├── 4M (1M SPIFFS) ├── 4M (2M SPIFFS) └── 4M (3m SPIFFS)
Arduino IDE ESP8266 SPIFFS Einstellung
SPIFFS - Die Libary
Um auf die Funktionen des SPIFFS zugreifen zu können, wird eine Bibliothek benötigt. Die Bibliothek ist bereits standardmäßig installiert und kann sofort verwendet werden.

Ich möchte an dieser Stelle direkt mit einem Beispiel starten. Die Erklärung einzelner Bestandteile kommt weiter unten im Text.
// Code by cooper@my.makesmart.net // Released under CC - CC by cooper@my.makesmart.net // Filesystem-Libary einbinden #include <FS.h> // Name der Datei die wir speichern und auslesen möchten const char* datei = "meine.txt"; void setup() { delay(1000); Serial.begin(115200); Serial.println(); Serial.println("ESP gestartet"); // Dateisystem initialisieren if(SPIFFS.begin()){ Serial.println("Dateisystem: initialisiert"); }else{ Serial.println("Dateisystem: Fehler beim initialisieren"); } // Dateisystem formatieren //SPIFFS.format(); // Öffnen der von uns definierten Datei nur mit Leserechten // r - Read - nur Leserechte // w - Write - Schreibrechte File file = SPIFFS.open(datei, "r"); if(!file){ // Die Datei ist nicht vorhanden Serial.println("Die Datei " + String(datei) + " existiert nicht!"); // Datei mit Schreibrechten öffnen, wird erstellt wenn nicht vorhanden File file = SPIFFS.open(datei, "w"); Serial.println("Datei " + String(datei) + " wurde erstellt!"); // Daten in die Datei schreiben file.print("Der Inhalt meiner Datei."); // Schließen der Datei file.close(); }else{ // Die Datei ist vorhanden Serial.println("Die Datei " + String(datei) + " wurde geöffnet!"); // Inhalt ausgeben oder verarbeiten int i; Serial.println(); for(i=0;i<file.size();i++){ Serial.print((char)file.read()); } file.close(); } } void loop() { // Hier wird einfach nur der Inhalt der Datei in Dauerschleife ausgegeben File file = SPIFFS.open(datei, "r"); int i; Serial.println(); for(i=0;i<file.size();i++){ //Serial.print((char)file.read()); Serial.print((char)file.read()); } file.close(); delay(20000); }
Die Ausgabe im seriellen Monitor sieht wie folgt aus:
ESP gestartet Dateisystem: initialisiert Die Datei meine.txt existiert nicht! Datei meine.txt wurde erstellt! Der Inhalt meiner Datei. Erläuterung des Codes
Zu Beginn muss das Dateisystem initialisiert werden. Ansonsten kann weder Lese- noch Schreibzugriff erfolgen.
// Dateisystem initialisieren if(SPIFFS.begin()){ Serial.println("Dateisystem: initialisiert"); }else{ Serial.println("Dateisystem: Fehler beim initialisieren"); }
In der folgenden Variable wird der Name der Datei gespeichert, auf die wir zugreifen wollen. Mithilfe dieser Variable erstellen wir ein neues File-Objekt mit dem Namen file. Über dieses Objekt greifen wir von dort an auf die einzelnen Funktionen der Bibliothek zu.

Es wird also die Datei meine.txt geöffnet.
const char* datei = "meine.txt"; // Öffnen der von uns definierten Datei // r - Read - nur Leserechte // w - Write - Schreibrechte File file = SPIFFS.open(datei, "r");
Die Datei ist (noch) nicht vorhanden. Ob eine Datei vorhanden ist, kann man mit dem gerade eben erstellen Objekt file prüfen.
if(!file){ Serial.println("Die Datei " + String(datei) + " existiert nicht!"); // Datei mit Schreibrechten öffnen / Datei wird erstellt wenn nicht vorhanden File file = SPIFFS.open(datei, "w"); Serial.println("Datei " + String(datei) + " wurde erstellt!") // Daten in die Datei schreiben file.print("Der Inhalt meiner Datei."); // Schließen der Datei file.close(); }
Es wird also die Datei meine.txt erstellt, da sie noch nicht vorhanden ist. Gleichzeit wird der Text Der Inhalt meiner Datei. in der Datei gespeichert.

Beim Neustarten des ESP wird der oben aufgeführte Code nicht mehr ausgeführt, da die Datei dann bereits existiert und die If-Anweisung deshalb übersprungen wird.

Um jetzt mit dem Inhalt der Datei arbeiten zu können, kann der folgende Code verwendet werden. Bei mir ist dieser Block im Setup sowie im Loop.
File file = SPIFFS.open(datei, "r"); int i; Serial.println(); for(i=0;i<file.size();i++){ Serial.print((char)file.read()); } file.close(); delay(20000);
Alle 20 Sekunden wird der Inhalt der Datei ausgegeben. Der serielle Monitor zeigt folgendes an:
ESP gestartet Dateisystem: initialisiert Die Datei meine.txt existiert nicht! Datei meine.txt wurde erstellt! Der Inhalt meiner Datei. Der Inhalt meiner Datei. Der Inhalt meiner Datei. Sind die Dateien auf meinem ESP?
Falls etwas nicht klappt und du ausschließen möchtest, dass es an fehlenden Dateien auf dem Dateisystem liegt, kannst du im setup() folgenden Code verwenden, um dir alle Dateien aus dem SPIFFS anzeigen zu lassen:
Dir dir = SPIFFS.openDir(""); while (dir.next()){ Serial.print(dir.fileName()); File f = dir.openFile("r"); Serial.println(f.size()); } Vorteile des SPIFFS
Das SPIFFS bietet mehrere Vorteile. Es können zum einen Konfigurationen gespeichert werden die entweder direkt auf dem ESP liegen oder auch nachträglich über ein Webinterface o.Ä geändert wurden. Sie gehen nicht mehr verloren.

Wie man sieht ist das SPIFFS, verglichen zu anderen Möglichkeiten, sehr einfach zu verwenden.

Auch für den Batteriebetrieb hat das SPIFFS Vorteile. Anstatt bei jedem Messen der Temperatur oder der Luftfeuchtigkeit die Daten über das WLAN zu senden, können die Messwerte zwischengespeichert und nur jedes 10x an die Zentrale geschickt werden. Das spart ordentlich Energie.

Allgemein ermöglicht das SPIFFS mehr Flexibilität bei Projekten. Ich werde demnächst eine Steuerung für ein Förderband programmieren. Parallel laufen noch anderes Prozesse. Ich habe keine Möglichkeit über Zeit oder über WLAN zu programmieren, also werde ich SPIFFS nutzen. Bei jedem Deep Sleep wird eine Variable um +1 Punkt erhöht. Wenn ein gewisser Schwellenwert erreicht ist, läuft die Steuerung an und setzt den Counter zurück.

Das SPIFFS bietet viele neue Möglichkeiten der Programmierung.
M

digitale Potis
arduino arduino-ide mcp4151 poti
Fragen, Hilfe & Probleme • • MaxMRNK

3

0
Stimmen

3
Beiträge

31
Aufrufe

M

Danke für die Aufklärung 🙂
Zu 2. Muss ich noch eine Formel hinzufügen, damit es logarithmisch wird.
SONOFF Geräte mit der original Firmware via HomeKit steuern - Tutorial
homebridge homekit smarthome sonoff
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

1355
Aufrufe

Wenn es darum geht, ein SONOFF Gerät in HomeKit oder mit einer anderen Smarthome-Plattform außerhalb der eWeLink-App zu steuern, wird oftmals auf die custom Firmware Tasmota zurückgegriffen. Dabei gibt es aber mehrere Hürden: Das Flashen der Firmware unterscheidet sich von Modell zu Modell und gestaltet sich allgemein immer noch schwieriger. Damit ist jetzt Schluss - denn ich zeige euch eine Möglichkeit, wie ihr SONOFF Geräte trotz original-Firmware mit HomeKit steuern könnt.
Die Homebridge auf dem makesmart-server
Realisieren werde ich das ganze mithilfe der Homebridge auf meinem makesmart-server. Ich nutze schon seit gut zwei Jahren Homebridge als Zentrale, um meine Geräte in HomeKit einzubinden. Für die Homebridge gibt es ganz frisch ein Plugin namens homebridge-ewelink.

Wie der Name schon erahnen lässt, lassen sich mithilfe des Plugins die SONOFF Geräte auch mit der original Firmware in HomeKit einbinden.

Dafür muss das Plugin zuerst installiert werden, ich installiere es über die homebridge-config-ui-x indem ich nach dem Begriff ewelink suche.

homebridge-ewelink Plugin installieren
homebridge-ewelink Konfiguration
Nach dem Installieren taucht ein Pop-Up auf, in dem ihr einmal den Ländercode (49) und die Zugangsdaten zu eurem eWeLink Account eingeben müsst.

homebridge-ewewlink Plugin Einstellungen

Die Konfiguration für das Plugin wird danach automatisch erstellt. Die eingegeben Daten werden dazu verwendet, die Konfiguration des Plugins in die config.json einzutragen. Ein Blick in die config.json verrät, was eingetragen wurde:
{ "name": "eWeLink", "countryCode": "49", "username": "deine@mail.de", "password": "deinpasswort", "debug": false, "debugReqRes": false, "sensorTimeLength": 60, "sensorTimeDifference": 120, "valveTimeLength": 20, "hideTHSwitch": false, "hideZBLDPress": false, "groups": [ { "type": "null", "setup": "null", "operationTime": 100 } ], "bridgeSensors": [ { "type": "motion" } ], "platform": "eWeLink" }
Einfacher geht es wohl kaum - zumindest hab ich das selten erlebt.

Als nächstes muss die Homebridge einmal neugestartet werden.
SONOFF Geräte in HomeKit eingebunden
Nach dem Neustarten verrät die Ausgabe der Homebridge-Konsole, dass die SONOFF-Geräte in der eWeLink-App automatisch erkannt und erfolgreich über die lokale IP-Adresse in Homebridge eingebunden wurden.
[9/18/2020, 18:33:48] [eWeLink] [0] eWeLink devices were loaded from the Homebridge cache. [9/18/2020, 18:33:48] [eWeLink] [1] primary devices were loaded from your eWeLink account. [9/18/2020, 18:33:48] [eWeLink] [1] primary devices were discovered on your local network. [9/18/2020, 18:33:48] [eWeLink] [Gerätd1f401] has been added to Homebridge. [9/18/2020, 18:33:48] [eWeLink] [Gerätd1f401] found in eWeLink and locally with IP [192.168.178.98].
Nach einem kurzen Moment taucht mein SONOFF Basic dann auch als Schalter in der Home App auf. Mein Gerät trägt den Namen Gerätd1f401. Dieser wurde aus der eWeLink App übernommen. Der Name kann beliebig direkt in der Home App angepasst werden.

Ich kann ihn nun per Siri steuern, in Automationen einbinden oder für Szenen verwenden.

SONOFF Basic HomeKit Schalter
Arduino IDE - Das Umwandeln und Casten von Datentypen
arduino-ide c++ cast datentypen esp8266
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

50
Aufrufe

Wer sich mit der Arduino IDE und Modulen wie ESP8266, ESP32 oder auch dem Arduino selber beschäftigt, wird früher oder später mal über das Problem stolpern, verschiedene Datentypen zu kombinieren zu wollen, oder auch Datentypen im Allgemeinen umwandeln zu wollen, um die Daten dann in anderen Operationen nutzen zu können. Ein gängiger cast wäre zum Beispiel eine int Variable in eine float Variable umzuwandeln, um damit genauer rechnen zu können.

Leider gib es keine Methode oder Funktion, die universell einsetzbar ist. Es kommt immer ganz drauf an, welchen Datentypen ihr umwandeln wollt, und vor allem welcher Datentyp am Ende rauskommen soll. Hier versuche ich mal alle Gängigen Datentyp-Konvertierungen aufzulisten - gruppiert nach dem gewünschten End-Datentyp.

Habt ihr weitere Vorschläge und Hinweise bzw. Snippets, dann würde ich mich freuen, wenn ihr sie unter diesem Beitrag hier teilen würdet.
Datentyp : String
Integer
int i = 25; String convertedString = String(i); // "25"
Float
float i = 22.5367; String convertedString = String(i, 3); // "22.536"
Bool
bool state = false; String convertedString = String(state ); // "0" Datentyp : Int
String
String number = "255"; int i = number.toInt(); // 255
Float
float number = "123.232"; int i = (int)number; // 123
Char
char myChar[] = "147"; int i= atoi(myChar); // 147 Datentyp : Float
Int
int i = 187; float myFloat= float(i); // 187.00
String
String number = "14.2653"; float i = number.toFloat(); // 14.2653
Arduino IDE - Arbeiten mit JSON Objekten für Einsteiger - Tutorial
api arduino-ide arduino-json d1-mini esp8266 json spiffs
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

990
Aufrufe

Die JavaScript Object Notation - JSON - ist ein kompaktes Datenformat in einer einfach lesbaren Textform und dient unter anderem zum Datenaustausche zwischen Anwendungen. Egal ob als Konfigurationsdatei, zum Übertragen von Daten via API oder auch zum Speichern in einer Datenbank wie MongoDB. JSON Objekte sind nicht mehr wegzudenken - und das ist ein guter Grund das ganze auch auf einem Mikrocontroller wie ESP866, D1 Mini, Arduino & Co. zu nutzen.

Nehmen wir an, wir programmieren eine kleine Software für eine Lampe mit einer Konfiguration für einen adessierbaren LED-Streifen. Diese Konfiguration möchten wir gerne im JSON-Format abspeichern, sodass wir sie einerseits beispielsweise über das SPIFFS-Dateisystem auslesen können, aber auch, damit wir über eine API die Paramater des JSON-Objekts einfach ändern und anpassen können, wenn wir dies wollten.

Eine ganz einfache JSON Konfiguration könnte so aussehen - zwei Keys und dazugehörige Values:
{ "name": "Lampe", "numLEDs": 75 } ArduinoJson - Arduino IDE Library hinzufügen
Bevor wir damit anfangen, mit einem JSON Objekt zu arbeiten, muss zuerst eine passenden Library installiert werden. Die Library heißt ArduinoJson. Libraries werden immer gleich installiert. Und zwar über den Bibliotheksverwalter innerhalb der Arduino IDE.
Arduino IDE └───Werkzeuge └───Bibliotheken verwalten...
Die Library kann über die Eingabe in der Suche gefunden werden

makesmart arduino json verarbeiten

Mit der Installation der Library können wir auf alle Klassen, Objekte und Methoden dieser zugreifen und starten, JSON Objekte innerhalb der Arduino IDE zu erstellen, zu bearbeiten und auszulesen.
Arduino IDE - JSON Objekt erstellen
Wir starten mit einem leeren Programm, in dem die Library ArduinoJson bereits eingebunden wurde.
#include <ArduinoJson.h> void setup() { // Setup läuft einmal Serial.begin(115200); Serial.println("makesmart ESP8266"); } void loop() { // Loop läuft in Endlosschleife }
Mit dem Import der Library sind wir auch sofort in der Lage ein JSON-Objekt zu erstellen. Und zwar mit der Klasse DynamicJsonDocument.
void setup() { // Setup läuft einmal Serial.begin(115200); Serial.println("makesmart ESP8266"); // Eine kleine Pause für uns delay(1000); // Hier wird das JSON-Objekt erstellt DynamicJsonDocument configJSON(1024); configJSON["name"] = "Lampe"; configJSON["numLEDs"] = 75; serializeJson(configJSON, Serial); }
Die Ausgabe im seriellen Monitor sieht nach dem Hochladen wie folgt aus:
{"name":"Lampe","numLEDs":24}
Mithilfe des Webservices JsonLint lässt sich das JSON-Objekt leicht lesbar formatieren:
{ "name": "Lampe", "numLEDs": 24 }
Das hinzufügen von weiteren Key- und Value-Paaren ist genauso simple, wie das eben erstellte JSON-Objekt:
// Hier wird das JSON-Objekt erstellt DynamicJsonDocument configJSON(1024); configJSON["name"] = "Lampe"; configJSON["numLEDs"] = 75; configJSON["endpoint"] = "/api/lamp"; serializeJson(configJSON, Serial); { "name": "Lampe", "numLEDs": 24, "endpoint": "/api/lamp" } ArduinoJSON - erstellen von Arrays Einfaches Array als Liste mit Werten
Arrays sind Listen, Listen mit Werten. Lasst uns annehmen: Unsere Lampe hat verschiedene Animationen. Diese Animationen werden je druch eine eigene Bezeichnung definiert. Das Array mit den Bezeichnungen der Animationen könnte so aussehen:
String animations[] = {"demo", "fire", "ocean", "fade"}; ["demo", "fire", "ocean", "fade"]
Um dieses Array in unser JSON Objekt zu bekommen, können wir eine nützliche Funktion aus der Library verwenden - add().

Dafür erstellen für einen Loop, der jeden Eintrag im Array String animations[] druchläuft, und den aktuellen Wert per add() zu unserem JSON Objekt hinzufügt:
String animations[] = {"demo", "fire", "ocean", "fade"}; // for-Schleife, die das Array 'animations[]' durchläuft for (byte i = 0; i < (sizeof(animations)/sizeof(animations[0])); i++) { // animations[i] enthält den aktuellen Wert vom Array und wird per 'add()' zum Objekt hinzugefügt configJSON["animations"].add(animations[i]); }
Das Objekt sieht anschließend folgendermaßen aus:
{ "name": "Lampe", "numLEDs": 24, "endpoint": "/api/lamp", "animations": ["demo", "fire", "ocean", "fade"] } Arrays mit Objeken
Was wäre denn, wenn wir nicht nur einen Endpoint haben möchten, sondern vielleicht zwei? Diese beiden Endpoints können wir ebenfalls in einem Array speichern. Das Array enthält dabei nicht nur zwei Werte, sondern zwei Objekte - unserer beiden Endpoints.

Wir ersetzen den Key endpoint in unserem Objekt durch ein Array mit dem Key endpoints.
In diesem Array speichern wir zwei Objekte:
configJSON["endpoints"][0]["switchOn"] = "/api/lamp/switchOn"; configJSON["endpoints"][1]["switchOff"] = "/api/lamp/switchOff"; serializeJson(configJSON, Serial); { "name": "Lampe", "numLEDs": 24, "endpoints": [ { "switchOn": "/api/lamp/switchOn" }, { "switchOff": "/api/lamp/switchOff" } ], "animations": ["demo", "fire", "ocean", "fade"] }
Wir sehen, dass wir ein Array endpoints[] erhalten und darin sind zwei Objekte. Einmal mit dem Key switchOn und einmal mit dem Key switchOff. Natürlich können wir auch mehrere Key- und Value-Paare in einem Objekt innerhalb eines Arrays speichern. Dazu muss lediglich an der gleichen Index-Position des Arrays ein weiteres Paar hinzugefügt werden:
configJSON["endpoints"][0]["switchOn"] = "/api/lamp/switchOn"; configJSON["endpoints"][0]["desc"] = "Turn the lights on!"; configJSON["endpoints"][1]["switchOff"] = "/api/lamp/switchOff"; configJSON["endpoints"][1]["desc"] = "Turn the lights off!"; serializeJson(configJSON, Serial); { "name": "Lampe", "numLEDs": 24, "endpoints": [ { "switchOn": "/api/lamp/switchOn", "desc": "Turn the lights on!" }, { "switchOff": "/api/lamp/switchOff", "desc": "Turn the lights off!" } ], "animations": ["demo", "fire", "ocean", "fade"] } Objekte im Objekt
Das mit den gerade eben aufgeführten Objekten in Arrays ist auch so ähnlich gültig für Objekte in Objekten.
{ { // OBJ 1 } { // OBJ 2 } { // OBJ 2 } }
Wir erstellen ein neues Objekt ledSettings. Dieses Objekt erhält von uns vier verschiedene Key- Value-Paare:
configJSON["ledSettings"]["chip"] = "WS2812B"; configJSON["ledSettings"]["colorOrder"] = "GRB"; configJSON["ledSettings"]["framerate"] = "60"; configJSON["ledSettings"]["brightness"] = "100";
Wir fügen in unsere configJson also ein Objekt ein mit der Bezeichnung ledSettings.
Dieses Objekt erhält von uns vier Eigenschaften: chip, colorOrder, framerate, brightness mit den dazugehörigen Values:
{ "name": "Lampe", "numLEDs": 24, "endpoints": [ { "switchOn": "/api/lamp/switchOn", "desc": "Turn the lights on!" }, { "switchOff": "/api/lamp/switchOff", "desc": "Turn the lights off!" } ], "animations": ["demo", "fire", "ocean", "fade"], "ledSettings": { "chip": "WS2812B", "colorOrder": "GRB", "framerate": "60", "brightness": "100" } }
Das ganze Spielchen mit Objekten, Listen, Listen mit Objekten und Objekte mit Listen lässt sich beliebig oft wiederholen und ist sehr flexibel und vor allem auch sehr verschatelt anwendbar. Auch wenn es im ersten Moment kompliziert aussieht, ist es eigentlich doch ziemlich selbsterklärend, vor allem wenn man das Prinzip einer Objektorientierten Datenerfassung / Verarbeitung verstanden hat. Hier nochmal der bisherige Code:
void setup() { // Setup läuft einmal Serial.begin(115200); Serial.println("makesmart ESP8266"); // Eine kleine Pause für uns delay(1000); // Hier wird das JSON-Objekt erstellt DynamicJsonDocument configJSON(1024); configJSON["name"] = "Lampe"; configJSON["numLEDs"] = 75; configJSON["endpoints"][0]["switchOn"] = "/api/lamp/switchOn"; configJSON["endpoints"][0]["desc"] = "Turn the lights on!"; configJSON["endpoints"][1]["switchOff"] = "/api/lamp/switchOff"; configJSON["endpoints"][1]["desc"] = "Turn the lights off!"; // String array[] welches unserer Werte enthält String animations[] = {"demo", "fire", "ocean", "fade"}; // for-Schleife, die das Array 'animations[]' durchläuft for (byte i = 0; i < (sizeof(animations)/sizeof(animations[0])); i++) { // animations[i] enthält den aktuellen Wert vom Array und wird per 'add()' zum Objekt hinzugefügt configJSON["animations"].add(animations[i]); } // Hier wird ein Objekt 'ledSettings' innerhalb von dem Objekt 'configJSON' erstellt configJSON["ledSettings"]["chip"] = "WS2812B"; configJSON["ledSettings"]["colorOrder"] = "GRB"; configJSON["ledSettings"]["framerate"] = "60"; configJSON["ledSettings"]["brightness"] = "100"; serializeJson(configJSON, Serial); }
Die Ausgabe des Objektes erscheint jetzt nur im seriellen Monitor. Grund dafür ist die folgende Zeile:
serializeJson(configJSON, Serial);
Um das Objekt in einer Variable zu speichern, kann man folgendes tun:
// Varbiable anlegen String meineJson; // configJSON in meineJSON speichern serializeJson(configJSON, meineJson); // meineJSON auf dem seriellen Monitor ausgeben Serial.println(meineJson);
Die Variable meineJson kann jetzt verwendet werden, um das Objekt in einer Datei zu speichern. Dazu kann ich dir mein Tutorial zum SPIFFS-Dateisystem auf dem ESP8266 empfehlen. Außerdem könnte es so auch 1:1 an eine API gesendet werden, über die die Daten dann auf eine andere Art und Weise weiterverarbeitet werden können.

So viel mal zum erstellen von JSON-Dateien und Objekten innerhalb der Arduino IDE. Wie sieht es aber mit dem Auslesen aus?
Werte aus einem JSON Objekt auslesen
Das Objekt wurde erstellt, die Konfiguration wurde gespeichert und wir sind bereit damit zu arbeiten. Aber wie komme ich jetzt an die Werte einer JSON-Datei? Zuerst möchte ich erwähnen, dass es hier jetzt keinen Unterschied macht, ob man das Objekt selbst erstellt hat, oder ob man es von einer API verarbeitet. JSON ist JSON und die Anwendung bleibt die gleiche, egal woher das JSON kommt.

Gehen wir einfach mal davon aus, dass sich das JSON-Objekt in der Variable meineJson befindet.
Diese Variable enthält das JSON Objekt ausgelesen via SPIFFS, API oder was auch immer als String.
String meineJson = "{....}";
Um an die Werte zu kommen starten wir mit diesem Snippet:
String meineJson = "{....}"; DynamicJsonDocument config(1024); DeserializationError error = deserializeJson(config, meineJson); if (error) return;
Für das JSON meineJson wird im ersten Schritt ein neuer JSON Buffer angelegt: DynamicJsonDocument config(1024);.

Ausgelesen bzw. deserialisiert wird das Objekt dann final mit deserializeJson(config, meineJson); wobei meineJson unser JSON-Objekt als String enthält und config die Bezeichnung unserers gerade erstellen Buffers ist.

Die Values der einzelnen Keys können wir dann ziemlich einfach in Variablen speichern:
// Diese Variabe enthält ein JSON-Objekt String meineJson = "{....}"; // Hier wird ein neuer Buffer erzeugt, mit dem wir an die Werte kommen DynamicJsonDocument config(1024); DeserializationError error = deserializeJson(config, meineJson); if (error) return; // Hier lesen wir die Werte über den Buffer aus String name = config["name"]; Serial.println(name);
Output:
Lampe
Tatsächlich funktioniert es fast 1:1 wie beim Speichern eines Objektes. Also sollte auch das Auslesen von Objekten oder Werten einzelner Keys im Objekt kein Problem sein. Ich möchte jetzt an die Einstellung der Helligkeit kommen:
int brightness = config["ledSettings"]["brightness"]; Serial.println(brightness);
Output:
100
Ihr seht: es ist gar nicht kompliziert auch auf einem Mikrocontroller den Komfort von JSON-Objekten zu nutzen. So wird die Kommunikaton via API wesentlich leichter und auch die Einrichtung einer Konfiruation mittels Spiffs ist in Zukunft kein Problem mehr.

Das war nur ein kleiner Einblick in die sehr umfangreiche Library ArduinoJSON. Es gibt noch viel mehr Möglichkeiten das ganze umzusetzen. Außerdem gibt es noch eine ganze Reihe an nützlichen Funktionen die ebenfalls in dieser Library enthalten sind. Aber das würde den Rahmen hier sprengen: Außerdem gibt es ja genau für sowas die Dokumentation.

#API #Arduino-IDE #Arduino-JSON #D1-Mini #ESP8266 #JSON #SPIFFS

Firmware mithilfe der Arduino IDE flashen

Vorbereitungen

Firmware flashen

Ähnliche Themen

Dateien auf dem ESP8266 speichern - Das SPIFFS Dateisystem auf dem ESP arduino-ide d1-mini dateisystem esp8266 spiffs Tipps, Tricks & Tutorials • • cooper

digitale Potis arduino arduino-ide mcp4151 poti Fragen, Hilfe & Probleme • • MaxMRNK

SONOFF Geräte mit der original Firmware via HomeKit steuern - Tutorial homebridge homekit smarthome sonoff Tipps, Tricks & Tutorials • • cooper

Arduino IDE - Das Umwandeln und Casten von Datentypen arduino-ide c++ cast datentypen esp8266 Tipps, Tricks & Tutorials • • cooper

Arduino IDE - Arbeiten mit JSON Objekten für Einsteiger - Tutorial api arduino-ide arduino-json d1-mini esp8266 json spiffs Tipps, Tricks & Tutorials • • cooper

Dateien auf dem ESP8266 speichern - Das SPIFFS Dateisystem auf dem ESP
arduino-ide d1-mini dateisystem esp8266 spiffs
Tipps, Tricks & Tutorials • • cooper

digitale Potis
arduino arduino-ide mcp4151 poti
Fragen, Hilfe & Probleme • • MaxMRNK

SONOFF Geräte mit der original Firmware via HomeKit steuern - Tutorial
homebridge homekit smarthome sonoff
Tipps, Tricks & Tutorials • • cooper

Arduino IDE - Das Umwandeln und Casten von Datentypen
arduino-ide c++ cast datentypen esp8266
Tipps, Tricks & Tutorials • • cooper

Arduino IDE - Arbeiten mit JSON Objekten für Einsteiger - Tutorial
api arduino-ide arduino-json d1-mini esp8266 json spiffs
Tipps, Tricks & Tutorials • • cooper