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

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

ESP32-Cam Programmieren - Einrichtung als Livestream-Server
arduino arduino-ide define esp32 esp32-cam livestream smarthome webserver
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

1753
Aufrufe

Der ESP32 ist wie der ESP8266 ein 32-bit ausgeführter Mikrocontroller. Neben einer integrierten WLAN-Funktion hat der ESP32 aber noch einiges mehr zu bieten. Zum Beispiel ein zusätzliches Bluetooth-Modul, mit dem man unter anderem BLE Beacons orten kann. Nicht nur hardwaretechnisch ist der ESP32 dem ESP8266 überlegen - auch an Geschwindigkeit gibt der ESP32 weitaus mehr her. Und genau das machen wir uns heute mit der ESP32-Cam zu nutzen.

Die ESP32-Cam ist kein Modul sondern ein eigenständiges ESP32-Board mit integriertem Kamera- und SD-Kartenmodul. Mit der Kamera kann man Bilder schießen, Videos aufnehmen oder sogar einen Livestream einrichten, auf den man über den Webbrowser zugreifen kann. Perfekt geeignet für eine Low-Budget Überwachungskamera. Unser heutiges Projekt.

Für dieses Projekt werden folgende Produkte benötigt:

Ein Breadboard ist zwar nicht unbedingt nötig, erleichtert aber wie immer die Bedienung und Verdrahtung. Bei dem USB-TTL-Converter ist darauf zu achten, dass er in der Lage ist 5V Spannung zu liefern, anderenfalls kann die ESP32-Cam nicht programmiert werden.
Arduino IDE Libraries installieren
Wie beim ESP8266 muss auch für den ESP32 ein zusätzlicher Boardverwalter innerhalb der Arduino IDE installiert werden, damit das Board und die Dateien dafür gefunden werden können.

Zusätzliche Boardverwalter kann man unter Arduino -> Einstellungen hinzufügen.

In der Textbox Zusätzliche Boardverwalter-URLs muss folgender Link eingetragen werden: https://dl.espressif.com/dl/package_esp32_index.json.

Sollte in der Textbox bereits ein Boardverwalter-Link für z.B den ESP8266 gespeichert sein, könnt ihr das erweiterte Fenster öffnen, in dem ihr auf das folgende Icon klickt:

arduino_ide_zusaetzliche_boardverwalter_urls.png

Nachdem ihr 2x auf Ok gedrückt habt, kann das Board und die Einstellungen dafür installiert werden.
Arduino IDE ESP32 Board installieren
Boards lassen sich über den Boardverwalter installieren. Ihr findet ihn unter

Werkzeuge -> Board -> Boardverwalter

Sucht im Boardverwalter anschließend nach ESP32 und installiert das offizielle Paket von ESPRESSIF Systems.

arduino_ide_esp32_espressif_systems.png

Nach der Installation habt ihr in der Liste eurer Boards sämtliche ESP32-Boards aufgelistet, die ihr auswählen und programmieren könnt.

Geht innerhalb der Arduino IDE auf Werkzeuge -> Board und wählt als zu programmierendes Board das ESP32 Wrover Module aus.

Damit es während dem Hochladen zu keinen Problemen kommt, solltet ihr die Einstellungen mit euren vergleichen und diese dementsprechend ändern, falls nötig.

arduino_ide_esp32-cam_einstellungen.png

Besonders wichtig sind diese Einstellungen:
Upload Speed: "115200" Partition Scheme: "Huge APP (3MB No OTA/1MB SPIFFS)"
Da sonst Fehler beim Hochladen auftreten.

Das war es soweit schon zur Vorbereitung der Entwicklungsumgebung. Kommen wir zum elektrischen Teil.
Die Verdrahtung zum Programmieren
Für die Programmierung wird ein USB-TTL-Converter benötigt, da die ESP32-Cam keine USB-Schnittstelle besitzt. Wichtig ist wie bereits erwähnt, dass der Programmer 5V Spannung liefert.

Wie auch bei ESP8266 Modulen und anderen Mikrocontrollern die über eine serielle Schnittstelle programmiert werden, muss folgendermaßen verdrahtet werden:
ESP32-S Cam USB-TTL Programmer 5V 5V UOR TxD UOT RxD GND GND
Zusätzlich müssen an der ESP32-Cam noch die Pins IO0 und GND miteinander gebrückt werden, um die ESP32-Cam in den Flash-Modus zu versetzen. Fehlt diese Brücke, so kann kein Programm hochgeladen werden.

esp32-cam_programming_pinout.png
Der Livestream Webserver
Glücklicherweise gibt es beim auch beim ESP32 wieder sehr viele Beispiele, an denen man sich orientieren kann. Auch unseren Livestream-Webserver finden wir in den Beispielen. Navigiert dazu innerhalb der Arduino IDE zu folgendem Punk:

Datei -> Beispiele -> ESP32 -> Camera -> CameraWebServer

und öffnet das Beispiel.
Anpassungen im Code
Es gibt lediglich zwei Programmpassagen, die wir ändern müssen. Einmal ist es das Kameramodell. Wir nutzen das Kameramodell von AI_THINKER. Ändert die Kommentare so ab, dass #define CAMERA_MODEL_AI_THINKER wirksam wird:
// Select camera model //#define CAMERA_MODEL_WROVER_KIT //#define CAMERA_MODEL_ESP_EYE //#define CAMERA_MODEL_M5STACK_PSRAM //#define CAMERA_MODEL_M5STACK_WIDE #define CAMERA_MODEL_AI_THINKER
Zu guter Letzt müssen noch die WLAN-Daten eingepflegt werden. Dazu müssen die beiden folgenden Zeilen angepasst werden:
const char* ssid = "WLAN-SSID"; const char* password = "WLAN-PASSWD"; Das Hochladen
Stellt sicher, dass die Brücke zwischen IO0 und GND gesetzt ist. Trennt die USB-Verbindung zum PC und stellt sie anschließend wieder her, damit die ESP32-Cam im Flash-Modus bootet. Anschließend könnt ihr das Programm wie gewohnt via Arduino IDE auf das Board laden.

Die beiden Schritte USB Kabel trennen / wieder verbinden müssen vor jedem Hochladen erfolgen (da sonst nicht im Flash-Modus). Alternativ kann auch der Reset-Knopf an der ESP32-Cam betätigt werden.

Nach dem Hochladen erscheint folgende Meldung im seriellen Monitor:
WiFi connected Starting web server on port: '80' Starting stream server on port: '81' Camera Ready! Use 'http://192.168.178.116' to connect
Sollte das nicht passieren, löst die Brücke zwischen IO0 und GND, damit die ESP32-Cam normal bootet und nicht im Flash-Modus startet. 👍

Wenn wir nun auf die angegebene Adresse navigieren, können wir die Web-UI des Livestreams erreichen.

Um den Livestream zu starten, müssen wir lediglich im Menü ganz unten den passenden Button ‘Start Stream’ klicken.

esp32-cam-livestream-web-ui.png

Das Bild der Kamera erscheint im Webbrowser und kann beobachtet werden.

esp32-cam-livestream-image.png

Sämtliche Einstellungen der Kamera können über das Menü im Webbrowser vorgenommen werden. Darunter fallen zum Beispiel:
Auflösung Qualität Helligkeit Kontrast Sättigung Weißabgleich … und vieles mehr
sogar Gesichtserkennung ist möglich.
Einbinden auf einer lokalen Webseite
Nicht nur die mitgelieferte Weboberfläche eignet sich zum ansehen des Streams. Der Stream kann genauso gut auf einer lokalen Webseite eingebunden werden. Dazu kann der HTML-Tag für Bilder img verwendet werden.
<img src="http://192.168.178.116:81/stream">
Die Anzeige des Bildes erfolgt dabei automatisch in der Größe des Streams.

Man sieht also, die ersten Schritte für den eigenen Livestream-Server sind gar nicht so schwer. Natürlich haben wir hier nur mit dem Beispiel “gearbeitet”. Aber das Beispiel lässt sich verwenden, um eigene Projekte darauf zu realisieren. Es war sozusagen das “Blink” der ESP32-Cam. Mal sehen, was man damit noch so alles anstellen kann. Vielleicht ja sogar eine native Überwachungskamera für das smarte Zuhause.

¹Produktempfehlungen
Produkte zum Warenkorb hinzufügen
Gehäuse
Nach der Programmierung und dem Setup der Kamera fehlt eigentlich nur noch ein passendes Gehäuse. Glücklicherweise hat @dixondsc ein Gehäuse für die #ESP32-Cam konstruiert und hier im Forum geteilt. Lasst ihm gerne ein Dankeschön da! 🙂

Das Gehäuse gibt es in zwei Varianten:
Klicke auf den 3D-Würfel um die Modelle anzuschauen.
ESP32-Cam Gehäuse mit GoPro-Halterung ESP32-Cam Gehäuse ohne GoPro-Halterung
Und dazu wird jeweils dann noch der Deckel benötigt:
ESP32-Cam Deckel
Das Gehäuse ist so konstruiert, dass es über eine MicroUSB-Buchse bestromt wird. Dazu für ein ¹USB - DIP Adapter benötigt. Mehr dazu im Thread von @dixondsc.

#Arduino #Arduino-IDE #ESP32 #ESP32-Cam #Livestream #Webserver #Smarthome
¹Affiliate Link. Affiliate Links sind Referenzen des Autors. Bei Kauf wird eine Provision ausgeschüttet. Mehr Informationen.
Arduino IDE - Arbeiten mit JSON Objekten für Einsteiger - Tutorial
api arduino-ide arduino-json d1-mini esp8266 include json spiffs
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

233
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
Tutorial: ESP8266-01S programmieren
arduino-ide esp01s esp8266
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

1091
Aufrufe

Hey! Ich habe ein Projekt im Kopf, welches ich gerne mit einem ESP8266-01S umsetzen wollen würde. Aufgrund der kompakten Größe und der ausreichenden Anzahl an Pins für mein Projekt, eignet er sich bestens.

ESP01-S makesmart.shop

Im Gegensatz zu einem Entwicklerboard, wie dem D1 Mini, kann der ESP8266-01S aber nicht direkt mit der USB-Schnittstelle des PCs verbunden werden.

Dafür gibt es aber andere Methoden, den ESP8266-01S zu programmieren. Die wohl einfachste Möglichkeit ist die mit dem Programmer.

rsz_esp01_programmer.png

Disclaimer: Die Arduino IDE ist bereits für das Programmieren verschiedener ESP8266 Module eingerichtet. Ihr könnt die die Einrichtung der IDE mit diesem Artikel durchführen.
Software
Um den ESP8266-01S programmieren zu können, müsst ihr als Board das Generic ESP8266 Module auswählen. Das geht über:

Werkzeuge - Board - Generic ESP8266 Module

Die Definition der eingebauten LED stimmt nicht. Diese müsst ihr unter Umständen unter
Werkzeuge - Builtin Led von 2 auf 1 ändern.

Damit ist die Software fertig eingerichtet.
Hardware
Ich verwende in dieser Anleitung, wie bereits erwähnt, einen Programmer, der extra für den ESP8266-01S ausgelegt ist. Leider funktioniert das Programmieren nicht ohne Modifikation an der Hardware.

extra für den ESP8266-01S ausgelegt

🤦

Bevor der ESP8266-01S mit dem USB-Port verbunden werden kann, muss eine Brücke zwischen GPIO0 und GND gesetzt werden.

Das kann entweder direkt über die Pins des ESPs, die Pins des Programmers oder beides irgendwie in Kombination passieren - Hauptsache: Brücke.

Die Brücke bewirkt, dass der ESP8266-01S im Programmierbetrieb startet - nur so kann er programmiert werden.

esp8266-01S_pinout.png

Als Brücke dient bei mir ein an beiden Enden abisoliertes Jumper-Kabel.

Wenn die Brücke gesetzt ist, kann der Programmer mit dem PC verbunden, und der ESP programmiert werden.

Wenn die blaue LED beim Verbinden mit dem PC ganz kurz (!) aufleuchtet, weiß man, man ist im Programmierbetrieb.

Mittlerweile verwende ich einen anderen Programmer, der funktioniert auf anhieb ohne löten und pfuschen. Einfach Plug & Play. Ich werde bei Zeiten die Anleitung hier mal neu strukturieren und schreiben. Den Programmer findet ihr im makesmart.shop.
Programmierung
Programmieren kann man den ESP8266-01S dann wie gewohnt. Als Dummy-Programm verwende ich - wie so oft - das Blink-Beispiel. Dieses findet man unter:

Datei - Beispiele - 01.Basics - Blink

Nach dem das Programm geöffnet wurde, kann es über den Pfeil oben links in der Ecke auf den ESP geladen werden.
Der Sketch verwendet 258596 Bytes (51%) des Programmspeicherplatzes. Das Maximum sind 499696 Bytes. Globale Variablen verwenden 26696 Bytes (32%) des dynamischen Speichers, 55224 Bytes für lokale Variablen verbleiben. Das Maximum sind 81920 Bytes. Uploading 262736 bytes from /var/folders/wv/mznb1p6x3kx40bkysnfy2mhc0000gn/T/arduino_build_296160/Blink.ino.bin to flash at 0x00000000 ................................................................................ [ 31% ] ................................................................................ [ 62% ] ................................................................................ [ 93% ] ................. [ 100% ]
Der ESP8266-01S sollte zum blinken beginnen. 🏁
Fehlerbehebung
Wenn man das Programm modifiziert und erneut hochladen möchte, wird ein Fehler ausgespuckt:
Der Sketch verwendet 258596 Bytes (51%) des Programmspeicherplatzes. Das Maximum sind 499696 Bytes. Globale Variablen verwenden 26696 Bytes (32%) des dynamischen Speichers, 55224 Bytes für lokale Variablen verbleiben. Das Maximum sind 81920 Bytes. warning: espcomm_sync failed error: espcomm_open failed error: espcomm_upload_mem failed error: espcomm_upload_mem failed
Der Grund dafür ist simple: Der ESP8266-01S befindet sich jetzt im Normalbetrieb.
Um den ESP erneut in den Programmierbetrieb zu bekommen kann man:
A: die Brücke von GND trennen und anschließend wieder verbinden, oder B: den Programmer vom USB-Port trennen und anschließend einfach wieder verbinden.
Danach kann das neue oder geänderte Programm auf den ESP8266 hochgeladen werden.

Die Schritte A oder B müssen nach jedem Hochladen ausgeführt werden.

Viel Spaß bei euren Projekten,

cooper
Tutorial: ESP8266 Deep-Sleep
arduino-ide d1-mini deep-sleep esp8266
Tipps, Tricks & Tutorials • • cooper

5

0
Stimmen

5
Beiträge

1252
Aufrufe

@frrrdy

Per Seriellem Monitor?
Genau!

Serial.begin(115200);

Baudrate im seriellen Monitor muss gleich eingestellt sein: 115200.
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

104
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. 🙂

Relais beim ersten Knopfdruck HIGH, beim zweiten Knopfdruck LOW setzen

Ähnliche Themen

ESP32-Cam Programmieren - Einrichtung als Livestream-Server arduino arduino-ide define esp32 esp32-cam livestream smarthome webserver Tipps, Tricks & Tutorials • • cooper

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

Tutorial: ESP8266-01S programmieren arduino-ide esp01s esp8266 Tipps, Tricks & Tutorials • • cooper

Tutorial: ESP8266 Deep-Sleep arduino-ide d1-mini deep-sleep esp8266 Tipps, Tricks & Tutorials • • cooper

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

ESP32-Cam Programmieren - Einrichtung als Livestream-Server
arduino arduino-ide define esp32 esp32-cam livestream smarthome webserver
Tipps, Tricks & Tutorials • • cooper

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

Tutorial: ESP8266-01S programmieren
arduino-ide esp01s esp8266
Tipps, Tricks & Tutorials • • cooper

Tutorial: ESP8266 Deep-Sleep
arduino-ide d1-mini deep-sleep esp8266
Tipps, Tricks & Tutorials • • cooper

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