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:

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 die (maximale) Anzahl der Zeichen. 

#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
 
  byte present = 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 EXP8266 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, und 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!

2 thoughts on “ESP8266 ESP-01 Modul

  1. 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.