ESP8266 ESP-01/ESP-01S WLAN-Modul mit dem Arduino UNO programmieren
Kategorien: Arduino
Das ESP8266-WLAN-Modul ist in seinen verschiedenen Varianten sehr kostengünstig und wird bereits mit einer AT-Befehlssatz-Firmware vorprogrammiert ausgeliefert, was bedeutet, dass sich diese Module sehr einfach an einen Mikrocontroller wie beispielsweise dem Arduino anschließen lassen und den Arduino um eine WLAN-Funktionalität erweitern, wie es andere WLAN-Shields zwar auch tun, aber das wesentlich teurer.
Diese Module sind sehr leistungsstark, sind gut verarbeitet und verfügen auch über einen eigenen Speicher, was es ermöglicht, Sensoren oder andere INPUTS/OUTPUTS an den vorhandenen GPIOs zu verarbeiten.
Man kann die ESP8266-Module auch vollständig ohne einen Arduino betreiben, da sie über einen eigenen Mikroprozessor (L106 32-bit RISC Mikroprozessorkern, basierend auf dem Tensilica Xtensa Diamond Standard 106Micro mit 80 MHz) verfügen, der sich genau so einfach mittels der Arduino-IDE programmieren lässt wie ein Arduino Mikrocontroller.
Somit lässt sich eine WLAN-Funktionalität auf einfache Weise in ein eigenes Arduino-Projekt einfügen.
Wir beginnen mit den ESP8266 ESP-01 und ESP-01S, die wir in diesem Tutorial mit einem Arduino UNO programmieren wollen.
Im Grunde verhalten sich die beiden gleich, nur beim programmieren unterscheidet sich der Aufbau der elektronischen Schaltung ein klein wenig.
Software und nötige Treiber installieren
Als erstes benötigen wir eine Arduino-IDE (Download: https://www.arduino.cc/en/Main/Software) auf unserem Rechner.
Falls bereits eine Version installiert ist, sollte diese mindestens in der Version 1.6.4 vorliegen, sonst funktionieren die notwendigen ESP-Treiber nicht.
Um nun die notwendigen Treiber zu installieren, öffnen wir im Programmmenü “Datei” den Punkt “Voreinstellungen“.
In dem sich darauf öffnenden Fenster tragen wir die folgende URL “http://arduino.esp8266.com/stable/package_esp8266com_index.json” unter “Zusätzliche Boardverwalter-URLS” ein.
Befindet sich in dem Eingabefeld bereits ein Eintrag, so kann man den neuen Eintrag mit einem Komma nach dem letzten Eintrag einfach hinzufügen.
Das Fenster schließen wir jetzt durch anklicken des “OK“-Buttons.
Nach der Installation scrollen wir unter dem Menüpunkt “Werkzeuge“->”Board” nach oben bis zu der Auswahl “Boardverwalter“.
In dem sich öffnenden Fenster suchen wir den Eintrag “esp8266” und installieren das entsprechende Paket.
Danach stehen uns unter “Werkzeuge“->”Board” am unteren Auswahlende etliche neue Boards zur Verfügung. Unter anderem den Eintrag “Generic ESP8266 Module”.
Diesen Eintrag wählen wir aus und dann haben wir alles, um unser ESP-Modul programmieren zu können.
Hardwareaufbau
Achtung: Es gibt ab jetzt ein paar Fallstricke, daher lest den folgenden Teil aufmerksam und Ihr werdet Euer ESP-Modul mühelos und ohne Fehlerausgaben sauber mit dem Arduino programmieren.
Fallstrick Nummer 1: Das ESP8266 ESP-01(S)-Modul läuft NUR mit 3.3V (max. 3.6V – auch die GPIO´s sind nicht 5V tolerant!).
Alles darüber zerstört das Modul! Der Arduino hat zwar einen 3.3V-Ausgangspin, aber der liefert je nach Arduino-Clon möglicherweise nicht genug Spannung.
Daher sollte man auf jeden Fall besser eine externe Stromquelle verwenden und diese auf maximal 3.3V Output einstellen.
Dafür nimmt man beispielsweise einen LM317, oder einen AMS1117 für 3.3V Ausgangsspannung.
Wichtig ist, dass der verwendete Spanungswandler/Step-Up/Step-Down mindestens 500mA Strom, noch besser mindestens 800mA – bei 3.3V zur Verfügung stellen kann, sonst kommt es – auch später im Livebetrieb – möglicherweise zu einem ominösen Verhalten des ESPs in Form von Reboots, usw.
Wir verwenden für diesen Aufbau einen LM317 Linearregler (beachtet die Pinbelegung des LM317. Datenblatt) und dafür brauchen wir noch zwei Widerstände, um die Spannung sauber herunterzuregeln.
Wir brauchen einen 220 Ohm Widerstand und einen 330 Ohm Widerstand. Mit diesem kleinen Schaltkreis erhalten wir rund 3.1V bei einer Eingangsspannung von 5-12 VDC (geht auch mehr, aber dann müsste man den LM317 besser kühlen).
Optional noch eine Freilaufdiode (D1) zwischen Ein- und Ausgang des LM317 als Schutz einbauen.
Pins des ESP8266 ESP-01(S)
Hinweis für den ESP-01S: Alle GPIO-Pins, so wie TX und RX haben einen internen PullUp-Widerstand, sind also generell auf HIGH gezogen.
Die normale Version ESP-01 hat dies nicht. Also brauchen wir in unserer Schaltung entsprechende Widerstände.
Fallstrick Nummer 2: Ganz wichtig ist, dass GPIOo und GPIO2 steuern, wie das Modul starten soll und erfordern daher eine besondere Handhabung.
Wie in der Tabelle zu sehen ist, muss GPIO0 auf LOW und GPIO2 auf HIGH gezogen werden, um das Modul programmieren/flashen zu können.
Verwenden wir dagegen unser Modul mit dem fertigen Programm, so muss GPIO0 und GPIO2 auf HIGH gezogen werden.
Diese beiden Möglichkeiten beziehen sich nur auf den kurzen Bootvorgang (oder nach einem Reset).
Danach können die GPIOs ganz normal verwendet werden und jeden anderen Status annehmen.
GPIO15 ist hier nicht von Interesse, da das ESP8266-01-Modul keinen herausgeführten GPIO15-Pin hat.
Die Pinbelegung des ESP8266 ESP-01 für den Flashvorgang sieht dann wie folgt aus:
VCC kommt an 3,3V extra Versorgungsspannung
RST (Reset) bleibt offen – vor dem Programmieren kurz auf GND legen
CHPD/EN/CS Chip Select kommt fest mit einem 1 KOhm Widerstand auf die 3,3V Versorgungsspannung
TX geht zu TX (Pin 1 des Arduinos)
RX geht über einen Levelshifter (3,3V) zu RX (Pin 0 des Arduinos)
GPIO 0 geht mit einem 2-10 KOhm Widerstand an GND zum Programmieren (Nur kurz anlegen!)
GPIO 2 bleibt offen
GND geht an Masse Versorgungsspannung
GND des Arduinos geht auf die gemeinsame Masse.
Der ESP-01S ist identisch, bis auf CHPD/EN/CS und GPIo. Hier brauchen wir keine Widerstände. Siehe Schaltplan.
Unsere Schaltung schaut dann wie auf den unten folgenden Bildern aus.
Links ist unser Linearregler, der auf der obigen Stromschiene eine Spannung von 5-12V INPUT in rund 3.1V runterregelt und diese 3.1V OUTPUT auf der unteren Stromschiene zur Verfügung stellt.
ESP-01: Bevor wir Strom auf das Breadboard schalten, muss der blaue Draht (GPIO0) mit “** INFO” mit einem PullDown-Widerstand zwischen 2-10KOhm auf LOW gezogen werden.
ESP-01S: Der blaue Draht wird nur kurz auf LOW gezogen.
Wir schalten den Strom ein und dann entfernen wir das blaue Kabel wieder, bevor wir anfangen das Modul zu programmieren.
Warum das so ist, ist im folgenden Fallstrick erklärt.
Schaltplan ESP-01:
Schaltplan ESP-01S:
Fallstrick Nummer 3: Will man GPIO0 als Ausgabe-Pin verwenden und setzt GPIO0 in seinem Programm auf HIGH – obwohl zum programmieren der GPIO0 ja auf LOW gezogen sein muss, kann die Erdung den ESP8266-Chip möglicherweise zerstören!
Daher ist der sicherste Weg, den ESP8266-01 wie folgt zu programmieren. Damit geht man den sicheren Weg, auch wenn er etwas “komplexer” zu sein scheint. Er hat aber den Vorteil, dass das Modul vor der Zerstörung geschützt wird.
1.) Zuerst schalten wir alles stromlos,
2.) dann verbinden wir mit dem PullDown-Widerstand GPIO0 mit GND. (Blaues Kabel)
3.) Wir verbinden das Modul mit dem Strom und lassen es kurz hochbooten. Das Modul geht in den Programmiermodus.
4.) Wir entfernen die GPIO0-Leitung (blaues Kabel) und
5.) programmieren das Modul neu.
Somit verhindern wir, dass der Ausgabepin kurzgeschlossen wird, wenn das Programm nach dem erfolgreichen hochladen anfängt zu laufen.
Jetzt können wir, nachdem wir alles stromlos geschaltet haben, den GPIO0-Pin mit LED/Relais, oder was auch sonst immer verbinden.
Programmieren des ESP8266-01
In der Arduino IDE muss nun unter “Werkzeuge“->”Board” das “Generic ESP8266” ausgewählt und die richtige COM Schnittstelle für den Arduino eingestellt werden mit 115200 Baud. (Nur diese Geschwindigkeit funktioniert)
Jetzt flashen wir das ESP-Modul mit dem Testprogramm “Blink”, wie wir es auch vom Arduino her kennen. (“Hello World” für Elektroniker 🙂 )
Wichtig ist, dass wir jetzt, bevor wir mit dem “Hochladen” beginnen,
zuerst GPIO0 mit dem PullDown auf GND ziehen (Punkt 2),
dann das freie Kabel, das am Reset-Pin des Moduls hängt, ganz kurz in GND stecken – es sollte dabei ganz kurz die blaue LED aufleuchten. – und wieder herausziehen und
abschießend das GPIO0-Kabel wieder abziehen (Punkt 4).
Unser Modul ist nun bereit, das neue Programm zu empfangen. Wir wählen “Hochladen” aus, lassen den/das (???) Sketch kompilieren und wenn alles erfolgreich ist, wird der Sketch auch anschließend fehlerfrei hochgeladen.
ESP-01: Wichtig, wenn Ihr nicht die S-Version verwendet, müsst Ihr den folgenden Sketch verwenden und nicht den Beispielsketch, der in der Arduino vorhanden ist. Der Grund ist nämlich der, das bei diesen Modulen die blaue LED auf der Platine mit dem GPIO1 verbunden ist. Bei dem S-Modul haben sie das geändert.
ESP-01S: Verwendet einfach den Beispielsketch “Blink” zu finden unter “Datei“->”Beispiele“->”ESP8266”
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/* ESP8266 Blink by Simon Peter Blink the blue LED on the ESP-01 module This example code is in the public domain The blue LED on the ESP-01 module is connected to GPIO1 (which is also the TXD pin; so we cannot use Serial.print() at the same time) */ int LED=1; // GPIO1 = blaue LED void setup() { pinMode(LED, OUTPUT); // Initialize the LED_BUILTIN pin as an output } // the loop function runs over and over again forever void loop() { digitalWrite(LED, LOW); // Turn the LED on (Note that LOW is the voltage level // but actually the LED is on; this is because // it is acive low on the ESP-01) delay(1000); // Wait for a second digitalWrite(LED, HIGH); // Turn the LED off by making the voltage HIGH delay(2000); // Wait for two seconds (to demonstrate the active low LED) } |
Vergessen wir das resetten vor dem flashen, oder haben den GPIO0 nicht mit dem Pulldown-Widerstand auf LOW gezogen gehabt, erhalten wir diese Fehlermeldung der Arduino-IDE:
error: espcomm_open failed
Wenn aber alles geklappt hat, blinkt nun die blaue LED des ESP-Moduls.
Jetzt beenden wir den Flash-Modus des ESP-Moduls. (GPIO0 darf nicht mit GND verbunden sein.)
Dazu resetten wir mit dem freien Reset-Kabel nochmal, in dem wir das Kabel kurz in GND stecken.
Das ESP-Modul startet neu und nun blinkt die blaue LED wie vorher auch.
Fallstrick Nummer 4: Wird der Arduino abgeschaltet und stecken RX und TX noch im Board und ist dieser noch mit GND verbunden, startet das ESP-Modul auch nicht, da RX und TX auf GND, also LOW gezogen werden, was nicht sein darf.
Daher unbedingt das GND-Kabel abziehen, das den Arduino mit dem Breadboard verbindet.
Ich wünsche Euch viel Spaß und viel Erfolg.
Nachtrag vom 26.10.2019: Wir bieten jetzt einen günstigen ESP-Programmer in unserem Shop an, der es einem wesentlich erleichtert, ESP-01er-Module zu flashen.
Wir haben den ESP-Programmer ausprobiert und ihn auf Herz und Nieren untersucht. Das Ergebnis könnt Ihr hier nachlesen: “Modul mit dem ESP-Programmer programmieren”
28 Comments
Wolfgang
23. August 2022 at 10:35 amHallo,
ich benötige ein (schwaches) WLAN-Signal an einem bestimmten Ort, um dort mein Handy mit einem Macro darauf zu triggern. In Gegenden mit einem bekannten Router/WLAN-Signal kann ich das nehmen, um per Macro zu erkennen, wo ich bin, Zuhause, Büro, Freundin etc. Und je nachdem werden bestimmte Profile im Handy aktiviert. Soweit das “warum”
Jetzt habe ich dieses nette Modul “ESP8266 ESP-01/ESP-01S WLAN-Modul” hier entdeckt. Das wäre vielleicht vom Prinzip her geeignet.
Fragen:
Braucht man zum Programmieren wirklich einen Arduino oder nur die IDE?
Kann das Modul also nach der Programmierung und Stromanlegen ohne weitere Aktivitäten automatisch ein permanentes WLAN-Signal erzeugen? Das Signal muss nicht stark sein. Eine Reichweite von 3 Meter reicht. Das Handy soll einfach nur bei Annäherung ein bestimmtes WLAN erkennen und dann reagieren. Ich könnte ja einen alten WLAN-Router nehmen. Aber das wäre mir halt zu groß. Das kleine Ding reizt mich.
Ronin
24. August 2022 at 11:13 amHallo Wolfgang,
ja, das ist machbar. Du kannst das Modul als WLAN-Client und als AccessPoint, oder beides gleichzeitig Problemlos betreiben.
3 Meter sind ohne Weiteres drin. Die Module haben eine gute Abdeckung.
Zum Programmieren kannst Du auch einen ESP-Programmer unter der IDE verwenden. Würde ich Dir auch empfehlen, denn letztendlich ist es jedesmal ein böses Gefummel, wenn man sich die Schaltung mit einem Arduino selbst aufbaut. Ich mach das auch nur noch mit Programmer. 🙂
Schau Dir mal unseren Artikel zu dem Programmer an.
Viele Grüße und viel Erfolg,
Michael
Annett
17. März 2022 at 7:01 pmHallo,
ist es möglich ein vorinstalliertes Programm von einen D1 Mini NodeMcu mit ESP8266-12F WLAN Modul auf ein anderes zu übertragen?
Eine Verbindung kann ich herstellen. Wie kann ich den vorinstallierten Sketch auslesen / kopieren und auf das andere Modul laden?
Ronin
18. März 2022 at 3:03 pmHallo Annett,
Nein, das ist nicht möglich, denn das Original-Programm liegt Dir in einer Hochsprache auf Deinem Computer vor (C, mit der Arduino-GUI, … geschrieben), aber es wird ja in Maschinensprache kompiliert und dieser Maschinencode wird auf den Controller geflasht.
Mit einem externen Flasher der avrdude unterstützt (selbst gebaut), oder bspw. so einen hier: Programmer kannst Du das HEX-File (Maschinencode) herunterladen und ihn dann mit dem gleichen Flasher auf den anderen Controller übertragen.
Ob Du den ESP8266-12 als Flasher verwenden kannst, weiß ich jetzt leider nicht, da ich das noch nie ausprobiert habe, aber google mal mit “esp und avrdude”.
Aber Achtung: Wenn Du kein Profi in Assembler bist, kannst Du dann nichts an dem heruntergeladenen HEX-File ändern. Du hast also nur eine Datei mit der Du Klone erstellen kannst, aber keine Änderungen vornehmen kannst.
So würde beispielsweise eine HEX-Datei aussehen (Vorlage: ATMega328_1Mhz_Optiboot9600Baud_Bootloader.hex – 2kb groß):
:107E0000112484B714BE81FFE6D085E08093810001
:107E100082E08093C00088E18093C10086E0809377
:107E2000C2008CE08093C4008EE0BFD0259A86E02B
:107E300023EC3FEF91E0309385002093840096BBC4
:107E4000B09BFECF1D9AA8958150A9F7EE24FF2480
:107E5000AA24A394B5E0CB2EA1E1BA2EF3E0DF2E45
:107E600098D0813461F495D0082FA5D0023829F13B
:107E7000013811F485E001C083E083D07FC08234F3
:107E800011F484E103C0853419F485E09CD076C0F8
:107E9000853579F47ED0E82EFF247BD0082F10E0C2
:107EA000102F00270E291F29000F111F84D07801E1
:107EB00065C0863521F484E086D080E0DECF84364C
:107EC00009F040C066D065D0082F63D080E0E81686
:107ED00080E7F80618F4F701D7BEE895C0E0D1E0D6
:107EE00058D089930C17E1F7F0E0EF16F0E7FF06A2
:107EF00018F0F701D7BEE8955ED007B600FCFDCFBD
:107F0000A701A0E0B1E02C9130E011968C9111977F
:107F100090E0982F8827822B932B1296FA010C0160
:107F2000A7BEE89511244E5F5F4FF1E0A038BF0770
:107F300051F7F701C7BEE89507B600FCFDCFB7BE05
:107F4000E8951CC0843761F424D023D0082F21D0B9
:107F500032D0F70185917F0114D00150D1F70EC0C6
:107F6000853739F428D08EE10CD085E90AD08FE02E
:107F700084CF813511F488E018D01DD080E101D084
:107F80006FCF982F8091C00085FFFCCF9093C600E3
:107F900008958091C00087FFFCCF8091C00084FDD0
:107FA00001C0A8958091C6000895E0E6F0E098E150
:107FB000908380830895EDDF803219F088E0F5DF4B
:107FC000FFCF84E1DECF1F93182FE3DF1150E9F7D5
:107FD000F2DF1F910895282E80E0E7DFEE27FF27CC
:027FE000099402
:027FFE0000057C
:0400000300007E007B
:00000001FF
Mit entsprechenden Werkzeugen lässt sich dann der Code deassemblieren und kleinere Änderungen vornehmen (andere Pin-Nummer oder Variablen ändern), aber das ist schon ein ganz anderes Level. 🙂
Hoffe dennoch, meine Antwort hilft Dir ein wenig weiter…
Viele Grüße, Michael
DHT-22 and ESP-01 to measure temperature and humidity – iamklaus.org
6. März 2022 at 11:07 am[…] ESP8266 ESP-01/ESP-01S WLAN-Modul mit dem Arduino UNO programmieren […]
Michael H.
3. Mai 2021 at 3:00 pmDu schreibst
> CHPD/EN/CS Chip Select kommt fest mit einem 1 KOhm Widerstand auf die 3,3V Versorgungsspannung.
Das solltest du dann bitte auch so zeichnen (im Bild Schaltplan ESP-01). Beim ESP-01S ist es zwar ohne den Vorwiderstand, aber ansonsten richtig,
Der UNO (atmega328P) selbst wird ja gar nicht gebraucht, sondern nur sein USB-TTL-Wandler, richtig?
Sollte man da nicht verhindern, dass er auf seinem TX dazwischenplappert (z.B. den UNO RESET auf GND ziehen)?
sven
28. Januar 2021 at 9:29 amHallo, ich würde gerne wissen, wie die Kommunikation mit dem ESP01 und dem Arduino programmiert werden kann, z.B. mit der Wire Bibliothek. Ziel ist es ja über den ESP01 Daten über das WLAN mit anderen Servern auszutauschen. Hast Du da einen Tipp wo man ein gutes Beispiel-Projekt finden kann.
Ronin
4. Februar 2021 at 11:38 amHallo Sven,
schau mal bei https://esp8266-server.de/ vorbei. Dort gibt es sehr viele Beispiele speziell für den ESP.
Viel Erfolg,
Michael
DIYHUE Lampe mit LED Stripe und ESP8266-01S – EnjoyTure@Leipold.zone
24. Januar 2021 at 12:09 am[…] Zu meinen Boards habe ich noch eine sehr detaillierte Anleitung mit Schaltplan erhalten, hier ist es auch sehr gut beschrieben: https://www.kollino.de/arduino/esp8266-01-wlan-modul-mit-dem-arduino-uno-programmieren/ […]
niel
14. Dezember 2020 at 5:59 pmIch habe das gleiche Problem wie Max:
esptool.FatalError: Failed to connect to ESP8266: Timed out waiting for packet header.
egal was ich probiere, auch andere anleitungen funktionieren nicht.
AT commands (esp –> arduino uno –> usb anschluss ma pc) funktionieren aber
Irgendwelche ideen? habe die anleitung mit dem gpio0 pin auf 0 bei reset und dann entfernen ausgeführt und innerhalb von 3 tagen jetzt auch so ziemlich jede andere kombination.
Max
20. November 2020 at 11:42 amHallo,
ich probiere seit 3 Wochen den ESP-01s zu flashen, sodass ich meinem Arduino einen Wlan-Zugriff ermöglichen kann.
Ich habe die Anleitung befolgt, bekomme allerdings jedes Mal den folgenden Fehler:
esptool.FatalError: Failed to connect to ESP8266: Timed out waiting for packet header.
Ich bin mittlerweile echt verzweifelt, da jeder eine andere Art und Weise zeigt, wie man das ESP-01 flashen kann und keine funktioniert bei mir.
Weiß jemand wie man den oben genannten Fehler beheben kann?
Mit freundlichen Grüßen
Max
Bartsch G.
14. August 2020 at 10:41 amHola ????
Im Beitrag – Fehler ?? RX TX
Uno TX zu ESP TX — Uno RX zu ESP RX ???
siehe
https://www.arduino.cc/en/Tutorial/SoftwareSerialExample
Software serial multple serial test
Receives from the hardware serial, sends to software serial.
Receives from software serial, sends to hardware serial.
The circuit:
* RX is digital pin 2 (connect to TX of other device)
* TX is digital pin 3 (connect to RX of other device)
In Schema Fritzing evtl. gelb grün am Uno tauschen ??
oder.
Gruß
GB
Jocki
7. Juli 2020 at 5:56 pmHi,
habe jetzt ein zweites mal das esp8266 01 mit relais gekauft und es so geschaltet wie es im eBook beschrieben ist.(das ist ja auch wirklich nicht schwer) Bekomme aber keine Antworten von AT-Befehlen zurück. Es wird von euch angegeben, dass die AT-Software auf dem esp8266 01S vorhanden ist. Wie kann ich feststellen ob dies auch wirklich der Fall ist? da das esp-Modul ja schon auf der Relais-Platine gesteckt ist, müsste ich doch eigentlich davon ausgehen können das AT-Software vorhanden ist.
Hab alle Varianten mit USR-TCP232-Test durchgespielt, kein Erfolg
Bitte helft mir
Ronin
8. Juli 2020 at 1:46 pmHallo Jocki, das hast Du aber bestimmt nicht bei uns gekauft? Wir bieten nämlich gar keine Relais-Platinen an, auf die direkt ein ESP01-Modul gesteckt werden kann.
Ob aber das ESP-Modul über eine Firmware verfügt, kannst Du testen. Hierzu brauchst Du ein Terminal-Programm, um den seriellen Anschluss auszulesen (ist ja auch in der Arduino GUI enthalten). Wie das genau geht kannst Du hier nachlesen unter dem Absatz “Flashen der Firmware” beginnend ab “Zum Abschluss prüfen wir, ob die Firmware korrekt […]”.
Da Du ein Mal 01 und ein Mal 01S schreibst … Solltest Du ein 01 verwenden, ist die Baudrate nicht “115200” wie beid er 01S-Version, sondern nur “9600”.
Hoffe, das hilft Dir weiter.
Viel Erfolg,
Michael
Fritz
25. November 2019 at 10:17 pmHallo,
ich versuche seit geraumer Zeit am ESP-01 den GPIO2 oder GPIO0 als digitalen Input zu programmieren, was mir leider einfach nicht gelingen will. Es braucht irgendwie eine besondere “flash“ Methode, bzw. eine besondere Beschaltung. Hat jemand eine Idee?
Beste Grüße
Fritz
Domenico
20. November 2019 at 7:40 pmHallo,
also ich habe jetzt alles versucht, leider komme ich nicht zum erwünschten Ergebnis.
Mein esp lässt sich nur mit GPIO0 aus GND programmieren.
Das Blik Skech lade ich hoch und der esp zeigt die Datenverbindung per flackern der blauen LED an.
Nach dem Hochladen bekomme ich die Meldung:
Leaving…
Hard resetting via RTS pin…
Reset mit GPIO0 auf GND per Taster lässt den esp kurz blau blinken.
Reset mit GPIO0 unverbunden per Taster schaltet den esp aus.
Die Hinweise, GPIO 0 und 2 kurz auf VCC zu setzen bringt auch nichts.
Leider komme ich da nicht weiter.
Gruß
Domenico
Domenico
19. November 2019 at 7:19 pmVielen Dank für die Info.
Ich hatte bisher immer gelesen, dass GPIO0 und GPIO2 auf High oder offen bleiben können.
Somit habe ich diese auch noch nie auf VCC gesetzt.
Ich werde das ein mal prüfen und werde mich dann auch mit dem Ergebnis zurückmelden.
Gruß
Domenico
Domenico
19. November 2019 at 5:24 pmHallo zusammen.
Ich bin nun seit 2 Wochen dabei, mich mit dem esp8266 01 zu beschäftigen.
Ich habe zwar geschafft, irgendwelche Sketche auf den esp zu laden, jedoch bekomme ich nach dem xxx weder ein Blinken, noch sonst etas zum Laufen.
Lasse ich GPIO0 nach dem Reset unverbunden, schaltet der esp sich aus.
Auch über den Serial Monitor habe ich bisher keine Rückmeldung erhalten.
Es soll ja angeblich per AT Befehl ein OK zurückgegeben werden.
Oder habe ich hier vielleicht keine korrekte Firmware auf dem esp?
Gruß
Domenico
Ronin
19. November 2019 at 6:07 pmHallo Domenico,
Du wirfst hier ein wenig was durcheinander. AT-Befehle werden nur zurückgegeben, so lange sich kein Sketch auf dem Board befindet. Hierfür ist es erforderlich, das Board mit einer neuen Firmenware neu zu flashen. (ESP flashen)
Da Du schreibst, dass Du das 01er hast, musst Du unbedingt darauf achten, dass Du danach die Verbindungsrate auf 9600 Baud auf dem Board einstellst. (Seriellen Monitor öffnen und dann AT+UART_DEF=9600,8,1,0,0 eintippen. Jetzt den seriellen Monitor auf 9600 Baud umstellen und Du solltest eine Ausgabe sehen. Bei Eingabe von “AT” sollte es mit einem “OK” bestätigt werden.)
Das andere siond die Sketche: Du musst nach dem Hochladen Deines Sketches nach dem Reset des ESPs kurzzeitig GPIO0 und GPIO2 auf HIGH ziehen (“Verwenden wir dagegen unser Modul mit dem fertigen Programm, so muss GPIO0 und GPIO2 auf HIGH gezogen werden.”), sonst tut sich nix. Jetzt sollte mit dem für den 01er modifizierten Blink-Programm (LED ist ja bei diesem 01er-Board auf GPIO1) die LED auch blinken.
Unverbunden heißt nicht automatisch High. Das Signal “floatet”. Ist also weder eindeutig LOW, noch HIGH. Daher musst Du beide auf VCC schalten, damit der ESP weiß, dass er im Nicht-Programmier-Modus starten und das Sketch ausführen soll, das sich auf ihm befindet.
Viel Erfolg und bleib dran. Ich weiß, die Dinger sind ätzend im Umgang und man muss sich jedesmal wieder neu eindenken, aber sie ergänzen sich super mit dem Arduino. 🙂
Viele Grüße, Michael
Andreas Worresch
1. Oktober 2019 at 9:32 amServus,
DANKE für deine Arbeit und dafür das du dein Wissen mit uns teilst!!!
Ich habe mir einen Adapter/Shield für den UNO zusammengelötet, und es hat sofort funktioniert !!!
Ein kleine Änderung möchte ich vorschlagen ESP-01 du schreibst “CHPD/EN/CS Chip Select kommt fest mit einem 1 KOhm Widerstand auf die 3,3V Versorgungsspannung” im Schaltplan vwerbindest du den 1k Wiederstand aber auf Masse. Ich hab den Text befolgt und es funktioniert.
lg
Ueli
1. Mai 2019 at 10:54 amHallo,
Ich habe das selbe Problem wie Torsten.
Konntest du es nochmals testen?
Könnte sein, das die RX/TX Leitung vom Arduino 5V ausgeben?
Freundliche Grüsse
Ueli
Ronin
16. September 2019 at 1:36 pmHallo Ueli,
hat jetzt leider etwas länger gedauert, aber ich habe den Artikel nochmal überarbeitet. Du hast Recht mit den 5V aus den Datenleitungen. Hier muss ein Spannungsteiler rein, da RX/TX auch nur 3.3V vertragen.
Darüber hinaus stellte ich fest, dass es an dieser Stelle auch Probleme gab/gibt, weil einige die ESP-01 “Upgraded Version” nutz(t)en und andere die ESP-01S. (Danke an den Hersteller für die Verwirrung 🙂 )
Ich habe jetzt die Beschaltung, so wie die Unterschiede beider Module zum übertragen eines Sketches im Artikel parallel berücksichtigt und nun sollte es keine Probleme mehr geben mit dem Modul. Egal, ob 01 oder 01S.
Viele Grüße,
Michael
Torsten
13. April 2019 at 4:27 pmHallo,
ich habe das gleiche Problem wie Nikita – Verkabelung alles geprüft.
Folgende Ausgabe:
trying to connect
flush start
setting serial port timeouts to 1 ms
setting serial port timeouts to 1000 ms
flush complete
espcomm_send_command: sending command header
espcomm_send_command: sending command payload
read 0, requested 1
warning: espcomm_sync failed
error: espcomm_open failed
error: espcomm_upload_mem failed
error: espcomm_upload_mem failed
Allerdings nutze ich einen Arduino Micro. Funktioniert das Flashen auf diese Weise nur mit einen Arduino Uno
Ronin
15. April 2019 at 9:36 amHallo Torsten,
hmmm, ich werde es die Tage selbst nochmal testen und nochmal was dazu schreiben. Weiß nur noch nicht genau, wann, da ich noch einiges zu tun habe.
Aber zu Deiner letzten Frage. Ja, das flashen funktioniert auch mit einem Micro oder Nano. Bis auf die Bauform ist es der gleiche 328P-IC-Baustein wie beim Uno, der auf der Platine sitzt.
Viele Grüße,
Michael
Phil
13. März 2019 at 2:52 pmHallo,
das übertragen ist tatsächlich echt kompliziert. Mit der Anleitung habe ich es allerdings gut hinbekommen. Echt eine der besten die man so findet. Ich hab es ohne extra Spannungsversorgung probiert, direkt am Arduino, das ging gut.
Was allerdings Probleme gemacht hat: der 10k Widerstand hat das Übertragen blockiert, habe ihn weggelassen, dann erst hat er programmiert. Ein weiteres Problem war
int LED=1; // GPIO1 = blaue LED
Die blaue LED hängt wohl an GPIO2, habs abgeändert, dann gings!
Vielen Dank für die Anleitung.
Gruß
Ronin
13. März 2019 at 7:46 pmHallo Phil,
Dankeschön, das freut mich, dass Dir meine Anleitung weitergeholfen hat.
Es kommt in der Tat immer darauf an, welcher Arduino das ist. Es gibt einige Klone, die haben so schlechte Linearregler verbaut, dass die nicht den notwendigen Strom bereit stellen können und andere, die das können. Ich hatte bisher immer die Klone, wo das nicht ging. 🙂
Den 10K könnte man auch gegen einen 1K tauschen. Das sollte dann auch gehen. Kurzfristig zum programmieren geht natürlich auch direkt auf GND.
Mit der LED kann sein, dass es da zwischen neueren und älteren Modulen Unterschiede gibt. Ich habe noch dunkel in Erinnerung, dass die neueren Module wie bei Dir den GPIO2 statt GPIO1 verwenden.
Das mal als Hinweis, falls der ein oder andere auch noch darüber stolpern sollte.
Viele Grüße,
Michael
Nikita
3. Februar 2019 at 10:05 pmGrüß Gott!
Bitte antworten sie Schnell.
Wenn ich alles mache und dann den Arduino mit Strom versorge geht eine rote Lampe auf.
Alles funktioniert nicht.
Fehlermeldung:
warning: espcomm_sync failed
error: espcomm_open failed
error: espcomm_upload_mem failed
error: espcomm_upload_mem failed
Danke
Nikita
Ronin
3. Februar 2019 at 11:50 pmHallo Nikita,
Rote Lampe auf dem ESP-Modul vermute ich?
Das ist in Ordnung. Es gibt eine rote Power-LED und direkt daneben flackert bei Datenübertragung eine kleine blaue LED, bzw. im Programmiermodus leuchtet sie auch blau.
Deine Fehlermeldung deutet darauf hin, dass die serielle Verbindung nicht korrekt zu sein scheint. Überprüfe nochmal genau RX und TX. RX muss auf RX und TX auf TX angeschlossen sein. Das ist sehr wichtig, da der Arduino nur als Durchgang dient und alle Kommandos an den ESP weiterleitet. Andernfalls versuchst Du den Arduino mit dem ESP-Programm beschreiben zu wollen.
Ein weiterer Fehler kann sein, dass die Auswahl des Controllers in Deiner Arduino-IDE nicht korrekt ist. Schau hier bitte nochmal nach, ob Du auch wirklich den korrekten ESP8266 ausgewählt hast.
Es ist sehr frickelig die ESP’s auf diese Weise zu programmieren und erzeugt eine Menge Frust, aber wenn Du die Anleitung genauestens abarbeitest, muss es funktionieren. Ich muss sie selbst immer wieder nutzen, wenn ich mal wieder was mit den ESP8266 bauen will und es funktioniert selten auf Anhieb, weil ich irgendeinen kleinen Step vergessen habe.
Hoffe, ich konnte Dir bei Deiner Fehlersuche helfen.
Viel Erfolg und viele Grüße,
Michael