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).

Relais beim ersten Knopfdruck HIGH, beim zweiten Knopfdruck LOW setzen

Fragen, Hilfe & Probleme

237

Anmelden zum Antworten

justtn_ zuletzt editiert von

Hi - habe ein Problem bzw. komme gerade nicht weiter, weil mir das nötige Wissen fehlt.

Ich möchte mithilfe von einem Arduino Uno auf Knopfdruck ein Relais auf HIGH setzen, soweit komme ich.

Aber wie setze ich das Relais wieder LOW wenn der Knopf das zweite mal gedrückt wird?
1 Antwort Letzte Antwort
Antworten Zitieren 0
Jonas zuletzt editiert von

Ich kenne mich zwar nicht mit Relais aus, jedoch könntest du das doch mittels einer Hilfsvariable machen die du nach jedem Knopfdruck änderst. Das sollte dazu führen, dass du mittels einer if-Abfrage und einem else das Relais High setzt, wenn die Variable (ein boolean) false ist und wieder Low, wenn die Variable true ist.
1 Antwort Letzte Antwort
Antworten Zitieren 1
justtn_ zuletzt editiert von

Habs genau so gemacht. Danke!
1 Antwort Letzte Antwort
Antworten Zitieren 0

Ähnliche Themen

Der eigene Discord Bot mit discord.js
bot discord discord.js javascript programmieren
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

1829
Aufrufe

Wenn es darum geht, den eigenen Discord Bot zu programmieren, sind zwei Programmiersprachen besonders im Trend: Python und Javascript in der Laufzeitumgebung Node.js. Und genau um letzteres geht es heute. In diesem Tutorial möchte ich zusammen mit euch den ersten eigenen Discord-Bot mithilfe von discord.js programmieren.

In der Anleitung werden wir ein Template verwenden, welches mir freundlicherweise von @AllerEchteNlmyr zur Verfügung gestellt wurde.
Vorbereitungen
Bevor der eigene Bot mit Javascript programmiert werden kann, muss Node.js auf deinem System installiert sein. Du kannst es prüfen, in dem du die Kommandozeile deines Computers aufrufst und folgenden Befehl in der Konsole absetzt:
node -v
Ich habe Node.js installiert und bekomme folgende Rückmeldung:
C:\Users\cooper>node -v v14.15.1
Falls du Node noch nicht installiert hast, solltest du das jetzt unbedingt tun. Eine Anleitung zur Installation unter Linux findest du hier: Installation und Update von Node.js und NPM unter Linux. Für die Installation unter Windows oder MacOS kannst du den Installer von Node.js verwenden: nodejs.org - Node.js Installer herunterladen
Das Bot-Verzeichnis
In Node.js gibt es viele Module, die man herunterladen und verwenden kann. Auch für unseren eigenen Bot werden wir ein solches Modul verwenden und erstellen. Dank eines Befehls via NPM geht das ziemlich einfach.

Erstellt zunächst einen Ordner in dem ihr den Bot speichern und programmieren möchtet.
Mein Ordner trägt den Namen makesmart-discord-bot.

In diesem Ordner müsst ihr die Konsole öffnen. Navigiert dazu entweder manuell - via Konsole - in den Ordner, oder öffnet die Konsole direkt aus dem geöffneten Ordner heraus:

Datei -> Windows PowerShell öffnen -> Windows PowerShell öffnen

makesmart_windows_powershell
PS D:\Users\cooper\Desktop\makesmart-discord-bot>
Um den eigenen Discord Bot zu initialisieren setzen wir folgenden Befehl in der Konsole ab: npm init.

Nach dem Absenden des Befehls werden euch einige Fragen zu eurem Paket gestellt. Unter anderem wird nach dem Namen und der Version gefragt. Da das unser eigenes Paket ist, können wir die Parameter alle selber bestimmen.
package name: (makesmart-discord-bot) makesmart-discord-bot version: (1.0.0) 1.0.0 description: Little discord bot from cooper@makesmart entry point: (index.js) index.js test command: git repository: keywords: author: license: (ISC) About to write to D:\Users\cooper\Desktop\makesmart-discord-bot\package.json: { "name": "makesmart-discord-bot", "version": "1.0.0", "description": "Little discord bot from cooper@makesmart", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "author": "", "license": "ISC" } Is this OK? (yes)
Mit der Eingabe von yes wird unser Paket initialisiert und die Datei package.json erstellt, mit Inhalt gefüllt und abschließend gespeichert.

Der Ordner makesmart-discord-bot ist nun nicht mehr leer sondern enthält Informationen zu unserem Paket in der package.json.
makesmart-discord-bot └───package.json Die Installation von discord.js
Um das discord.js Modul zu installieren, verwenden wir ebenfalls den Paketmanager NPM. Auch dieser Befehl wird wieder direkt innerhalb des Ordners makesmart-discord-bot ausgeführt.

Der Befehl zum installieren des Moduls lautet: npm install discord.js.
PS D:\Users\cooper\Desktop\makesmart-discord-bot> npm install discord.js npm notice created a lockfile as package-lock.json. You should commit this file. npm WARN makesmart-discord-bot@1.0.0 No repository field. + discord.js@12.5.1 added 15 packages from 17 contributors and audited 15 packages in 3.292s found 0 vulnerabilities
In unserem Ordner wurde das Paket discord.js installiert. Das Paket sowie alle Abhängigkeiten befinden sich im Order node_modules.
makesmart-discord-bot └─── node-modules └─── package.json └─── package-lock.json
Wir haben unserer Ordnerstruktur soweit fertig und können uns dem Template widmen.
Das Template
Wie bereits erwähnt verwende ich in diesem Tutorial ein Template von @AllerEchteNlmyr. Das Template könnt ihr euch direkt hier herunterladen:

makesmart-discord-template.zip

Entpackt das Archiv und speichert alle Dateien in dem Order eures Bots. Das Verzeichnis sollte dann wie folgt aussehen:
makesmart-discord-bot ├───commands ├───node-modules └───utils └─── package.json └─── package-lock.json └─── index.js Discord Bot anlegen
Um einen Discord Bot zu programmieren, muss er zuerst über die Developer-Konsole von Discord angelegt werden. Das geht über diesen Link: https://discord.com/developers/applications

makesmart_discord_bot_new_application

Vergebt eurer App einen passenden Namen und erstellt sie. Anschließend kann links über das Menü der Bot innerhalb der Applikation erstellt werden.

makesmart_add_discord_bot.png

Um die Präsenz eines Users triggern zu können, muss ein Haken bei den folgenden Einstellungen aktiviert sein:
PRESENCE INTENT If your bot tracks presence data, you may need the presence intent to receive presence event data. [YES] SERVER MEMBERS INTENT If your bot tracks server members or downloads the entire member list, you may need the server members intent to receive member events and the member list. [YES]
Abschließend kann der Token des Bots kopiert und gespeichert werden.

makesmart_discord_bot_show_token.png

Zu guter letzt muss der Bot noch zum Server hinzugefügt werden. Geht dazu innerhalb der erstellen Applikation links im Menü auf OAuth2 und setzt einen Haken bei bot. Im Textfeld taucht ein Link aus, mit dem ihr den Bot auf euren Server einladen könnt.

Nachdem der Bot erstellt wurde, können für den Bot weitere Berechtigungen festgelegt werden.
Zum üben und probieren könnt ihr eurem eigenen Bot einfach die Berechtigung Administrator geben.
Der erste Start
Bevor der Bot das erste mal gestartet werden kann, muss der gerade eben kopierte Token in der config.json im Ordner utlis eingefügt werden.
{ "token": "NzgyNTcTNjc5MjY3ODk2MYQ1.X7OT2A.Ex4XlxDzN3kRZNAzRHP9BDht8II", "prefix": "ms." }
Der Value von prefix bestimmt, wie die commands des Bots aufgerufen werden. In diesem Fall würden die commands wie folgt aussehen:
ms.start ms.show ms.ban ms.poll
Nachdem der Token eingetragen und die Datei gespeichert wurde, kann der Bot das erste Mal gestartet werden. Das passiert wieder über die Konsole innerhalb des Bot-Ordners:
PS D:\Users\cooper\Desktop\makesmart-discord-bot> node index.js
Der Bot wurde erfolgreich eingeloggt und lauscht nun nach Befehlen im Chat:
PS D:\Users\cooper\Desktop\makesmart-discord-bot> node index.js Logged in as cooper-bot-tutorial#6189!
Egal was wir schreiben, es wird nichts passieren. Denn es wurde noch keine Aktion für einzelne Commands festgelegt. Lediglich der Prefix wurde definiert.
Der erste eigene Befehl
Öffnet den Ordner commands und darin die Datei command.js.
const Discord = require("discord.js"); const fs = require("fs"); const config = JSON.parse(fs.readFileSync("./utils/config.json", "utf8")); module.exports = { name: "command", description: "This is a command!", execute(message, args){ } }
Als leichtes Beispiel, werden wir innerhalb der Konsole ausgeben lassen, wenn wir eine Nachricht mit dem command command erhalten.

Das geht mithilfe von console.log("Nachricht mit command 'command' erhalten.");
const Discord = require("discord.js"); const fs = require("fs"); const config = JSON.parse(fs.readFileSync("./utils/config.json", "utf8")); module.exports = { name: "command", description: "This is a command!", execute(message, args){ console.log("Nachricht mit command 'command' erhalten."); } }
Damit der Bot den command auch erfasst, muss dieser in der Datei index.js festgelegt werden.
client.on("message", message => { if(!message.content.startsWith(config.prefix) || message.author.bot) return; const args = message.content.slice(config.prefix.length).split(/ +/); const command = args.shift().toLowerCase(); if(command === "help"){ client.commands.get("help").execute(message, args); } });
Ersetzt den Befehl help durch den in der commands/command.js definierten command.
if(command === "command"){ client.commands.get("command").execute(message, args); }
Vergesst nicht, das Programm in der Konsole mithilfe von Strg + C zu beenden, um es dann wieder mit node index.js zu starten, da die Änderungen sonst nicht wirksam werden.

Sobald wir innerhalb von Discord jetzt ms.command senden, erhalten wir die Ausgabe in der Konsole:
PS D:\Users\cooper\Desktop\makesmart-discord-bot> node index.js Logged in as cooper-bot-tutorial#6189! Nachricht mit command 'command' erhalten. Zusammenfassung Prefix
Der Prefix, mit dem die Funktionen des Bots aufgerufen werden, muss immer vorangestellt werden.

Egal ob ms.command, !command oder ?command, der Prefix wird in der Datei utils/config.json festgelegt.
{ "token": "NzgyNTcTNjc5MjY3ODk2MYQ1.X7OT2A.Ex4XlxDzN3kRZNAzRHP9BDht8II", "prefix": "ms." } Commands
Es ist ratsam, für jeden command eine eigene Datei anzulegen. Die Dateien für die commands werden automatisch von der index.js eingebunden. Die Dateien für die einzelnen commands befinden sich unter commands/*.

Der Name der Datei hat nichts mit dem command an sich zu tun. Die Paramater werden in der Datei nochmal einzeln definiert. Wobei der Wert von name der eigentliche command ist.
module.exports = { name: "meinCommand", description: "This is a command!", execute(message, args){ } } Command ausführen
Commands werden in der index.js ausgeführt. Wenn der Bot eine Nachricht erhält der mit einem command beginnt, wird die execute()-Funktion des jeweiligen commands aufgerufen.
if(command === "meinCommand"){ client.commands.get("meinCommand").execute(message, args); } const Discord = require("discord.js"); const fs = require("fs"); const config = JSON.parse(fs.readFileSync("./utils/config.json", "utf8")); module.exports = { name: "meinCommand", description: "This is a command!", execute(message, args){ console.log("Nachricht mit command 'meinCommand' erhalten."); } }
Weiteres wird folgen…

Wollt ihr wissen, wie ihr einen Discord-Bot mit Slash-Commands programmiert? Dann schaut euch gerne das Tutorial von @merlin an.
Tutorial: Der eigene Discord Bot mit Slash Commands
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

2912
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
G

HomeKit-ESP8266 osapi.h: No such file or directory?
arduino-ide d1-mini homekit smarthome
Fragen, Hilfe & Probleme • • goni

4

0
Stimmen

4
Beiträge

232
Aufrufe

M

Hallo goni,

ich bin derzeit ebenfalls mit diesem Projekt beschäftigt und hatte das gleiche Problem. Bei mir lag es daran, dass ich das falsche Board eingestellt hatte. Dies kannst du über Werkzeuge>Board ändern.
Ich nutze das “AZDelivery 3 x D1 Mini V3 NodeMCU ESP8266EX WLAN Modul” und musste dementsprechend noch eine BoardverwalterURL (Unter Arduino>Einstellungen) hinzufügen.

Diese Seite bietet eine entsprechende Anleitung zu meinem Board:
https://www.makershop.de/nodemcu-installieren/
Falls du ein anderes hast, solltest du dementsprechend mal auf Google suchen

Ich hoffe dir hilft das weiter, bin selber neu hier und bei meinen ersten Versuchen (abgesehen von einer einfachen WLED Installation)
Wie kann ich ein 2. Relais mit dem D1 Mini anteuern?
d1-mini relais steuerung webserver
Fragen, Hilfe & Probleme • • justtn_

2

1
Stimmen

2
Beiträge

716
Aufrufe

Hey willkommen im Forum erstmal 🙂

Zuerst wollte ich anmerken, dass wenn du einen Code postest, kannst du die Sprache definieren - dann wird alles schön formatiert. 😍 Dazu einfach die Sprache mit in die erste Zeile schreiben, also in dem Fall

```arduino
dein Code
```

Zuerst musst du zusätzlich das zweite Relais definieren, also an welchem Pin das Relais angeschlossen ist. In dem Fall ist es Pin D8. Die Definitionen kannst du aus dem Datenblatt vom D1 Mini entnehmen.

Pin D8 wird mit 15 in der Software definiert - du nimmst in der Software immer die GPIO-Bezeichnungen. Nicht die Pin-Bezeichnungen.
//Signal-Pin des Relais: D1 int relay_pin = 5; //Signal-Pin des Relais 2: D8 int relay2_pin = 15;
Dann im Setup natürlich auch definieren, dass der Pin ebenfalls ein Output ist:
pinMode(relay2_pin, OUTPUT);
Dann brauchst du auch noch die beiden Funktionen, die dein zweites Relais betätigen. Kannst du eigentlich 1:1 aus deinem Code kopieren und anpassen:
void relay_on(){ digitalWrite(relay_pin, HIGH); } void relay_off(){ digitalWrite(relay_pin, LOW); } void relay2_on(){ digitalWrite(relay2_pin, HIGH); } void relay2_off(){ digitalWrite(relay2_pin, LOW); }
Und zu guter Letzt halt nur noch deine beiden Pfade vom zweiten Relais vom Webserver definieren:
server.on("/relay2_on", []() { server.send(200, "text/plain", "Relais 2 wurde angeschaltet."); relay2_on(); }); server.on("/relay2_off", []() { server.send(200, "text/plain", "Relais 2 wurde ausgeschalten."); relay2_off(); });
Das Relais kannst du jetzt mit den beiden Links schalten:
http://192.168.0.150/relais2_on http://192.168.0.150/relais2_off
Joa, und das wars eigentlich schon. 🙂
Mister T 2.0 mit Wassertank
3d-druck d1-mini maschine mistert relais smart-kitchen smarthome webserver
Projekte, DIY & Präsentationen • • 3d.flo

12

5
Stimmen

12
Beiträge

354
Aufrufe

@3d-flo hast du schon weiter gemacht mit deinem MisterT?

Relais beim ersten Knopfdruck HIGH, beim zweiten Knopfdruck LOW setzen

Ähnliche Themen

Der eigene Discord Bot mit discord.js bot discord discord.js javascript programmieren 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

HomeKit-ESP8266 osapi.h: No such file or directory? arduino-ide d1-mini homekit smarthome Fragen, Hilfe & Probleme • • goni

Wie kann ich ein 2. Relais mit dem D1 Mini anteuern? d1-mini relais steuerung webserver Fragen, Hilfe & Probleme • • justtn_

Mister T 2.0 mit Wassertank 3d-druck d1-mini maschine mistert relais smart-kitchen smarthome webserver Projekte, DIY & Präsentationen • • 3d.flo

Der eigene Discord Bot mit discord.js
bot discord discord.js javascript programmieren
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

HomeKit-ESP8266 osapi.h: No such file or directory?
arduino-ide d1-mini homekit smarthome
Fragen, Hilfe & Probleme • • goni

Wie kann ich ein 2. Relais mit dem D1 Mini anteuern?
d1-mini relais steuerung webserver
Fragen, Hilfe & Probleme • • justtn_

Mister T 2.0 mit Wassertank
3d-druck d1-mini maschine mistert relais smart-kitchen smarthome webserver
Projekte, DIY & Präsentationen • • 3d.flo