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

1326

Anmelden zum Antworten

cooper ESP8266 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

ESP32-Cam als HomeKit Kamera via rtsp-Stream & Homebridge - Tutorial
arduino arduino-ide esp32 esp32-cam homebridge homekit kamera smarthome stream
Tipps, Tricks & Tutorials • • cooper

1

0
Stimmen

1
Beiträge

1230
Aufrufe

In einem anderen Tutorial habe ich bereits erklärt, wie man die ESP32-Cam mithilfe der Arduino IDE installiert, einrichtet und damit anschließend einen Livestream-Webserver realisieren kann. Heute möchte ich auf dem Wissen aufbauen und einen modifizierten Sketch vorstellen, mit dem die ESP32-Cam einen rtsp-Stream bereitstellt. Der Stream lässt sich von Programmen wie dem VLC-Media-Player abspielen, oder auch als HomeKit-Kamera in das eigene Smarthome einbinden.

makesmart_esp32-homekit-kamera.jpeg

Die Einbindung der ESP32-Cam in HomeKit funktioniert dabei nicht nativ, sondern über meine Smarthome-Bridge Homebrige, die auf meinem Raspberry Pi läuft.

Die Handhabung ist sehr einfach und am Ende haben wir neben einer funktionierenden HomeKit Kamera einen vollwertigen rtsp-Stream, den man auch anderweitig verwenden kann.

Solltet ihr noch nicht wissen, wie man eine ESP32-Cam einrichtet und programmiert, dann schaut euch vorher gerne diesen Beitrag an, in dem ich Schritt für Schritt erkläre, was zu tun ist, um die ESP32-Cam zum laufen zu bekommen.

Für dieses Tutorial braucht ihr neben der Hardware für die Homebridge noch eine ESP32-Cam, einen USB-TTL-Converter mit 5V Spannung und ein paar Jumper-Kabel. Ein Breadboard ist nicht unbedingt nötig, erleichtert der Verdrahtung und Schaltung aber allgemein um einiges. Ich verwende für dieses Tutorial folgende Produkte:
Sketch download & Anpassungen Arduino IDE
Der Sketch kann hier heruntergeladen werden: Download - es handelt sich dabei um einen Fork von bnbe-club.

Entpackt zuerst das .zip-Archiv und öffnet den sich darin befindlichen Ordner diy-e14.

Der Sketch trägt den Namen diy-e14.ino und muss per Doopelklick geöffnet werden, damit auch die anderen Ressourcen im Ordner geladen werden:
src camera_pins.h wifikeys.h
Nachdem der Sketch geöffnet wurde, navigiert ihr oben in den Tabs zu der Datei wifikeys.h und tragt dort eure WLAN-Zugangsdaten ein:
const char *ssid = "Network"; // Put your SSID here const char *password = "Password"; // Put your PASSWORD here
Der Sketch kann anschießend gespeichert werden, und dann ist er auch schon bereit zum hochladen. Wenn du nicht weißt, wie das funktioniert, sieh dir bitte mein Anfänger-Tutorial zur ESP32-Cam an.
Der rtsp-Stream
Nach dem Upload des Programms erscheint im seriellen Monitor der Arduino IDE folgende Meldung:
192.168.178.116 Stream Link: rtsp://192.168.178.116:8554/mjpeg/1
Über die IP-Adresse 192.168.178.116 kann der Stream direkt im Webbrowser angezeigt werden. Über diese URL kann man z.B auch mithilfe eines HTML-Iframe den Stream auf einer Webseite im lokalen Netzwerk laufen lassen.
<iframe src="http://192.168.178.116/" width="800px" height="600px"/>
Aber unser Ziel hier ist es, die Kamera direkt in unser Smarthome zu verfrachten - also weiter im Text.
Homebridge Plugin installieren
Als Plugin innerhalb der Homebridge verwende ich homebridge-camera-ffmpeg. Es kann direkt über die Weboberfläche von Homebridge installiert werden.

makesmart_homebridge_plugin-homebridge-camera-ffmpeg.png

Nach der Installation öffnet sich ein Konfigurations-Fenster des Plugins. Ihr müsst nur die folgenden Parameter ausfüllen und eintragen - für den Rest werden die default Paramter verwendet
Name Kamera Video Source -i rtsp://192.168.178.116:8554/mjpeg/1 Still Image Source none Enable Audio False
Die IP-Adresse muss natürlich angepasst werden. 🙂 Die IP-Adresse ist die, die im seriellen Monitor der Arduino IDE angezeigt wurde / wird.

Unter dem Punkt Video Output sollte zusätzlich noch der Punkt Unbridge Camera deaktiviert werden, da diese sonst die komplette Homebridge-Instanz verlangsamen könnte. Mit dieser Einstellung muss die Kamera manuell hinzugefügt werden - macht aber keinen Unterschied.

Wenn die Einstellungen eingetragen wurden, kann man diese ganz unten per klickt auf Speichern speichern. Die Homebridge muss danach neugestartet werden. Wichtig ist es, einen Blick in den Log auf der Startseite zu werfen, da dort der Pairing-Code der Kamera auftaucht.
[12/26/2020, 10:57:30 AM] Kamera is running on port 34217. [12/26/2020, 10:57:30 AM] Please add [Kamera] manually in Home app. Setup Code: 273-85-527 Pairing mit der Home App
Das Pairing läuft ab wie bei jedem anderem Gerät.

makesmart_pair_homkit_kamera_esp32-cam.jpeg
+ Gerät hinzufügen Ich habe keinen Code bzw. kann nicht scannen Kamera auswählen, meine Kamera trägt die Bezeichnung Kamera 3EBC Pairing-Code aus dem Log eingeben:
Please add [Kamera] manually in Home app. Setup Code: 273-85-527 Etwas gedulden, bis sich die Kamera verbunden hat
Fertig ist die HomeKit-Kamera mit der ESP32-Cam - Die eigene DIY-Low-Budget Kamera für das Smarthome.

makesmart_esp32-homekit-kamera.jpeg

Dieses Tutorial sollte auch mit folgenden ESP32-Cams funktionieren:

¹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 #Homebridge #HomeKit #Kamera #Smarthome #Stream
¹Affiliate Link. Affiliate Links sind Referenzen des Autors. Bei Kauf wird eine Provision ausgeschüttet. Mehr Informationen.
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

794
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. 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.
ESP8266 GET-Variablen auslesen
arduino-ide d1-mini esp8266 get http include request
Tipps, Tricks & Tutorials • • cooper

9

2
Stimmen

9
Beiträge

906
Aufrufe

H

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

1

0
Stimmen

1
Beiträge

1092
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

Firmware mithilfe der Arduino IDE flashen

Vorbereitungen

Firmware flashen

Ähnliche Themen

ESP32-Cam als HomeKit Kamera via rtsp-Stream & Homebridge - Tutorial arduino arduino-ide esp32 esp32-cam homebridge homekit kamera smarthome stream 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

ESP8266 GET-Variablen auslesen arduino-ide d1-mini esp8266 get http include request Tipps, Tricks & Tutorials • • cooper

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

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

ESP32-Cam als HomeKit Kamera via rtsp-Stream & Homebridge - Tutorial
arduino arduino-ide esp32 esp32-cam homebridge homekit kamera smarthome stream
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

ESP8266 GET-Variablen auslesen
arduino-ide d1-mini esp8266 get http include request
Tipps, Tricks & Tutorials • • cooper

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

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