ESP8266 & Telegram

Einen Mikrocontroller per Messenger Befehle senden oder Daten erhalten? Ja das geht, und es ist auch genau so cool wie es sich anhört!

An dieser Stelle sollte eigentlich ein kurzes Video folgen, da man dazu jedoch einen Premium-Tarif benötigt, und das neben meiner Website etwas unnötig wäre, gibt es stattdessen den Link zur genannten Website: 

http://deloarts.com/de/arduino/esp8266_telegram/

Dank der entsprechenden Lib (folgt später im Eintrag) erspart man sich viel Schreibarbeit und kann gleich loslegen. Wenn man sich die Bibliothek genauer anschaut merkt man die Ähnlichkeit zur Python API, es ist lediglich stark abgespeckt, was für die Nutzung auf dem ESP nur Hilfreich ist.

Telegram

Zuerst muss man Telegram als Messenger nutzen, entweder auf dem Smartphone, Tablet oder dem PC. Danach kann man schon damit beginnen, einen Bot zu erstellen. Der Übersicht zu Liebe folgt ein Copy/Paste-Inhalt aus dem Raspberry-Tutorial.

Startet damit in das Suchen-Feld den Namen BotFather einzugeben. Dies ist der Manager aller Bots auf Telegram. Bei ihm sucht man um einen neuen Bot an.

Search_Botfather

Sendet ihm den Befehl /newbot, wählt einen Namen und einen Benutzernamen. Der Benutzername ist öffentlich sichtbar und auffindbar, durch geschickte Programmierung redet der Bot aber nur mit ausgewählten Nutzern. Als Namen vergebe ich gerne einen projektbezogenen, in diesem Fall wäre ‚Doorbell‘ recht passend.

Talk_To_BotFather

Ist der Vorgang abgeschlossen, so erhält man einen eindeutigen Token. Dieser ist später im Programm wichtig!

Das Programm

Zu finden wie immer auf GitHub. Wer neu ist, und das ESP noch nicht so gut kennt, dem empfehle ich das Setup-Tutorial zum Board.

Oben im Beitrag habe ich die Lib erwähnt, welche für die Nutzung der Telegram API benötigt wird. Die habe ich sie in das GitHub-Verzeichnis von mir kopiert, um immer die passende Version zu haben.

Bevor ihr beginnen könnt, gebt die WLAN-Daten eures Netzwerks ein.

static char SSID[] = "your network name";
static char password[] = "your password";
static char hostname[] = "Doorbell";

Weiter geht’s mit den Definitionen des Programms, dazu muss man den Botnamen, seinen Usernamen, den Token und die ID angeben, an welche die Nachrichten geschickt werden sollen.

#define botName "Doorbell"
#define botUserName "something that ends with bot"
#define botToken "your:token"
#define adminID "yourID"

Die adminID ist demzufolge die ID eures persönlichen Telegram-Accounts. Um diese herauszufinden, ladet das Script auf den ESP, gebt aber zuvor in den Programmdefinitionen eure Daten ein (Username & Token). Über das Suchen-Feld in Telegram könnt ihr über den Usernamen euren Bot finden. Sendet danach dem Bot über Telegram eine Nachricht, dieser wird euch sodann eure ID zurücksenden.

String senderID = bot.message[i][4];
bot.sendMessage(bot.message[i][4], "Access denied. Your ID: " + senderID, "");

Ein anderer Weg ist der serielle Monitor. Die Chat ID wird bei jedem Zugriff angezeigt.

Tragt danach die ID einfach an der entsprechenden Stelle im Programm ein, und voilà, der Bot hört auf euch.

Am Beginn sollte man den ESP via USB mit dem PC verbinden (auf die Baudrate achten), um die Debuginformation zu erhalten. So lässt sich leicht ein möglicher Fehler entdecken, etwa falsche WLAN-Zugangsdaten oder ein falscher Token.

Zurück zum eigentlichen Programm.

Im setup() werden alle Routinen gestartet, das Programm ist (hoffentlich) gut auskommentiert.

In der loop() ist es schon etwas interessanter. Grundsätzlich wäre dem Zweck Genüge getan, wenn der Controller auf das Betätigen des Tasters wartet, und dann eine Nachricht an die AdminID sendet.

if (!digitalRead(inputPin))
{
    bot.sendMessage(adminID, "Ding Dong", "");
}

Ich möchte aber auch zeigen, wie man dem ESP über Telegram Befehle senden kann, weshalb das Programm noch etwas weiter geht. So könnte man etwa ein Relais ansteuern, oder Daten eines Sensors abgreifen. Um das tun zu können, muss man wissen, wo die Daten gespeichert werden.

Grundsätzlich werden die Telegram-Daten beim Empfangen in einem zweidimensionalen Array gespeichert: bot.message[i][j]. Ist i gleich 0, so werden Sonderfälle behandelt:

  • bot.message[0][0]: Anzahl der anstehenden Nachrichten.
  • bot.message[0][1]: ID der letzten Nachricht.

Ansonsten ist i der Index der eingegangenen Nachrichten. j beinhaltet die Daten, welche zu i gehören.

  • bot.message[i][0]: Update ID
  • bot.message[i][1]: User ID
  • bot.message[i][2]: Vorname
  • bot.message[i][3]: Nachname
  • bot.message[i][4]: User ID
  • bot.message[i][5]: Nachricht

Zuerst prüfen wir, ob Updates, also neue Nachrichten zur Verfügung stehen. Diese werfen wir dazu in das Array um sie später zur Verfügung zu haben.

bot.getUpdates(bot.message[0][1]);

Danach arbeiten wir uns Schritt für Schritt durch die Daten durch, und prüfen zugleich, ob die empfangene Nachricht einem Befehl entspricht.

for (int i = 1; i < bot.message[0][0].toInt() + 1; i++)
{
    if (bot.message[i][4] == adminID)
    {
        bot.message[i][5] = bot.message[i][5].substring(1, bot.message[i][5].length());
        if (bot.message[i][5] == "info")
        {
            bot.sendMessage(bot.message[i][4], "Hello.", "");
            bot.sendMessage(bot.message[i][4], "I am your doorbell.", "");
        }

        ...

    }
}

i entspricht, wie wir wissen, dem Index der IDs, welche dem Bot eine Nachricht gesendet haben. Bevor wir also auf eine Nachricht antworten, prüfen wir ob der Absender auch berechtigt ist, eine Antwort vom Bot zu bekommen. Ist er das nicht, bekommt er eine entsprechende Rückmeldung.

bot.sendMessage(bot.message[i][4], "Access denied.", "");

So viel zum Programm. Man sieht, es steckt nicht viel dahinter (also, eigentlich schon, aber das Interface ist einfach).

Der elektrische Aufbau

Zum Testen des Programms reicht die Lochrasterplatine vom Setup-Tutorial und ein Taster, wie es im Video am Beginn gezeigt wird.

Ich möchte die bestehende Türklingel nicht durch die WIFI-Klingel ersetzen, sondern beide parallel bestehen haben. Deshalb setze ich ein Relais in die Leitung der vorhandenen Glocke, welches das Signal an den Controller gibt, sobald die Taste betätigt wird. Hierfür muss man das Relais entsprechend der verbauten Klingel auswählen. Meine arbeitet mit 12VDC, weshalb ich auch ein Relais nutze, das bei 12V schließt. Dabei ist darauf zu achten, dass das Netzteil für die Klingel genügend Strom für die Klingel selbst, als auch für das Relais liefert.

shematic.jpg

Im Schaltplan erkennt man unter anderem, dass das Relais ohne Pull-Down-Widerstand (im Normalfall 10kΩ) an den Controller angeschlossen wird. Der Grund ist der gleiche, wie der im Setup-Tutorial beschriebene: Ist einer der beiden GPIO-Pins beim Booten nicht logisch HIGH (oder in einem Zwischenzustand), so startet der ESP nicht das Programm, sondern erwartet den Upload eines Programms. Deshalb starte ich den ESP mit offenem Relais (es ist doch sehr unwahrscheinlich, dass jemand anleutet wenn der Controller gerade bootet).

Der zweite Punkt, welcher auffällig ist, ist dass der GPIO-Pin über das Relais nicht mit +3V3 verbunden ist, sondern mit der Groundleitung. Dazu bedarf es einer Erklärung des …

INPUT_PULLUP

Von den Schaltungen eines Arduinos ist man es gewohnt, einen Taster mit VCC und dem Pin zu verbinden. Vom Pin ausgehend schließt man einen hochohmigen Widerstand auf Ground um Störsignale oder Signalschwankungen zu filtern.

input

Würde man den Pull-Down-Widerstand weglassen, so wäre der Pin bei offenem Taster in einem Zwischenzutand (floating). Es ist also nicht eindeutig festgelegt, ob der Taster nun offen ist. Auf diese Weise können Signale der Umgebung, elektromagnetische oder magnetische Felder, den Pin beeinflussen. Das kann man sich sehr gut veranschaulichen, indem man sich über den seriellen Monitor eines blanken Arduinos den Wert eines Analogpins ausgeben lässt. Bewegt man das Board oder hält ein elektrisches Gerät in seine Nähe, so ändert sich der Wert.

/* Button an Pin 12,
   LED an Pin 13
*/
pinMode(12, INPUT);
pinMode(13, OUTPUT);
digitalWrite(13, digitalRead(12));

Das Programm sieht daher so aus wie immer, wird der Taster betätigt, so leuchtet die LED. Das ganze kann man aber auch umgekehrt lösen, indem man einen Pull-Up-Widerstand nutzt. Dieser wird zwischen VCC und dem Pin eingesetzt.

input_pullup

Ist der Taster offen, so bleibt die Spannung am Widerstand gleich – 5V, 3V3, … was auch immer die Versorgungsspannung ist. Das bedeutet, dass am Pin immer 5V, 3V3, … anliegen. Wird der Taster gedrückt, so fällt die Spannung auf Null ab. Durch den hochohmigen Widerstand verhindert man zudem ein Kurzschließen des Schaltkreises. Man sollte allerdings keinen allzu großen Widerstand wählen, da ansonsten das Rauschen wieder zurückkehrt (Luft ist ja auch ein Widerstand) – 10kΩ sind die Faustregel bei Controllern bis +5V Betriebsspannung.

/* Button an Pin 12,
   LED an Pin 13
*/
pinMode(12, INPUT);
pinMode(13, OUTPUT);
digitalWrite(13, !digitalRead(12));

Im Programm hat man nur eine kleine Änderung zu machen: Den Input mit dem Rufzeichen zu negieren. Ist der Taster nicht gedrückt gibt digitalRead(pin); true zurück und vice versa.

Nun könnten wir das bereits nutzen, um den Button am ESP anzuschließen. Der Pin wäre ohne Interaktion immer logisch HIGH, wodurch der Controller problemlos booten kann. Allerdings hat der Controller die nette Eigenschaft, einen hochohmigen Widerstand hinter seinen GPIO-Pins verbaut zu haben. Das bedeutet, dass wir uns darum nicht mehr kümmern müssen und der Aufbau sich vereinfacht:

input_internal

Gut, etwas muss man schon beachten: Der interne Widerstand muss aktiviert werden. Dies erledigt man, indem man den Input nicht mit pinMode(PIN, INPUT);, sondern mit pinMode(PIN, INPUT_PULLUP); festlegt.

/* Button an Pin 12,
   LED an Pin 13
*/
pinMode(12, INPUT_PULLUP);
pinMode(13, OUTPUT);
digitalWrite(13, !digitalRead(12));

Das lässt sich übrigens auch am Arduino anwenden. Wer also gerade keinen Widerstand zur Hand, oder nicht genug Platz für einen hat, muss nicht verzweifeln: einfach INPUT_PULLUP nutzen!

Weiters sind, auf das Arduino Nano bezogen, auch die analogen Pins A0-A5 (oder 14-19) als digitaler Input nutzbar, und sie haben ebenso einen Pull-Up-Widerstand verbaut. Lediglich die beiden letzten analogen Inputs (A6 und A7 [oder 20 und 21]) haben keinerlei Schaltung und dienen ausschließlich als analoger Input.

Und weil wir bereits beim Arduino sind: Der digitale Pin 13 kann nicht als Pull-Up-Input genutzt werden, da auf den Arduino Boards eine LED mit einem 330Ω Widerstand verbaut ist. Diese verhindert die Funktion, da sie den Pin dauerhaft mit GND verbindet und somit der Pin immer geschalten werden würde.

Zurück zum Thema: Für den Aufbau habe ich die folgenden Bauteile genutzt:

.

Stk. Komponente Ausführung Beschreibung
1 ESP8266 ESP-01
1 Widerstand 10kΩ
1 Spannungsregler LD33V 12VDC -> 3V3DC
2 Elektrolytkondensator 10µF
1 Kermaikkondensator 0.1µF
1 Relais 12VDC Passend zur Klingel

.

Die Kondensatoren dienen zur Glättung der Spannung, ohne diese würde der Spannungswandler instabil werden und die Spannung am Ausgang würde stark schwanken – schlecht für den ESP. Das passiert, weil der verwendete Spannungswandler von seinem Aufbau her ein rückgekoppelter Verstärker ist.

setup

Eine weitere Möglichkeit, neben dem Taster, wäre die Nutzung eines Infrarot-Bewegungsmelders. Diesen könnte man sogar an den verbeleibenden Pin des ESP anschließen (auf die galvanische Trennung beim Booten sollte man achten).

Fragen? Kommentar!

Advertisements

ESP8266 Web Socket

Wer diesen Eintrag zum Setup des ESP8266 WiFi-Moduls gelesen hat und nun mehr mit dem Controller machen will, der ist hier genau richtig. Was genau kann man von diesem Tutorial erwarten? Ich zeige wie man das ESP so programmiert, dass man damit eine LED-Lichtleiste mit Hilfe eines Transistors über ein Smartphone ein- und ausschalten kann. Obendrein gibt’s natürlich wieder alle Erklärungen und Anleitungen bezüglich der verwendeten Hardware.

Da ich in diesem Beitrag unter anderem ein kurzes Video habe, und WordPress die Datei aus Gründen nicht wiedergeben will, gibt es diesen Beitrag nur auf meiner Website. Ein Premiere, wenn man so will.

Und los geht’s! 

ESP8266 Setup

Das ESP8266-WiFi-Modul ist klein, günstig und funktioniert problemlos – vorausgesetzt man bekommt es erst einmal zum laufen. Wie man das macht, welche troubleshooting-Möglichkeiten es gibt und was man damit anstellen kann zeige ich hier. Am meisten geholfen hat mir das ‚community wiki‚ des Controllers. Ich programmiere es mit der Arduino IDE 1.6.9, da es leider keinen Support für Sublime Text 3 & Stino gibt. Jede neuere Version der IDE sollte ebenso problemlos funktionieren.

esp8266

Am Ende dieses Tutorials soll das ESP die angeschlossene LED blinken lassen. Das mag sich nicht nach viel anhören, soll aber die Basis für alle weiteren meiner ESP-Tutorials werden. Zu allem später mehr, jetzt folgen erst einmal die …

Spezifikationen

Das Modul hat eine integrierte WLAN-Schnittstelle (802.11 b/g/n [2.4GHz]) und unterstützt neben den Funktionen als Endgerät, Accesspoint auch Peer-To-Peer Kommunikation. TCP/IP ist integriert. Der wichtigste Punkt zu Beginn ist jedoch: Versorgungsspannung 3.3V, nicht 5V tolerant!

Mehr …

Preislich liegt das Modul zwischen 2€ und 5€, abhängig von der Ausführung. Die hier von mir vorgestellte Version (esp-01) ist eine der günstigsten, hat im Gegensatz zu den teureren Varianten nur 2 GPIO-Pins.

Es hat keinen FTDI-Chip integriert, das bedeutet, dass man es nicht so bequem an den PC anstecken kann wie ein Arduino, um es zu programmieren. Abhilfe schafft hier ein günstiger FTDI-Adapter.

ftdi232

Dieser sollte unbedingt neben 5V auch 3.3V unterstützen, da man ansonsten zwischen den Signalpins (RX, TX) einen Logic-Level-Shifter benötigt.

ftdi232_supply

Wer einen zu meinem Adapter ähnlichen verwendet, der muss einfach nur den Jumper zwischen den mittleren und den 3.3V-Pin stecken. Schon ist die Signalpegel-Logik auf 3V3 gestellt.

Den FTDI Adapter sollte man allerdings nicht als Versorgung nutzen, da das ESP oftmals mehr Strom benötigt als der Adapter zur Vrfügung stellen kann.

Der elektrische Aufbau

Für das Tutorial benötigt man neben dem ESP8266-01 noch ein paar weitere Komponenten, um es einerseits programmieren zu können, es andererseits auch nutzen zu können.

Stk. Komponente Ausführung Beschreibung
1 ESP8266 esp-01
1 FTDI-Adapter FTDI232 5V & 3V3
1 Versorgung 3.3V 2AA Batterien oder Netzteil
2 Widerstände 10kΩ
1 Pushbutton Programmer-Mode
1 LED
1 Schalter Optional
n Drahtbrücken

Das nachfolgende Bild zeigt die Pinbelegung des ESP Moduls.pinout

Die Verdrahtung erfolgt nach dem unten gezeigtem Schaltplan. Auch auf die Gefahr hin, dass ich mich wiederhohle möchte ich nochmals darauf hinweisen, das FTDI-Modul so zu nutzen, dass es mit 3.3V arbeitet.

shematic

Wer sich den Schaltplan genau ansieht erkennt, dass die LED nicht wie gewohnt angeschlossen wird, sondern verkehrt. Also die Anode (+) der LED auf Vcc, und die Kathode (-) auf den GPIO_2 Pin. Der Grund hierfür ist, dass beide GPIO Pins (GPIO_0 & GPIO_2) des ESP8266 Moduls beim Booten logisch HIGH (oder in einem Zwischenzustand) sein müssen. Würde man die LED wie gewohnt anschließen, also Anode auf GPIO_2 und Kathode auf GND, so würde das ESP denken, dass man ein Programm via UART darauf laden möchte. Jedoch muss man dann später im Programm darauf achten, die Logik des Ausgangs zu invertieren. Mit digitalWrite(Pin, HIGH); wird die LED ausgeschalten und vice versa.

Zum Schluss sollte der ganze Setup in etwa so aussehen. Anstatt der beiden Batterien kann man natürlich auch eine andere Versorgung nehmen, etwa ein Netzteil mit 3V Output.

setup

Die Arduinno IDE vorbereiten

Damit man mit der Arduino IDE das ESP-Modul programmieren kann muss man dieser das Board erst einmal hinzufügen und konfigurieren. Dazu öffnet man zunächst die IDE und führt die folgenden Schritte aus:

  • Prefrences öffnen (File -> Preferences)
  • Auf das Icon neben ganz rechts neben den Additional Boards Manager URLs klicken.
  • Am Ende, falls bereits Einträge existieren, folgenden Link hinein kopieren:
http://arduino.esp8266.com/stable/package_esp8266com_index.json
  • Alle Fenster mit Ok schließen.
  • Den Board Manager öffnen (Tools -> Board „…“ -> Boards Manager)
  • Den Eintrag esp8266 by ESP8266 Community installieren.

Eine bebilderte Anleitung gibt es hier, allerdings von einem anderen Projekt.

Nun ist das WiFi Modul in der Arduino IDE registriert und kann verwendet werden. Dazu muss man es lediglch von den Boards (Tools -> Boards) auswählen und wie folgt konfigurieren:

  • Board: „Generic ESP8266 Module“
  • Flash Mode: „DIO“
  • Flash Size: „512K (64K SPIFFS)“
  • Flash Frequency: „40MHz“
  • CPU Frequency: „80MHz“
  • Upload Speed: „115200“

esp_ide

Der Port entpricht jenem Port des FTDI-Adapters. Hat man diesen mit dem PC verbunden, kann man seinen Port auswählen.

Das Programm

Wie ich bereits erwähnt habe ist das Programm sehr simpel, da dieser Eintrag nur als Basis für weitere Projekte mit dem WLAN-Modul dienen soll. Man kann es einfach in die Arduino IDE kopieren und dann auf das ESP hochladen.

Aber halt: Wie lädt man das Programm auf den Controller? Nun kommt endlich der Button zum tragen. Wird dieser gedrückt, so wird das ESP in den Programer-Modus versetzt und erlaubt es, von der Arduino IDE programmiert zu werden. Dazu muss man wie folgt vorgehen:

  • Die Spannungsversorgung zum ESP trennen, der FTDI Adapter kann mit dem PC verbunden bleiben.
  • Den Button drücken und gedrückt halten.
  • Die Spannungsversorgung wieder herstellen.
  • Der Button kann losgelassen werden.
  • Das Programm hochladen.
  • Nach dem erfolgreichen Upload muss das ESP eventuell neu gestartet werden.

Anmerkung: Es ist auch möglich, das ESP ohne einen Button zu programmieren, dafür ist allerdings ein anderer FTDI-Adater nötig. Durch das Fehlen eben dieses kann ich darauf leider nicht weiter eingehen.

#define LED_PIN 2

void setup()
{
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, HIGH); // Invertierte Logik!
}

void loop()
{
    digitalWrite(LED_PIN, LOW);
    delay(100);
    digitalWrite(LED_PIN, HIGH);
    delay(100);
}

Nach dem Hochladen (es nimmt etwas Zeit in Anspruch, da die ESP Dateien miteingebunden werden müssen und der Flash komplett überschrieben werden muss) sollte die angeschlossene LED schnell blinken. Tut sie das nicht, so können diese Tipps eventuell hilfreich sein.

Einen Schritt weiter gehen

Das ESP8266-01 hat den gleichen Aufbau wie das nRF24L01+ Funkmodul. Das bedeutet, dass es genauso schlecht auf ein Breadboard passt, wie das genannte Modul. Beim Funkmodul ist das noch nicht so tragisch, man lässt es im Allgemeinen für die Dauer des Projekts am Arduino montiert oder verlötet es zum Schluss auf eine Platine. Beim ESP ist das etwas anders, denn zum Flashen des Programms muss der „Programmer-Aufbau“ verwendet werden, welche unter Umständen nicht für anderes geeignet ist. Deshalb habe ich für das Funkmodul eine kleine Platine aus einer Lochrasterplatine gebaut.

perfboard_setup.jpg

Gut, auf dem Bild kann man nicht viel erkennen, deshalb gibt es im Anschluss das Fritzing-File-Bild. Ich habe 3 Terminal-Blocks (doppelte Ausführung), 3 Stiftleisten (2×4 & 1×6 Pins), 1 Steckerbuchse, den Schalter, den Button und die beiden Widerstände verbaut. Damit, und mit der richtigen Verkabelung kann man die WiFi-Module bequem programmieren und im Anschluss wo anders weiter verwenden.

perfboard

Der Pinout von links (1) nach rechts (6):

Pin Anschluss Anmerkung
1 Vcc 3.3V max.
2 GND
3 3.3V Für Sensoren, etc
4 GND Für Sensoren, etc
5 GPIO 0 SDA
6 GPIO 2 SCL

Zugegeben, auch dieses Bild ist etwas unübersichtlich, doch mit ihm und dem oben gezeigten Schaltplan sollte das Nachbauen kein Problem mehr sein. Ich habe lediglich die LED weggelassen. Zum Testen des hier gezeigten Programms kann man sie aber einfach zwischen die GPIO_2 und GND Pins der Terminal-Blocks stecken.

Troubleshooting

Ich habe einige Zeit gebraucht, bis ich das ESP zum Laufen bekommen habe, da ich Fehler Nummer eins der folgenden Liste begangen habe. Zusätzlich habe ich noch ein paar weitere Ratschläge aufgeschrieben, sodass man das WLAN-Modul tatsächlich zum Funtionieren bringt.

  • Den Taster auf Funktion prüfen. Es ist doch tatsächlich daran gescheitert, dass der Button für den Programer-Modul defekt war, und ich das ESP nie programmieren konnte. Dinge an die man niemals denkt …
  • Eine stabile Spannungsversorgung. Alte Batterien oder eine schwankende Eingangspannung können die Ursache für Fehlverhalten sein. Zu Beginn habe ich die Spannungsversorgung durch herausziehen einer Drahtbrücke unterbrochen. Durch schlechte Kontakte am Steckbrett wurde die Verbindung nicht so hergstellt, wie sie sollte. Nun trenne ich die Spannung nur mehr mit soliden Schaltern.
  • Beide LEDs (rot & blau) am ESP leuchten. Das bedeutet, dass das ESP Daten via UART anfordert und nicht bootet. Der Fehler ist, dass GPIO_2 auf dem Ground-Potential liegt. Umgehen kann man das so.
  • Alle Verbindungen prüfen. Es kann durchaus sein dass man einen Pin falsch angeschlossen hat, oder den Ground nicht mit allen Geräten (ESP8266 & FTDI) geteilt hat.
  • Die Baudrate ist falsch eingestellt. Im Normalfall ist die Baudrate 115200bps oder 9600bps. Das ist wiederum abhängig von der Version, einfach mal beides testen.
  • WLAN Daten prüfen. Wer bereits ein WLAN-fähiges Programm laufen hat, der kann nochmal die WLAN Zugangsdaten prüfen. Beim Passwort habe ich mich schon öfter vertippt.
  • Module neben dem ESP-01: Der GPIO-Pin Nummer 15 muss auf Ground liegen.
  • Fehlerhaftes ESP. Es gibt tatsächlich eine defekte Charge des Moduls, hier ist der Widerstand für die Power-LED zu schwach, was zu einem Durchbrennen dieser führt.

Mit dem ESP arbeiten

Hier werde ich erst einmal einen Schlussstrich ziehen und auf die anderen Tutorials verweisen, welche nach und nach kommen werden.

Easy going

Wem es zu viel Aufwand ist, sich die Lochrasterplatine nachzubauen, oder wer keine Lust auf Kabelsalat hat: ESP8266 NodeMcu ist das Stichwort. Das Board ist Ähnlich dem Aufbau eines Arduino Nanos und es lässt sich auch genauso bequem über einen USB Port programmieren.

Ansonsten bleibt zu sagen: Viel Spaß mit dem ESP8266, ich habe ihn definitiv!