ESP8266 ESP-01 Modul

Über den Beitrag

Über das ESP8266 ESP-01 Modul wurde schon sehr viel geschrieben. Warum also nun noch ein weiterer Beitrag dazu? Bis ich mit meinem ESP-01 Modul alles machen konnte was ich mir für den Anfang vorgenommen hatte, hat es trotz der Fülle an verfügbaren Informationen viel Zeit gekostet, da die benötigten Details auf viele Quellen verteilt waren. Deshalb hier nun der Versuch einer nicht zu langen aber nachvollziehbaren Schritt-für-Schritt Einführung in die grundlegenden Funktionen. Dabei setze ich den Schwerpunkt auf die Programmierung mit der Arduino IDE. Im Einzelnen behandele ich die folgenden Themen:

  • Integration der ESP8266 Produktfamilie in die Arduino IDE
  • Schaltung für die Programmierung mit einem Arduino
  • Schaltung für die Programmierung mit einem USB-zu-TTL Adapter
  • Steuerung der GPIOs per WLAN
  • Messwerte auf einer Website darstellen und regelmäßig aktualisieren 
  • Aktualisierung / Wiederherstellung der Firmware
  • Steuerung des ESP8266 ESP-01-Modul per AT-Befehle (Server einrichten / GPIOs schalten)
  • LUA Programmierung (nur als Verweis)

Grundlegendes

Ein ESP8266 ESP-01 Modul oder kurz ESP-01 Modul basiert auf dem ESP8266 Chip der Firma Espressif. Dieser Chip wird auf verschiedenen Modulen verbaut, wobei das ESP-01 Modul die einfachste Ausfertigung darstellt. Es handelt sich im Prinzip um einen recht leistungsfähigen Microcontroller mit integriertem WLAN. 

Die Original Firmware lässt eine Programmierung über die etwas sperrigen „AT-Kommandos“, die ihr vielleicht von Bluetooth Modulen wie dem HC-05 und HC-06 her kennt, zu. Diese Bauteile habe ich hier beschrieben. Fleißige, schlaue Leute haben es dann möglich gemacht die ESP8266 Module auch mit der Arduino Plattform zu programmieren, was das Hauptthema dieses Beitrags ist. Ich gehe später aber auch noch kurz auf die AT-Kommandos ein.

Hinweis: Wenn man einmal einen Arduino Sketch hochgeladen hat, ist die Firmware damit überschrieben und das Modul versteht keine AT-Befehle mehr. Dann muss man es erst wieder mit der Originalfirmware flashen. Das ist keine ganz große Sache, erfordert aber einige Schritte. Dazu weiter unten mehr.

Ein- und Ausgänge des Moduls

ES8266 ESP-01 Modul mit Breadboard Adapter
ES8266 ESP-01 Modul mit Breadboard Adapter

Das ESP-01 Modul besitzt 8 Pins, die so angeordnet sind, dass man es nicht direkt in ein Breadboard stecken kann. Deswegen und weil man sich wegen der fehlenden Beschriftung auch leicht vertun kann, empfehle ich die Anschaffung eines kleinen Adapters (siehe Foto). Man bekommt das Modul mit Adapter z.B. bei Amazon für 5 – 10 Euro.

Das Modul wird über VCC/GND mit Strom versorgt. Die Spannung sollte zwischen 2.5 und 3.6 Volt liegen. Die Kommunikation erfolgt seriell über TX und RX. Programmiert man über einen Arduino, muss streng genommen noch ein Spannungsteiler oder Logik Levelkonverter vor RX gesetzt werden, damit auch hier die 3.6 Volt nicht überschritten werden. Der CH-PD Pin ist der Enable Pin und wird mit der Spannungsversorgung verbunden. Der RST Pin löst – wenn er kurz auf „LOW“ gesetzt wird – einen Reset aus. GPIO0 und GPIO2 (General Purpose Input Output) sind die beiden programmierbaren Ein-/Ausgänge. GPIO0 wird zusätzlich benötigt um das ESP8266 ESP-01 Modul in den Programmiermodus zu bringen. Zu diesem Zweck wird dieser Pin beim Einschalten der Spannungsversorgung oder während eines Resets mit GND verbunden. Danach kann die Verbindung zu GND gelöst werden. Das Modul verbleibt im Programmiermodus bis ein Sketch hochgeladen wird.

Pinbelegung des ESP8266 ESP-01 Moduls
Pinbelegung des Moduls

Man kann TX noch als GPIO1 und RX als GPIO3 erreichen und kommt so auf immerhin vier Ein-/Ausgänge. Trotzdem ist das ESP8266 ESP-01 Modul wegen der geringen Zahl an GPIOs in seinen Möglichkeiten natürlich ein wenig beschränkt. Wer mehr benötigt, kann auf die größeren Vertreter der ESP8266 Modulfamilie zurückgreifen, insbesondere den ESP-12. In einem noch folgenden Beitrag werde ich aber auch zeigen, wie man mit GPIO0 und GPIO2 eine Porterweiterung realisieren kann. 

Vorbereitung der Arduino IDE

Es dauert keine zwei Minuten die Arduino IDE um die ESP8266 Module zu erweitern. Im ersten Schritt muss man die entsprechende Boardverwalter-URL eintragen. Dazu müsst ihr auf Datei -> Voreinstellungen gehen und auf das rot markierte Symbol klicken:

Eintragen der Boarverwalter URL

Dann gebt ihr die Adresse: „http://arduino.esp8266.com/stable/package_esp8266com_index.json“ als separate Zeile ein und bestätigt mit „OK“:

Eintragen der Boardverwalter URL II

Im nächsten Schritt geht ihr in die Boardverwaltung, sucht nach „esp8266“ und installiert das Paket:

Board Manager wählen….
….und das „esp8266“ Paket installieren

Schließlich müsst ihr die Arduino IDE nochmal neu starten und das war’s. 

Sketche hochladen

Hochladen per Arduino

Bei der Schaltung ist zu beachten:

  • TX kommt an TX und RX an RX; Vmax am RX des ESP01 ist 3.6V 
    • deshalb Spannungsteiler verwenden: 1kOhm / 2.0 oder 2.2 kOhm
  • Reset des Arduino an GND
  • VCC (ESP-01) an 3.3V
  • GND an GND
  • CH_PD an 3.3V
  • GPIO0 an GND (um in den Programmiermodus zu kommen)
  • RST (ESP-01) für einen Reset an GND, z.B. über einen Taster
ESP8266 ESP-01 Modul - Schaltung für Programmierung über einen Arduino

Als Board wählt ihr in der Arduino IDE das „Generic ESP8266 Module“. Außer dem Port lässt man die anderen Einstellungen so wie sie sind. 

Auswahl des richtigen Boards in der Arduino IDE

Als Test bietet sich ein einfacher Blink Sketch an:

int LEDPin = 2; // GPIO2

void setup() {
  pinMode(LEDPin, OUTPUT);     
}

void loop() {
  digitalWrite(LEDPin, LOW); 
  delay(500);                     
  digitalWrite(LEDPin, HIGH);  
  delay(500);                      
}

Wenn ihr dann eine LED an GPIO2 anschließt sollte es funktionieren. Falls nicht, so solltet ihr, sofern noch nicht geschehen, die Verbindung GPIO0 – GND lösen und einen Reset durchführen. 

Hochladen per USB-zu-TTL Adapter

Nehmt ihr einen USB-zu-TTL Adapter anstelle eines Arduino, solltet ihr am besten ein Modell wählen bei dem man 3.3 V einstellen kann. Hier ein Beispiel:

USB-zu-TTL Adapter mit einstellbarer Spannung
USB-zu-TTL Adapter mit Jumper zur Einstellung von 3.3 oder 5 Volt

Bei der Schaltung ist zu beachten, dass hier nun RX mit TX und TX mit RX verbunden werden. Ein Spannungsteiler für RX fällt weg, sofern man seinen Adapter auf 3.3 Volt einstellen kann. 

ESP8266 ESP-01 Modul - Schaltung für Programmierung über einen USB-zu-TTL Adapter

Steuerung der GPIOs per WLAN

Zum „Aufwärmen“: Nachricht an den Browser

Das ESP8266 Paket für den Arduino umfasst einen großen Umfang an Bibliotheken und Beispielen. Wer richtig tief einsteigen möchte, sollte sich mit dem WLAN Protokoll und HTML beschäftigen. Aber keine Sorge, vieles lässt sich auch einfach realisieren. 

Den folgenden Sketch müsst ihr nur leicht anpassen. Am Anfang des Sketches wird ein Server definiert: ESP8266WebServer Server(80);. Die 80 ist dabei der Standardport, so dass man die Website ohne Angabe des Ports im Browser aufrufen kann. In diesem, wie auch den folgenden Sketchen steht in der loop Funktion lediglich: server.handleClient(); Das eigentlich Interessante wird durch server.on("/",handleRoot); im Setup definiert. Übersetzt heißt das: Wenn die Hauptseite („/“) aufgerufen wird, führe die Funktion „handleRoot“ aus. In diesem einfachen Sketch wird in handleRoot lediglich ein Text mit ein wenig HTML Formatierung gesendet. Die „200“ ist der Antwortcode (200 = OK), siehe auch hier

#include "ESP8266WiFi.h"
#include "ESP8266WebServer.h"

const char* ssid = "Eure SSID";
const char* pass = "Euer WLan Passwort";
IPAddress ip(192,168,178,xxx); // 192.168.178.xxx = freie IP Adresse, ggf. müsst ihr auch die anderen Zahlen anpassen; schaut am besten in euren Router
IPAddress gateway(192,168,178,1);
IPAddress subnet(255,255,255,0);

ESP8266WebServer server(80);
 
void handleRoot() {
 String message="<h1>Minimalprogramm ESP8266</h1>";
 message += "Hallo ... !!!! Dieses ist ein netter Gru&szlig vom ESP8266 Server";
 server.send(200, "text/html", message);
}

void setup(){
  WiFi.begin(ssid, pass);
  WiFi.config(ip, gateway, subnet); 
  server.on("/",handleRoot);
  server.begin();
} 
  
void loop(){
  server.handleClient(); 
}

Nachdem ihr den Sketch hochgeladen habt, geht ihr in euren Lieblingsbrowser und ruft die IP Adresse, in diesem Fall „192.168.178.xxx“, auf. Mit Firefox und Chrome hatte ich keine Probleme, Edge zickte manchmal ein bisschen herum. Bei Problemen also vielleicht mal den Browser wechseln und nicht gleich am Code zweifeln. 

Schalten per WLAN

In diesem Beispiel wird eine LED an GPIO0 per WLAN über den Browser geschaltet. Der Sketch ähnelt dem obigen. Hier sind aber zwei Unterseiten hinzugekommen, die per Links („<a href=……>“) aufgerufen werden, was die Ausführung der entsprechenden Funktionen (ledan(), ledaus() ) auslöst. 

Wenn ihr die auskommentierten Zeilen aktiviert, könnt ihr den Verbindungsaufbau am seriellen Monitor verfolgen. Bei mir hat das allerdings zu Schwierigkeiten beim Seitenaufruf geführt. Ich würde das also nur zu Testzwecken tun. 

#include "ESP8266WiFi.h"
#include "ESP8266WebServer.h"
#define LEDPIN 0

const char* ssid = "Eure SSID";
const char* pass = "Euer WLAN Passwort";
IPAddress ip(192,168,178,xxx); // Individuell anzupassen
IPAddress gateway(192,168,178,1);
IPAddress subnet(255,255,255,0);

ESP8266WebServer server(80);
 
String led1= "<a href=\"/led_an\">LED An</a>";
String led0= "<a href=\"/led_aus\">LED Aus</a>";

void handleRoot() {
  String message="<h1>Testprogramm - Minimalprogramm ESP8266</h1>";
  message += "Hallo ..., das ist ein Gru&szlig vom ESP8266 Server</BR></BR>";
  message += led1;
  server.send(200, "text/html", message);
}

void ledan(){
  digitalWrite(LEDPIN, HIGH);
  server.send(200, "text/html", led0);
}

void ledaus(){
  digitalWrite(LEDPIN, LOW);
  server.send(200, "text/html", led1);
}

void setup(){
  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN, LOW);
//  Serial.begin(9600); 
//  Serial.println("Testprogramm - Minimalprogramm ESP8266");
//  Serial.print("Verbinde mich mit Netz: ");
//  Serial.println(ssid);
  WiFi.begin(ssid, pass);
  WiFi.config(ip, gateway, subnet); 
  
//  while(WiFi.status() != WL_CONNECTED){
//  delay(500); Serial.print(".");
//  }
//  Serial.println("");
//  Serial.println("WiFi Verbindung aufgebaut");
//  Serial.print("Eigene IP des ESP-Modul: ");
//  Serial.println(WiFi.localIP());

  server.on("/",handleRoot);
  server.on("/led_an", ledan);
  server.on("/led_aus", ledaus);
  server.begin();
//  Serial.println("HTTP Server wurde gestartet!");
} 
  
void loop(){
  server.handleClient(); 
}

 

Zwei LEDs schalten

Auch die Schaltung zweier LEDs lässt sich mit dieser Methodik bewerkstelligen:

#include "ESP8266WiFi.h"
#include "ESP8266WebServer.h"
int led[2] = {0,2};
bool led_status[2] = {false};
String message = "";
String title = "<h1>Testprogramm - Minimalprogramm ESP8266</h1>"
               "Hallo Wolle, das ist ein Gru&szlig vom ESP8266 Server</BR></BR>";

const char* ssid = "Eure SSID";
const char* pass = "Euer WLAN Passwort";
IPAddress ip(192,168,178,xxx);
IPAddress gateway(192,168,178,1);
IPAddress subnet(255,255,255,0);

ESP8266WebServer server(80);
 
String led0_1= "<a href=\"/led0_an\">LED0 An</a>";
String led0_0= "<a href=\"/led0_aus\">LED0 Aus</a>";
String led1_1= "</BR><a href=\"/led1_an\">LED1 An</a>";
String led1_0= "</BR><a href=\"/led1_aus\">LED1 Aus</a>";


void setup(){
  pinMode(led[0], OUTPUT);
  digitalWrite(led[0], LOW);
  pinMode(led[1], OUTPUT);
  digitalWrite(led[1], LOW);
  WiFi.begin(ssid, pass);
  WiFi.config(ip, gateway, subnet); 
  server.on("/",handleRoot);
  server.on("/led0_an", led0an);
  server.on("/led0_aus", led0aus);
  server.on("/led1_an", led1an);
  server.on("/led1_aus", led1aus);
  server.begin();
}
  
void loop(){
  server.handleClient(); 
}

void handleRoot() {
  message = "";
  message += title; 
  message += led0_1;
  message += led1_1;
  server.send(200, "text/html", message);
}

void led0an(){
  led_status[0] = true;
  switchLED(0,1);
}

void led0aus(){
  led_status[0] = false;
  switchLED(0,0);
}

void led1an(){
  led_status[1] = true;
  switchLED(1,1);
}

void led1aus(){
  led_status[1] = false;
  switchLED(1,0);
}


void switchLED(int num, bool state){
  message = "";
  message += title; 
  digitalWrite(led[num], state);
  (led_status[0]==true)?(message += led0_0):(message += led0_1);
  (led_status[1]==true)?(message += led1_0):(message += led1_1);
  server.send(200, "text/html", message);
}

 

Messwerte darstellen und automatisch aktualisieren

Mit zwei GPIOs hat man natürlich nur begrenzte Möglichkeiten. Das ist wahrscheinlich der Grund warum fast jeder, der eine Einführung über das ESP8266 ESP-01 Modul verfasst, die Temperaturmessung über einen DS18B20 Sensor als Anwendungsbeispiel nimmt. Denn dieser funktioniert mit der One Wire Technik. Wo I2C und SPI zwei bzw. drei Leitungen brauchen, kommt One Wire – wie der Name schon sagt – mit einer einzigen Kommunikationsleitung aus.

Da das hier ein Beitrag über das ESP-01 Modul und nicht über den DS18B20 Sensor ist, werde ich nicht näher auf die Details eingehen und verweise auf die vielen Beiträge dazu, die im Netz verfügbar sind. Aber zumindest soviel: der DS18B20 ist sowohl als „Dreibein“ verfügbar, wie auch als wasserdichte Version. Ich verwende letztere: 

Geliefert wird das Teil mit den blanken Anschlusskabeln. Ich habe mit einem Stück Lochrasterplatine einen Breadboardadapter gebastelt.  Schwarz (GND) kommt an GND, Rot (VCC) an 3.3 Volt (5 Volt geht auch) und Gelb (DATA) an GPIO0 oder GPIO2, je nach Programmierung. Zu beachten ist noch, dass die Datenleitung einen Pullup Widerstand von 4.7 kOhm benötigt. 

Der Sketch dazu

#include <OneWire.h> 
#include "ESP8266WiFi.h"
#include "ESP8266WebServer.h"

int DS18B20_Pin = 2; 
OneWire ds(DS18B20_Pin);

const char* ssid = "Eure SSID";
const char* pass = "Euer WLAN Passwort";
IPAddress ip(192,168,178,xxx); //Anzupassen
IPAddress gateway(192,168,178,1);
IPAddress subnet(255,255,255,0);
ESP8266WebServer server(80);
 
void setup() {
  WiFi.begin(ssid, pass);
  WiFi.config(ip, gateway, subnet); 
  
  server.on("/",handleRoot);
  server.begin();
}
 
void loop() {
   server.handleClient(); 
}

void handleRoot() {
  String message= "<head><meta http-equiv=\"refresh\" content=\"10\"></head>"
                  "<h1>Temperaturprogramm ESP8266</h1><BR><BR>"
                  "Die Temperatur betr&aumlgt: ";
  static String tString = "";
  static unsigned long lastMeasure = 0; 
  
  if((millis()-lastMeasure) > 5000){
    float temperature = getTemp();
    tString = String(temperature);
    lastMeasure = millis();
  }
  
  message += tString;
  server.send(200, "text/html", message);
}
 
float getTemp(){
  byte data[12];
  byte addr[8];
  if ( !ds.search(addr)) {
      //no more sensors on chain, reset search
      ds.reset_search();
      return -1000;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44,1); // start conversion
 
  ds.reset();
  ds.select(addr);    
  ds.write(0xBE); // read Scratchpad
 
    for (int i = 0; i < 9; i++) { // we need 9 bytes
    data[i] = ds.read();
  }
  
  ds.reset_search();
  
  byte MSB = data[1];
  byte LSB = data[0];
 
  float tempRead = ((MSB << 8) | LSB); //using two's compliment
  float TemperatureSum = tempRead / 16;
  
  return TemperatureSum;
}

 

Auf den DS18B20 Teil gehe ich nicht näher ein. Nehmt an dieser Stelle einfach hin, dass die getTemp() Funktion die Temperatur als Float liefert. Wenn ihr den Code mit anderen Sketchen für den DS18B20 vergleicht, seht ihr, dass dieser hier vielleicht etwas komplizierter erscheint. Man kann ihn theoretisch vereinfachen, indem man noch die „DallasTemperature“ Bibliothek einbindet, allerdings gab es bei mir dann Probleme mit dem Seitenaufruf – warum auch immer. 

Der Rest sollte relativ klar ein. Alle fünf Sekunden wird die Temperatur gemessen. Um die Website regelmäßig zu aktualisieren wurde die HTML Anweisung <head><meta http-equiv=\"refresh\" content=\"10\"></head> eingefügt. Dabei bedeutet die „10“, dass alle 10 Sekunden ein Refresh durchgeführt wird. 

Und noch ein Hinweis: Anführungszeichen brauchen einen vorangestellten Backslash, damit sie nicht als Arduino Steuerzeichen interpretiert werden.  

Die Firmware wieder installieren

Wie weiter oben erwähnt, führt das Hochladen der Arduino Sketche zum Überschreiben der Original Firmware, so dass eine Steuerung per AT-Befehlen nicht mehr möglich ist. Man kann die AT-Software aber wieder herstellen bzw. auch eine neuere Version aufspielen. Das ist ein kleines bisschen aufwendig, da man u.a. noch ein kleines Tool installieren muss. Eine gute Beschreibung gibt es hier. Wenn ihr euch (genau!) daran haltet, dann funktioniert es. 

Steuerung per AT-Kommandos

Das wird jetzt keine detaillierte Einführung in die AT-Kommandos. Ich möchte nur anhand von zwei Beispielen einen Eindruck vermitteln, wie es sich AT-Kommandos arbeitet. Eine Liste mit AT-Kommandos gibt es hier.

Hinweis: Nicht alle AT-Kommandos funktionieren mit jeder Firmware Version. 

Das Setup

Die Schaltung für die Übermittlung der AT-Befehle an das ESP8266 ESP-01 Modul unterscheidet sich grundsätzlich von der Schaltung zum Hochladen von Sketchen und Firmware. RX kommt an TX (über SoftwareSerial), TX an RX, wobei wir wieder vor dem RX des ESP-01 einen Spannungsteiler einsetzen. GPIO0 wird nicht mit GND verbunden, da man nicht in den Programmiermodus geht. Natürlich ist auch die Übermittlung der AT-Kommandos eine Art Programmierung, allerdings wird hier kein ganzes Programm übertragen. Außerdem bleibt der Resetpin unverbunden. 

Schaltung zur Übermittlung von AT-Kommandos an das ESP8266 ESP-01 Modul

Um die Kommunikation zu ermöglichen wird ein SoftwareSerial eingerichtet. Beim Hochladen muss man jetzt den Arduino als Board wählen. 

#include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11);

void setup() {
  Serial.begin(9600);
  Serial.println("Los geht's");
  mySerial.begin(115200);
}

void loop() { // run over and over
  if (mySerial.available()) {
    Serial.write(mySerial.read());
  }
  if (Serial.available()) {
    mySerial.write(Serial.read());
  }
}

 

Einen Server mit AT-Kommandos einrichten

Nachdem der SoftwareSerial Sketch hochgeladen wurde, öffnet man den seriellen Monitor, stellt dort als Baudrate 9600 ein und wählt die Option „Sowohl NL als auch CR“. Das Senden von „AT“ sollte das Modul mit einem „OK“ beantworten. Tut es das nicht, müsst ihr nochmal alle Einstellungen überprüfen und ggf. das Modul nochmal mit der Firmware flashen (siehe weiter oben). 

Funktioniert alles, gibt euch ein „AT+GMR“  die Version der Firmware. Um eine Nachricht in euren Browser zu zaubern, gebt Ihr folgende AT-Kommandos ein:

AT+CWMODE=1  –> Station WiFi Mode

AT+CWJAP=“eure SSID“,“WiFi-Zugangspasswort“  –> mit WiFi Verbinden; Eingabe einschließlich der Anführungszeichen

AT+CIFSR –> hier seht ihr eure IPAdresse

AT+CIPMUX=1 –> Connection Modus (Multiple)

AT+CIPSERVER=1,80 –> 1: create Server, 80: Port

An dieser Stelle könnt Ihr schon mal euren Browser starten und die IP-Adresse eingeben. Wie ihr dann seht, seht ihr erstmal noch nichts.

AT+CIPSEND=0,5  –> Kanal und Anzahl Zeichen

Es taucht ein “>“ auf. Ihr gebt „Hallo“ ohne Anführungszeichen ein, dann Enter

AT+CIPCLOSE=0  –> Erst jetzt taucht ein freundliches „Hallo“ im Browser auf.

GPIOs mit AT-Kommandos schalten

Vorab: Das Schalten der GPIOs hat bei meinen ESP8266 ESP-01 Modulen erst funktioniert, nachdem ich die Firmware gemäß obiger Anleitung aktualisiert habe. 

Für das Schalten von GPIO2 gebt ihr ein:

AT+SYSIOSETCFG=2,0,0 –> 2: Pin, 0: Mode, 0: kein Pullup

AT+SYSGPIODIR=2,1 –> 2: Pin, 1: Output

AT+SYSGPIOWRITE=2,1 –> 2: Pin, 1: An

AT+SYSGPIOWRITE=2,0 –> 2: Pin, 0: Aus 

Mit LUA programmieren

Neben der Programmierung mit Arduino und AT-Kommandos gibt es noch eine dritte Variante und zwar die Programmierung mit der recht einfachen Programmiersprache LUA. Dazu muss man sein Modul zunächst mit der nodeMCU Firmware flashen. Die Prozedur ist hier sehr gut beschrieben. Ich gehe da nicht näher drauf ein. 

Tiefer einsteigen

Wer noch tiefer einsteigen möchte, kann sich an dem Getting Started Guide des Herstellers versuchen. Eine sehr gute Seite, die die Grundlagen gut erklärt ist diese hier. Außerdem empfehle ich in den vielen Beispielsketchen, die ihr nach dem Installieren der ESP8266 Boardfamilie in der Arduino IDE findet, zu stöbern. 

Zu einem späteren Zeitpunkt werde ich noch etwas zum großen Bruder des ESP-01, dem ESP-12 schreiben. Außerdem habe ich noch vor etwas über Möglichkeiten zur Porterweiterung des ESP-01 zu schreiben. Ich hoffe ihr schaut wieder rein!

45 thoughts on “ESP8266 ESP-01 Modul

  1. Hallo Herr Ewald,

    ich will mich hier auch mal für die Arbeit die sie sich gemacht haben bedanken. Man muss kein Fachmann sein, um einen Sachverhalt verständlich zu vermitteln. Sie machen das ganz gut und dafür danke.
    Persönlich bin ich noch immer ein Newcomer, und bediene mich auf dieser Seite ganz gerne.
    Es ist gut beschrieben, die Beispiele sind nachvollziehbar.

  2. zum Sketch
    Eine_LED_per_WLAN_schalten.ino

    wie kann man den Sketch ergänzen, um die LED zum Blinken zu bringen (also über WLAN schalten AN, AUS oder BLINKEN) ?

    1. Hallo, aufgrund der Menge an Anfragen, die ich bekomme, kann ich keine individuellen Sketche erstellen. Du musst du selbst ein bisschen tüfteln. Du brauchst einen weiteren Link für die Blinkfunktion und einen weiteren Handler (server.on). Schau dir vielleicht mal den Unterschied des Sketches für eine LED zu zwei LEDs an. Das gibt einen Hinweis darauf wie man das erweitert. VG, Wolfgang

  3. Hallo Wolfgang
    Finde deine Seite sehr interessant. Sie hat mich auf eine Idee gebracht , das man doch die vielen mit Batterien betrieben Weinachtsbeleuchtung Ein und Ausschalten könnte. Mein Frau da bestimmt 12 davon. Wie ist eigendlich der Strom Verbrauchen bei dem esp8266. Habe mal eine steuerung über Bluetooth auf gebaut das war sehr Strom intensiv.

    1. Der ESP8266 schluckt ganz gut Strom. Folgendes habe ich gefunden:
      Aktiv 69mA
      LIGHT_SLEEP 42mA
      MODEM_SLEEP 44mA
      Deep-Sleep 10mA
      Shutdown 300µA
      Shutdown ohne LED 20µA
      Beim Senden geht der Verbrauch auf über 200 mA. Es lohnt sich schon, das Teil zwischenzeitlich in den Schlaf zu schicken, wenn die Anwendung es zulässt.

  4. Hallo Wolfgang,

    leider verzweifle ich bereits an Deinem ersten Sketch ‚Minimum_Server‘.
    Wenn ich das richtig verstanden habe, so ist ssid mein Netzwerkname und pass mein Passwort zum Netzwerk.
    IPAddress ist die Adresse mit der ich auf den ESP zugreife.
    Oder liege ich da falsch?
    Zumindest passiert nichts. Ich kann nicht auf 192.168.2.102 zugreifen.

    const char* ssid = „Polizeiteststation“;
    const char* pass = „xxxxx“;
    IPAddress ip(192,168,2,102); // 192.168.178.xxx = freie IP Adresse, ggf. müsst ihr auch die anderen Zahlen anpassen; schaut am besten in euren Router
    IPAddress gateway(192,168,2,1);
    IPAddress subnet(255,255,255,0);

    Danke im Voraus

    1. Eigentlich alles soweit richtig, sofern der Router die Adresse 192.168.2.1 hat. Was passiert, wenn du diese Adresse in den Browser eingibst? Und wenn du im Router bist, ich weiß ja nicht, welchen du hast, dann solltest du dort sehen können, ob der ESP sich erfolgreich mit dem WiFi Netz verbunden hat. Und ist die 102 noch frei? Oder vielleicht anderweitig vergeben?

      1. Hallo Wolfgang,

        danke für die Antwort. Ich habe meinen Fehler gefunden. Tja, der Schreibfehlerteufel.
        Da hat bisher keiner gemerkt, dass die ssid einen Schreibfehler hat. Da fehlt nämlich das zweite ‚t‘.
        Ein kleiner Buchstabe der einen großen Effekt hat.

        Ansonsten Danke für Deine Ausführungen und Beispiele. Das hat mir sehr beim Einstieg geholfen.

        Gruß
        Uwe

  5. Hallo Wolfgang,

    eine tolle Website, vielen Dank!

    Eine Frage, bitte: Bei der Schaltung für die Übermittlung der AT-Befehle werden die 5V Pegel vom Arduino direkt auf RX/TX des EXP8266-Moduls gelegt, welche max. 3.6V vertragen. Mache ich einen gedanklichen Fehler?

    Besten Dank und schöne Grüße
    Simon

    1. Hallo Simon, stimmt. Weiter oben habe ich überall die Spannungsteiler eingezeichnet, hier habe ich sie vergessen. Muss ich demnächst mal ändern. VG, Wolfgang

      1. Hallo Wolfgang,
        Vielen Dank für die Änderung.
        Habe mal ein wenig mit den Programmen herumgespielt, um meine ersten ESP8266 Gehversuche zu machen. Dank der guten Beschreibung ging alles glatt.
        Ein paar Beobachtungen habe ich dabei gemacht: Beim neueren ESP01S-Modul braucht man keine LED an GPIO2 anzuschließen; die interne blaue LED wird durch das Programm angesteuert.
        Allerdings liegt diese an VDD und ist damit Active Low. Daher war ich zunächst beim „Schalten per WLAN“-Sketch wegen des Ergebnis etwas verwirrt.
        Wenn man also #define LEDPIN 2 sagt, muss man bei ledan LOW und bei ledaus HIGH sagen und beim Setup entsprechend LEDPIN, HIGH.
        Das Flashen mit neuer Firmware war anfangs kein Erfolg. Mit dem ESP8266 Download Tool Version 3.8.5 erhalte ich nur die obskure Fehlermeldung: UnicodeDecodeError: ‚gb2312‘ codec can’t decode bytes in position 35-36: illegal multibyte sequence.
        Der NodeMCU Flasher tat es dann (https://github.com/nodemcu/nodemcu-flasher).
        Viele Grüße
        Simon

  6. Hallo Wolfgang,
    seit einigen Wochen beschäftige ich mit einer Lösung, um mit dem Anroid Autoradio (ACHTUNG) via WLAN ohne Internet einen Ausgang auf meinem Arduino zu steuern.
    Ich habe ein NodeMCU mit ESP8266 Chip.
    Warum WLAN ohne Internet und nicht Bluetooth?
    Also ich habe einen Audi TT zum E-Auto umgebaut und möchte einige Funktionen und Anzeigen über mein Autoradio (relativ offenes Android Radio namens RADICAL RD211) steuern und ansehen.
    Leider geht Bluetooth in dem Radio nur bedingt, sonst wäre ich schon am Ziel.
    Das RD211 verbindet sich mit Gott und der Welt (Android Phone, iPhone etc. alle kein Problem)
    aber nicht mit meinem BT Chips, die du ja auch schon beschrieben hast. Es sieht die noch nicht mal. Ich vermute, dass es eine Bibliothek im Android Betriebssystem gibt, die gewisse Bauteile nicht kennt.
    Ich hab auch einen BT Sender im Batteriemanagementsystem, der Daten von der Antriebsbatterie sendet, Iphone etc. erkennen das alles super aber mein RD211 leider nicht.
    Ich habe jetzt eine Lösung über BLYNK, die auch funktioniert. Aber irgendwie will ich meine E-Heizung auch ohne Internet an und ausschalten können.
    Kannst du mir einen kleinen Schubs geben, um über eine einigermaßen einfach zu erstellende Android APP in meinem RD211 ein Arduino Board zu steuern.
    Wäre super, wenn du da eine grobe Idee hättest.
    Vielen Dank auch für deine tolle Seite, da können andere noch was lernen über Didaktik und so…

    Lieben Gruss Gerd Gross

    1. Hallo Gerd, das Problem ist, dass es verschiedene Bluetooth Profile gibt:

      https://de.wikipedia.org/wiki/Bluetooth-Profile

      … und die wiederum bauen auf dem allgemeinen oder speziellen BT Protokollen auf:

      https://www.bluetooth.com/de/specifications/protocol-specifications/

      Weit verbreitet ist z.B. das HID Profil, mit dem Computermäuse und Tastaturen über BT mit dem PC kommunizieren. Auch da kann man nicht so ohne weiteres einfach eine Seite durch ein BT Modul ersetzen sondern muss erst die Firmware modifizieren.

      Hier bekommst du mal einen Eindruck:

      https://www.instructables.com/Upgrade-Your-3-Bluetooth-Module-to-Have-HID-Firmwa/

      Mir scheint also, dass man da recht tief in das vom RD211 verwendete Protokoll einsteigen muss. Aber mehr als die das Problem darzustellen, kann ich leider nicht tun. Vielleicht kann dir jemand in Foren wir microcontroller.net helfen.

      VG, Wolfgang

    2. Hallo Wolfgang,
      vielen Dank für deine zeitnahe Antwort.
      Genau aus den genannten Gründen hab ich ja die Bluetoothlösung begraben.
      Ich hatte halt gehofft, dass es eine WLAN Lösung ohne Internetzugang
      gibt und du mir eine Richtung geben kannst. Also nochmals Danke und alle Gute.
      verschneite Grüsse aus dem Altmühltal
      Gerd

      1. Hallo Gerd,

        ich war zu sehr auf das BT fixiert, ich hätte aufmerksamer lesen sollen. Also die Kommunikation soll so laufen: Android Phone –> ESP8266 –> RD211 –> Autofunktionen? Und Android –> ESP8266 soll ohne den Umweg über Router / Internet gehen? So etwas in dieser Art:

        https://forum.arduino.cc/index.php?topic=290301.0

        Geht das in die richtige Richtung?

        VG., Wolfgang

        1. Hallo Wolfgang,
          zunächst einmal Danke, dass du dir die Sache nochmals angeschaut hast.
          Habe ich ehrlich nicht erwartet.
          Mein Autoradio soll eine App bekommen, von der aus ich via WLAN OHNE den Umweg übers Internet direkt das Arduino steuern oder lesen kann.
          Ich habe mit der APP „BLYNK“ eine funktionierende Lösung, die aber eine Internet Verbindung zwingend braucht. Mit der BLYNK App im Android Radio
          kann ich einen Softkey betätigen z. b „Heizung EIN“, dann wird über dem im Auto eingesetzten USB
          Router von Huawai der Befehl an den BLYNK Server irgendwo auf der Welt gesendet, der leitet die Daten dann zurück an meinen USB Router und der sendet den Befehl dann an das Arduino bzw. bei mir das Note MCU. Umgekehrt kann ich so auch den Ladezustand der HochVolt Batterie aus dem Arduino lesen.
          Also eigentlich genau wie du und andere das mit BT beschrieben haben nur mit einem wirklichen wireless LOCAL area network. Betonung auf liegt auf LOCAL und eben nicht global.
          Ich schau mir gerne mal deinen link an.
          Übrigens die BLYNK APP ist wirklich toll, wenn du sie noch nicht kennen solltest. Nur was ist, wenn ich keine Internetverbindung habe, dann muss ich frieren…..(armer Gerd)
          lieben Gruss Gerd

    1. Hallo Frank,

      das Board ist eine sehr gute Idee, denn die Stöpselei beim ESP8266-01 ist schon etwas nervig. Ich hatte mir sogar schon eine Platine bestellt. Sie liegt jetzt vorwurfsvoll in meiner Kiste mit den Dingen um die ich mich noch kümmern will…

      VG, Wolfgang

  7. Hallo Wolle,
    ich bin seit einiger Zeit umgestiegen.
    benutze VSC mit PlatformIO
    dort gibt es für jedes Projekt eine platformio.ini
    in diese ini-Datei kann man Befehlszeilen Makros angeben.
    hier ein paar Beispiele:
    build_flags = -D WLANPASSWD='“MEINPASSWORT“‚
    -DADVANCEDWEBSERVER
    -D FBSSID='“MeineFB“‚
    #-DMYDNS=’const char* myDns= ‚
    -DMYDNS=“MODUL_EG“
    #I2C Addresse
    -D MCPOUTPUT1=0x20
    #I2C Addresse Maximal 4 MCPBausteine immer 16 Input oder 16 Output
    -D MCPINPUT1=0x21
    #Harware Pins
    -D GPIO-WIRE=’0,2‘
    # 2MCP23017 Bausteine
    -D MCP23017=2
    # Für Zeitabfrage von einem Zeitserver
    -D NTPCLIENT='“fritz.box“‚
    Diese Befehlszeilen Makros sind wie
    #define WLANPASSWD MEINPASSWORT
    in einer .h Datei
    somit kannst du Quellcode einfach weitzergeben ohne gefahr zu laufen deine Passwörter preiszugeben.

  8. Fehler im Sketch –Schalten per WLAN–

    Die LED sitzt beim ESP8266-01S an Pin 2 (hat mich einige Brennversuche gekostet 😉 )
    Auch wird die LED mit LOW AN-geschaltet und umgekehrt.

    Da Das schon früher beim Arduino teilweise für Verwirrung sorgte, erstelle ich dafür eigene Variablen.
    Weiter habe ich die SSID und das W-Lan-Passwort in einen separaten Tab ausgelagert (pw.h) – kommt schon häufig vor, daß in Sketchen Hilfesuchender Passworte/Zugangsdaten enthalten sind – Das passiert mit externem Tab nicht mehr ganz so schnell.
    Dann habe ich noch die IP in externe Bytes gesetzt – meine IPs lauten 192.168.0.x – weitere private IPs gibt’s wohl in 10.10.x.y – so muß man nur eine Eingabe anpassen und nicht in zig Zeilen den gleichen Inhalt korrigieren.

    Mit bestem Dank und natürlich zur freien Verfügung
    [code]
    #include „ESP8266WiFi.h“
    #include „ESP8266WebServer.h“

    const byte ESP8266_01S_LED=2;
    const bool _ON=LOW; //Pegel für LED AN
    const bool _OFF=!_ON;

    const byte LEDPIN = ESP8266_01S_LED; //Pins 0 und 2 sind rausgeführt

    #include „pw.h“
    const byte IP1 = 192;
    const byte IP2 = 168;
    const byte IP3 = 0;
    const byte IP4 = 24; //2…254, freie IP im eigenen LAN

    IPAddress ip(IP1, IP2, IP3, IP4); // 192.168.0.xxx = freie IP Adresse, ggf. müsst ihr auch die anderen Zahlen anpassen; schaut am besten in euren Router
    IPAddress gateway(IP1, IP2, IP3, 1);
    IPAddress subnet(255, 255, 255, 0);

    ESP8266WebServer server(80);

    String led1 = „LED An„;
    String led0 = „LED Aus„;

    void handleRoot() {
    String message = „Testprogramm – Minimalprogramm ESP8266“;
    message += „Hallo …, das ist ein Gru&szlig vom ESP8266 Server“;
    message += led1;
    server.send(200, „text/html“, message);
    }

    void ledan() {
    digitalWrite(LEDPIN, _ON);
    server.send(200, „text/html“, led0);
    }

    void ledaus() {
    digitalWrite(LEDPIN, _OFF);
    server.send(200, „text/html“, led1);
    }

    void setup() {
    pinMode(LEDPIN, OUTPUT);
    for (byte b = 0; b < 10; b++) {
    digitalWrite(LEDPIN, _ON);
    delay(100);
    digitalWrite(LEDPIN, _OFF);
    delay(100);
    }
    // Serial.begin(9600);
    // Serial.println("Testprogramm – Minimalprogramm ESP8266");
    // Serial.print("Verbinde mich mit Netz: ");
    // Serial.println(ssid);
    WiFi.begin(ssid, pass);
    WiFi.config(ip, gateway, subnet);

    // while(WiFi.status() != WL_CONNECTED){
    // delay(500); Serial.print(".");
    // }
    // Serial.println("");
    // Serial.println("WiFi Verbindung aufgebaut");
    // Serial.print("Eigene IP des ESP-Modul: ");
    // Serial.println(WiFi.localIP());

    server.on("/", handleRoot);
    server.on("/led_an", ledan);
    server.on("/led_aus", ledaus);
    server.begin();
    // Serial.println("HTTP Server wurde gestartet!");
    }

    void loop() {
    server.handleClient();
    }
    [/code]

    1. Hallo posti, mein Sketch funktioniert einwandfrei. Ich habe es gerade ausprobiert. Ich schrieb in meiner Anleitung, dass eine LED geschaltet wird und nicht die Board LED oder was du da geschaltet hast. Und eine externe LED kannst du an Pin0 hängen oder Pin2 – wie du willst. Ich habe sie halt an 0 gehängt. Ob sie mit „An“ an oder ausgeht, hängt dann davon ab, ob du den ESP01 als Stromquelle nutzt oder als Stromsenke. Ich habe Ersteres getan und dann geht sie mit „AN“ auch an. Danke für den Hinweis mit der pw.h – das passiert wirklich schnell, dass man mal eben seine Zugangsdaten weiterleitet.

      1. Hi

        Danke für die super schnelle Antwort – irgendwie gab’s aber dazu keine Mail bei mir.
        IOch nahm irrtümlich an, daß Du die auf dem ESP-01(S) aufgelötete LED schaltest – Da tat Sich nämlich nicht viel – Die sitzt ja, wie schon gesagt wurde, beim ESP-01S an Pin 2.
        Beim ESP-01 (ohne S) soll Diese an Pin 1 sitzen (zwar immer noch nicht 0, aber immerhin).

        Sonst hatte ich ja auch nur noch die häufiger vorkommenden Nummern der IP in Variablen gepackt – widerspricht Sich zwar irgendwie – schreibfaulheit und dann den ganzen kram für ‚Schreibfaul‘ umstricken, aber so werden Änderungen an EINER Stelle getätigt und sind im ganzen Sketch geändert.

        Mittlerweile versuche ich mich in einem Mesh-Verbund … mit eher magerem Erfolg.
        Zwei ESP-01S (PC und am daneben per 3.3V versorgt) wie einen im anderen Stock auf so einem USB-Programmier-Adapter – finden Sich nur sporadisch – hatte eigentlich vor, mit den WLan-Käfern meine Temperatur-Sensoren aufzurüsten 🙂
        (bisher kabelgebunden über CAN an Arduino Nano)

        Nun gut – werde hier wohl noch öfter aufschlagen, gefällt mir bisher ganz gut hier.

  9. Hallo Wolle
    vielen Dank für deine rasche Antwort. Ich habe ein „unbeschriebenes Blatt“ (ESP01) genommen und es funktionierte mit den AT umgehend.
    Dann muss jedes Mal die Firmware erneuern, wenn ich einen Sketch hochgeladen habe und anschliessend einen AT-Befehl anwenden möchte? Könnte man das auch mit „Werkzeuge>Bootloader“ machen? Oder hat die Firmware und der Bootloader nichts miteinander zu tun?
    Danke für deine Hilfe.
    Andreas
    PS: ich staune immer über deine unglaubliche Schaffenskraft für unser Hobby.. und bin ja so froh darüber!

    1. Ich denke es geht nicht über Werkzeuge -> Bootloader. Ich würde mir einen ESP01 aufheben, auf den du keine Sketche lädst, sondern nur über die AT-Befehle benutzt. Das Firmware flashen funktioniert auch, und wenn man sich das Flashtool besorgt und eingerichtet hat, dann geht es auch schnell, aber erstmal muss man ja da hinkommen.

  10. Hallo Wolle
    ich habe einen USB-Adapter und möchte via diesen direkt auf den ESO01 mit SoftwareSerial zugreifen um die AT-Kommandos auszuprobieren.
    Dann macht ja dein Sketch mit

    „SoftwareSerial mySerial(10, 11);
    void setup() {
    Serial.begin(9600);
    Serial.println(„Los geht’s“);
    mySerial.begin(115200);
    }“

    keinen Sinn.
    Wie müsste ich den Sketch mit SoftwareSerial programmieren, um direkt auf den ESP01 zugreifen zu können?
    Die Pins 10 und 11 und 9600Bd beziehen sich ja auf den UNO – oder mache ich da einen Ueberlegungsfehler?
    Andreas

    1. Hallo Andreas, du brauchst dann SoftwareSerial nicht, da du eine „echte“ serielle Verbindung hast. Einfach den Adapter anschließen, den Port in der Arduino IDE wählen, den seriellen Monitor öffnen, Baudrate einstellen (wahrscheinlich 115200), ggf. noch einstellen, ob ein CR und / oder NL übertragen wird (das ist neben der Baudeinstellung). Dann müsste es gehen. Du musst aber die Firmware auf dem ESP8266 haben. Wenn du erstmal einen Sketch hochgeladen hast, dann ist sie überschrieben. Man kann sie aber wieder draufladen. Die Prozedur steht hier:

      https://www.electronicshub.org/update-flash-esp8266-firmware/

  11. Hallo Wolfgang,

    mit deiner Software funktioniert auch das LOLIN (WEMOS) D1 R2 Board – die „interne“ LED leuchtet invertiert (led1 bedeutet LED Aus bzw. led0 = LED An) und muß mit #define LEDPIN 2 angesprochen werden.

    Vielen Dank für Deine tolle Arbeit! Weiter so!
    Gruß Harald

  12. …und ein Nachtrag, als ich mir das Bild angeschaut habe bin ich selbst drauf gekommen:
    Der Spannungsteiler über 3,3V => 10kOhm => GPIO2 => 3,3KOhm => Transistor be => GND war natürlich falsch aufgestellt.
    Die 10kOhm ausgetauscht gegen 1k und schon funktioniert es.
    Mann mann mann.. Trotzdem lieben dank und viele Grüsse!

  13. Hallo Wolfgang, erstmal vielen Dank für deinen tollgeschriebenen Beitrag.

    Bei mir funktioniert das schalten über GPIO nicht ganz, da, von Anfang an dort ein HIGH-Signal ist, internal_pullup. Ich benutze den Ausgang nur als Ansteuerung für einen Transistor mit noch einem 4,7kOhm Vorwiderstand.
    Hab ich da was übersehen?
    Wie bist du da vorgegangen?
    Viele Grüsse,
    Marcel

    1. Hallo Marcel, ich habe einfach nur das gemacht, was oben beschrieben steht. Ich denke nicht, dass ich irgendwelche Details „unterschlagen“ habe. Funktioniert denn auch der oben abgebildete Blink Sketch nicht? Wichtig ist natürlich, die GPIO-GND Verbindung, die man braucht um in den Programmiermodus zu kommen, zu lösen und evtl. noch einen Reset auszuführen. Wenn es nicht geht müsstest du mir noch mal genauer beschreiben, was du gemacht hast, wie dein Sketch aussieht, usw.

      1. Hallo Wolfgang,
        Das mit dem Blink hab ich noch nicht probiert, wird aber gemacht.
        Das Programmieren funktioniert auch gut. Wenn ich allerdings verbinde wie ich es aufgemalt habe, dann gibt es bei der seriellen Ausgabe kauderwelsch.
        Wenn ich den Transistor wegnehme beim starten und danach wieder einsetze, dann funktioniert es. Vielleicht eine Diode nach dem Emitter einsetzen?
        Ich habe dir mal meine Schaltung und Code hochgeladen, vielleicht fällt dir ja schon was auf?

        Schaltplan
        https://ibb.co/RHX8zfY
        (Die LED Kombi da oben soll später ersetzt werden und ein Relais auf Ground ziehen)

        Code
        https://pastebin.com/2yWJuZfh

        Viele Grüsse!

  14. Danke aus tiefstem Herzen! So gut wie hier habe ich es nirgends beschrieben gesehen. Hat mir unglaublich viel geholfen.

  15. Hallo Wolfgang,
    du schreibst, dass bei der Verbindung zwischen Uno und ESP01 Tx mit Tx und Rx mit Rx zu verbinden ist.
    Ich habe bei serieller Verbindung in meinen Arduino-Basteleien bisher immer Rx mit Tx und umgekehrt verbunden. Warum ist das beim ESP 01S anders oder wo kann ich das nachlesen. So habe ich das nirgendwo gefunden.
    Sonst ist dein Betrag klar und verständlich und somit sehr wertvoll für mich, um in die ESP-Welt einzusteigen.
    Vielen Dank und
    Gruß
    August

    1. Ja, das erscheint merkwürdig. Aber es ist so! Auf dem Arduino ist ein USB zu Seriell Adapter. Mit diesem wird der ATmega328P programmiert. Der RX des Adapters ist mit dem TX des ATMega328P verbunden entsprechend TX(Adapter) mit RX(Atmega). Diese RX/TX und TX/RX Leitungen sind mit TX / RX Ausgängen verbunden (deswegen gibt es manchmal auch Probleme beim Sketch hochladen, wenn etwas an diesen Ausgängen hängt). Die Bezeichnung der TX/RX Ausgänge bezieht sich auf den ATmega328P. Der ist aber im Resetmode (Reset ist an GND), so dass wir den USB zu Seriell Adapter direkt nutzen können. Und da passt dann schlicht die Beschriftung nicht.

  16. Hallo Wolfgang,

    ein kleiner Hinweis. Der Satz „Die „200“ ist die (maximale) Anzahl der Zeichen. “ ist nicht ganz korrekt. Der erste Parameter der Funktion server.send ist der HTTP-Status-Code, den der Server auf einen Anfrage sendet, in dem Fall ist es „200 OK“ (siehe https://de.wikipedia.org/wiki/HTTP-Statuscode).

    Gruß Frank

    1. Hallo Frank,
      das war nicht nur nicht ganz korrekt – es war total verkehrt. Weiß nicht wie ich darauf gekommen bin. Ein Blick in die ESPWebServer.h verrät:
      // send response to the client
      // code – HTTP response code, can be 200 or 404
      // content_type – HTTP content type, like „text/plain“ or „image/png“
      // content – actual content body
      void send(int code, ………

      Ich bin immer dankbar für solche Hinweise! Danke! Ich korrigiere es.

  17. Hallo Leute,
    ich habe einige Projekte mit dem ESP8266 entwickelt, wie hier z.B. eine 433MHz Alarmanlage mit Sirene, Led, Summer, Sirene und mp3 Ansagen. Diese kann per iobroker Benachrichtigungen z.B. über Telegram auf das Handy schicken. Ich würde gern meine Projekte mit der Welt da draußen teilen 🙂 Wenn ihr Interesse an einer Veröffentlichung habt, dann sagt einfach bescheid. Beste Grüße
    A. Maghafi

    http://www.studiomix.de/2020/04/13/433mhz-alarm-4-mit-mp3/
    http://www.studiomix.de

  18. Hallo Wolle, bin aus Österreich, bin 61j und interessiere mich schon seit 2 Jahren mit den ESP8266. Probierte schon Viele Arduino Versionen und viele ESP’s und viele Scatches.
    Noch NIE ist mir was gelungen. Immer war was anderes Schuld! Deine Skatches funktionierten auf ANHIEB! Gratuliere!
    Vielen Dank! Endlich hab ich’s geschafft! Danke

    1. Hallo Gerhard, ich habe deinen Kommentar mit großer Freude gelesen. Danke! Und ich bewundere dein Durchhaltevermögen 🙂 !

  19. Danke für die ausführliche und verständliche Einführung. Nur wenige Seiten im Netz können sich damit vergleichen. Die Hinweise auf Weiterführungen regen zum tieferen Einstieg an.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.