ESP12E, Einstieg mit dem ESP8266 Modul

In unserem letzten Beitrag „NodeMCU und ESP8266“ habe ich ja schon aufgezeigt wie einfach sich mit dem kleinen NodeMCU-Board tolle Schaltungen mit WLAN-Funktionalität basteln und programmieren lassen. In diesem Beitrag möchte ich zeigen, wie einfach sich die gleichen Programme auch direkt mit dem ESP12E-Modul verwenden lassen und welche Vor- und Nachteile dies hat und wie man sich das Ganze mit einem Eigenbau-Adapter vereinfacht.

Nachteile des ESP12E Moduls gegenüber dem NodeMCU

Dieser Beitrag ist vornehmlich für Leser gedacht, die noch kein ESP-Modul oder zumindest nicht das Modul ESP12E direkt mit der Arduino IDE programmiert haben. Aber auch Bastler, die einen guten ESP12E-Adapter suchen, finden weiter unten eine interessante Bauanleitung.

Wie schon im letzten Beitrag beschrieben, ist auch das NodeMCU-Board im Grunde nichts anderes als ein ESP12E-Modul mit einigen externen Komponenten, die die Handhabung und Programmierung vereinfachen (u.a. Spanungswandler, USB-to-UART-Adapter). Somit kann man natürlich die gleichen Programme (Sketches) auch direkt in das ESP12E einspielen.

Der Nachteil ist allerdings, dass das Modul ESP12E ein sehr kleines Anschluss-Raster (2.0mm) nutzt, es kann somit nicht so einfach auf Breadboards (Steckbrettern) oder handelsüblichen Lochraster-Platinen verwendet werden. Des weiteren besitzt es natürlich auch keine USB-Schnittstelle, man benötigt daher noch einen zusätzlichen USB-to-UART-Adapter. Des weiteren müssen einige Pins auf einen entsprechenden Pegel gelegt werden, damit das Modul programmiert oder das geladene Programm gestartet wird. Die Handhabung ist also deutlich umständlicher als bei dem NodeMCU-Board, daher empfehle ich immer zunächst das NodeMCU Board für die Programmentwicklung und die Erprobung einer Schaltung zu nutzen. Es ist einfach bequemer, später kann man dann immer noch zum ESP12E-Modul wechseln, was durchaus auch Vorteile haben kann.

Vorteile des ESP12E Moduls gegenüber dem NodeMCU

Nicht immer, aber oft macht es Sinn die fertig entwickelte Schaltung bzw. das fertig programmierte Programm direkt mit einem ESP12E Modul umzusetzen. Zum einen ist das Modul doch noch eine ganze Ecke günstiger als das NodeMCU-Board und zum anderen kann man die Baugröße der gesamten Schaltung damit oft noch etwas verkleinern. Was aber oft noch wichtiger ist, auch der Strombedarf der Schaltung lässt sich durch eine geschickte Auswahl des Spannungsreglers und die Reduzierung unnötiger externer Bauteile noch erheblich senken. Insbesondere wenn das Modul durch Akku- oder Batteriespannung versorgt werden soll und vielleicht oft auch im Tiefschlaf betrieben wird, da eignet sich das NodeMCU-Board nicht so wirklich gut für.

ESP-12E WiFi Modul ESP8266 Controller kompatibel...

Zum Shop* Preis inkl. MwSt., evtl. zzgl. Versandkosten

Hrph Nodemcu LUA WiFi Internet ESP8266 Development...

Zum Shop* Preis inkl. MwSt., evtl. zzgl. Versandkosten

Letzte Aktualisierung am 2024-11-21 / * Affiliate Links 

Wie programmiert man das ESP12E Modul?

Wie im letzten Beitrag behandele ich auch in diesem Beitrag immer die Programmierung in C mit Hilfe der Arduino IDE. Wir werden in diesem kleinen Tutorial auch zum Teil die gleichen Beispielprogramme und Librarys nutzen, deshalb empfehle ich unbedingt den Beitrag „NodeMCU und ESP8266“ als erstes zu lesen. Damit habt Ihr bereits die wichtigsten Grundkenntnisse, die für die Programmierung des ESP12E Moduls notwendig sind.

ESP12E Variante mit ESP8266 Chipsatz

Für die Experimente mit dem ESP12E Modul empfehle ich folgende Bauteile zu beschaffen:

• ESP12E-Modul selbst (gibt es bei Ebay* und Amazon*)
• USB-to-UART-Adapter. (z.B. das schon vorgestellte Modul „Mini-USB-Modul UM2102“ von ELV oder ein ähnliche siehe hier bei Amazon*))
• ein kleines Steckbrett mit einigen Drahtbrücken (auch über Amazon* erhältlich)
• einen 3,3V Spannungsregler (meine Empfehlung MCP1700-3302E, gibt es hier* bei Conrad)
• zwei Elkos 1uF
• eine Lochrasterplatine mit Lötpunkten (gibt es bei Conrad*) manchmal auch über Amazon*
• zwei Stiftleisten (Raster 2,54mm), gibt es bei Reichelt oder Conrad*
• optional Adapter-Platine für ESP12E-Modul, gibt es bei Amazon*

Den 3,3V Spannungsregler könnte man theoretisch weglassen, falls man eine andere 3,3V Spannungsquelle besitzt, beispielsweise ein Lithium-Akku für die Spannungsversorgungen nutzen möchte. Da wir in unserem Beispiel aber den USB-Port als Spannungsquelle nutzen möchten, müssen wir Spannung von 5 auf 3,3V reduzieren. Hierfür eignet sich sehr gut der Spannungsregler MCP1700-3302E. Er ist leicht erhältlich (z.B. über Conrad) und liefert bis zu 250 mA, seine Eingangsspannung muss lediglich 0,178V über der Ausgangsspannung liegen. Ein weiterer Vorteil ist, dass er auch in dem bastlerfreundlichen To92 Gehäuse geliefert wird und praktisch so gut wie keinen Strom benötigt. Legt sich unser ESP12E-Modul irgendwann mal schlafen (DeepSleep), so braucht der Spannungsregler selbst nur ca. 0,4µA (also 0,0000004 A), das ist ein vielfaches weniger als beispielsweise der NodeMCU-Spannungsregler benötigt, erst dadurch sind Batterie Anwendungen denkbar.

Den USB-UART-Adapter brauchen wir nur für die Programmierung, er wandelt die USB-Leitung in ein RX / TX Signal um, welches wir dann direkt mit dem Modul verbinden können. Ich verwende für solche Aufgaben immer den „Mini-USB-Modul UM2102“ von ELV, da dieser sowohl für 3,3V als auch 5V Ports verwendet werden kann, eine Umschaltung ist da nicht nötig. Zudem kann man an diesem Adapter sehr leicht eine 4 polige Stift- oder Buchsenleiste anbringen, die dann 5V, GND, RX, TX beinhaltet. Bringt man eine entsprechende Buchsen- oder Stiftleiste auch am ESP12E Modul an, so kann man den Adapter sehr bequem anstecken und das Modul programmieren (flashen). Nach der Programmierung ist dieser Adapter ja nicht mehr erforderlich und kann leicht wieder entfernt werden, was Platz und Strom spart.

Jetzt könnte der ein oder andere ja sagen dieser Adapter hat doch auch einen 3,3V Ausgang, könnten wir da nicht auch den Spannungsregler beim Programmieren sparen? Das stimmt auch, allerdings liefert der Adapter nur wenige mA Ausgangsstrom, das reicht leider nicht aus um das ESP12E Modul zu betreiben, daher ist der Spannungsregler nötig.

Erste ESP12E Experimente auf dem Breadboard (Steckbrett)

Für erste Experimente bietet sich immer ein Steckbrett an. Da leider das ESP12E-Modul vom Raster nicht steckbar ist, gibt es zwei Möglichkeiten. Entweder man baut sich aus einem Stück Lochrasterplatine selbst einen Adapter, oder man kauft einen fertigen Adapter im Online-Handel (z.B. hier bei Amazon*). Diese Adapter kosten nur ein paar Euro und können einem reichlich Zeit ersparen, daher kann ich durchaus empfehlen einen solchen zu nutzen. Der gängige Adapter, der im Handel erhältlich ist, kann auch mit einem Spannungsregler auf der Rückseite bestückt werden. Leider habe ich im Handel nirgends einen genaue Erläuterung der Spannungsregler-Pinbelegung und der vorhandenen Widerstände gefunden (oft leider typisch bei China Produkten), daher habe ich das mal ausgemessen und euch hier in der Skizze dargestellt.

Wie man sieht, muss man den Widerstand R2 auslöten wenn man einen Spannungsregler bestückt, er stellt nämlich nur eine 0 Ohm Brücke nach VCC dar. Der Adapter erleichtert durchaus das Experimentieren, ist allerdings nicht ganz optimal. Zum einen wird hier ganz auf Kondensatoren verzichtet, was manchmal Probleme machen kann. Zum anderen werden die hinteren Pins des ESP12E Moduls gar nicht herausgeführt. Auch ist es schade das immer die Stiftleisten eingelötet werden müssen um den ESP12E zu programmieren.

Verschaltung des handelsüblichen ESP-Adapters

Aus diesem Grunde nehme ich diesen Adapter in er Praxis eher selten. Ich habe daher einen eigenen Adapter unter Eagle entwickelt, welcher wesentlich flexibler ist und mehr Arbeit und Zeit spart. Das Projekt mit Platinenlayout stelle ich euch weiter unten im Beitrag vor (siehe Bild unten). Über unsere Platinenservice-Seite findet Ihr wieder Anbieter, die diese Leiterplatte auch günstig anbieten.

Kann als Breadboard-Adapter oder auch WLAN-Temperatursensor genutzt werden

Alternative ESP12E auf Lochraster

Es geht aber auch ohne einen fertigen Adapter, dazu nimmt man einfach ein Stück Lochrasterplatine und zwei 11 polige Stiftleisten. Das eigentliche ESP12E-Modul kann man dann einfach in der Luft mit normalen Drähten verlöten. Das Ganze sieht nicht toll aus, erfüllt aber seinen Zweck (siehe Foto).

Jetzt können wir das Modul bequem auf einem kleinem Steckbrett aufstecken. Am besten lötet man auch bei dem USB-UART-Adapter eine Stiftleiste hinten ein, dann kann man auch dieses Modul auf das Steckbrett stecken. In meinem Fall habe ich hinten eine Buchsenleiste eingelötet, auch das eignet sich zum Verdrahten.

Damit das Verdrahten erleichtert wird, hier noch mal die genaue Pinbelegung beider Module auf einem Blick. falls ihr einen anderen USB-Adapter* nutzt, achtet darauf das dort die Pinbelegung etwas anders ausfallen kann.

Die Verdrahtung ist relativ einfach, die 5V des USB-Adapters gehen zunächst zum Spannungsregler und von dort an VCC des ESP-Moduls. GND kann natürlich direkt verbunden werden. Bei den eigentlichen Datenleitungen RX und TX muss man darauf achten, dass diese verdreht an das Modul gehen, also der Adapter-Ausgangsport TX geht an RX des ESP-Moduls und RX des Adapters geht an TX des ESP-Moduls. Am besten schaut Ihr euch die ganze Verschaltung in nachfolgender Skizze an:

Beachtet, dass neben der erwähnten Verschaltung auch noch die der Port GPIO15 auf GND gelegt werden muss, ansonsten funktioniert das Modul nicht. Auch der Pin EN (ist gleichzeitig auch auch CH_PD) muss auf High (+3,3V) gelegt werden. Die blaue gestrichelte Verbindung von GPIO0 nach GND ist nur erforderlich, wenn das ESP-Modul programmiert (geflasht) werden soll, danach muss diese Verbindung wieder getrennt werden da sonst das Programm nicht immer korrekt abläuft. Der Hersteller des Spannungsreglers empfiehlt noch ein 1µF Keramikkondensator vor und hinter dem Spannungsregler, das wäre z.B. unser C in der Skizze. Sicherlich kann es aber nicht schaden wenn hier für C auch ein etwas größerer Elko von etwa 1µF bis 100 µF genutzt wird, schließlich kann der Stromverbrauch bei WLAN-Betrieb deutlich über 100 mA liegen. Im Test hatte das Ganze allerdings selbst mit 100nF noch gut funktioniert.

Auf dem Steckbrett sieht unsere Schaltung also wie folgt aus:

Programmierung eines ESP12E Moduls auf dem Steckbrett

Der blaue Draht ist auf dem Steckbrett nur mit GPIO0 verbunden, er muss natürlich zur Programmierung am anderen Ende in GND eingesteckt werden. Der linke gelbe Draht ist hier mit Reset verbunden, er muss kurz mit GND verbunden werden wenn das Modul neu gestartet werden soll. Ein Reset ist immer nötig, wenn der Modus gewechselt wird, also wenn der blaue Draht umgesteckt wird.

Wenn wir diese Schaltung jetzt mit einem USB-Kabel am PC anschließen, dann können wir mit der Arduino IDE das erste Programm in das ESP-Modul hochladen. Achtet darauf, dass die Arduino IDE entsprechend vorbereitet ist (siehe Artikel NodeMCU). An den Zieleinstellungen muss man in der Arduino nichts ändern, es kann also als Zielboard weiterhin „Board NodeMCU 1.0“ eingestellt bleiben. Welcher COM-Port der USB-UART-Adapter belegt, kann man über den Gerätemanager von Windows herausbekommen. In der Regel hat man in der Arduino aber nur ein oder zwei zur Auswahl, so dass man notfalls ruhig einfach einen ausprobieren kann.

Als erstes Testprogramm könnten wir folgendes Beispiel verwenden. Dieses Beispielprogramm lässt die blaue LED auf dem ESP12E Modul im Sekundentakt blinken. Zudem zählt das Programm die Variable i im Sekundentakt hoch und gibt die Zahl über die serielle Schnittstelle aus. Wenn unser Programm richtig läuft, dann muss also nach der Programm Übertragung die blaue LED blinken und eine Zahlenfolge auf dem seriellen Monitor der Arduino IDE erscheinen.

Vergesst nicht nach der Programmierung die blaue Brücke nach GND zu entfernen und ein RESET durchzuführen. Ich habe festgestellt, dass manchmal die Programme auch dann laufen, wenn GPIO0 noch an Masse liegt, allerdings ist das dann nicht sicher gewährleistet.

Ein erstes Testprogramm:

/*
 ESP12E-Test
 Led an dem ESP8266 Modul Typ ESP12E blinken lassen
 und Zahlenfolge über serielle Schnittstelle ausgeben

 Programm erprobt ab Arduino IDE 1.6.13
 Weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/

#include <ESP8266WiFi.h>


#define LED D4 //GPIO2 - Led auf dem Modul selbst

int i;

void setup() {
 pinMode(LED, OUTPUT); // Port aus Ausgang schalten

 Serial.begin(115200);
 delay(10);
 
 Serial.println("");
 Serial.println("ESP12E Modul Test"); 
}


void loop() {
 
 digitalWrite(LED, LOW); //Led port ausschalten
 delay(1000); //1 Sek Pause
 digitalWrite(LED, HIGH); //Led port einschlaten
 delay(1000); 
 
 Serial.println(i); 
 i++;
}

Empfehlenswerte Grundschaltung zum Experimentieren

Eigentlich wissen wir jetzt schon alles Wichtige, wir können das Modul jetzt genauso leicht programmieren wie das NodeMCU-Board. Die Programme können 1:1 übernommen werden, es sind keinerlei Anpassungen nötig. Wenn Ihr allerdings sehr viel mit dem Modul experimentieren wollt, dann schlage ich eine etwas verbesserte Grundschaltung vor. Hier werden einige Brücken mit einen Pullup oder Pulldown-Widerstand beschaltet, das kann manchmal schützen falls Ihr einen Port am Steckbrett falsch verdrahtet. Die Funktion ist aber identisch. Die Brücken für Reset und die Programmierung habe ich hier durch Taster ersetzt, wenn Ihr das Modul programmieren wollt, müsst Ihr die Flash-Taste gedrückt halten und danach kurz die Reset-Taste drücken. Sobald die Arduino IDE das Programm hochlädt, könnt Ihr die Flash-Taste loslassen. Das erspart einem das Umstecken der Drahtbrücken. Diese Taster sind übrigens auch auf dem NodeMCU-Board in gleicher Form vorhanden.

Empfohlene Experimentierschaltung für ein ESP12E Modul

Einen WLAN Temperatursensor für Batteriebetrieb bauen

Schon im letzten Beitrag haben wir ja mit einem NodeMCU Board einen Temperatursensor gebastelt, der per WLAN eine Temperatur an ein NodeMCU mit Display schickt. Dieses Beispiel wollen wir noch mal aufgreifen, weil gerade das so ein Fall für das ESP12E Modul mit dem hier gezeigten Spannungsregler MCP1700-3302E* ist. Damit der Temperatursensor nur wenig Energie verbraucht, sendet dieser nur alle 15 Minuten eine Temperatur an die Anzeigeeinheit. Zwischen dieser Zeit legt sich das Modul schlafen und verbraucht kaum Strom. Da auch unser Spannungsregler kaum Strom verbraucht, also eine feine Sache. Im Endeffekt würde also die Schaltung mit dem Temperatursensor wie folgt aussehen.

Komplette Schaltung für einen WLAN Temperatursensor

Man sieht, die Verschaltung ist recht einfach und es werden kaum Bauteile benötigt. Den Spannungsregler könnte man sogar in einigen Fällen noch weglassen. In meinem Fall habe ich diesen Temperatursensor im Außenbereich in eine Solarlampe eingebaut und über dessen Akku versorgt. Da hier unter Umständen die Ladespannung mal höher sein könnte, empfehle ich den Spannungsregler nicht wegzulassen, sicher ist sicher. Da der Temperatursensor im Intervall arbeitet und die Solarlampe den Akku ja immer auflädt (abends leuchtet diese nur bei Bewegung), ist eigentlich ein günstiger dauerhafter Betrieb dieses WLAN-Temperatursensors sichergestellt.

Auf Lochraster könnte ein solcher Temperatursensor wie auf dem nachfolgenden Bild aussehen.

Auf diesem 3 bis 4 cm großen Stück Lochraster habe ich alles untergebracht was man braucht, inkl. Spannungsregler und Temperatursensor. Zusätzlich habe ein eine 4 polige Stiftleiste vorgesehen die zum Programmieren dient. Hier kann einfach ein entsprechender USB-Adapter angesteckt werden. Die andere Stiftleiste ist für 2 Jumper vorgesehen. Einmal kann man damit das Modul in den Programmiermodus versetzen (GPIO0 nach GND) und zum anderen kann man den Weckmodus für den Tiefschlaf aktivieren (RESET nach GPIO16).

Im nachfolgenden Foto seht Ihr wie einfach das Ganze mit dem Adapter programmiert wird.

Programmierung unseres WLAN-Temperatursensors

Einbau des ESP12E in eine Solarlampe für dauerhaften Betrieb

Meinen Außensensor habe ich so programmiert, dass er sich nur alle 15 Minuten aktiviert und dann die Temperatur an einen Server (eine NodeMCU Server mit Display) übermittelt. Das reicht völlig, da sich Temperaturen ja nicht so schnell ändern und dadurch erheblich an Energie gespart wird. Zwischen diesen Intervallen schläft das Modul immer, die ganze Schaltung braucht dann unter 20µA  (0,00002 A), das sollte selbst im Batteriebetrieb für sehr lange Laufzeiten ausreichen.
Da ich aber den Batteriewechsel und den Bau eines Gehäuses komplett vermeiden wollte, habe ich diesen Sensor einfach in eine ohnehin vorhandene Solarlampe eingebaut. Es gibt inzwischen wirklich gute und günstige Solarlampen die auch richtig hell sind, empfehlen kann ich hier das Modell Litom (siehe hier bei Amazon*). Dieses Modell hat auch einen Bewegungsmelder und vor allem noch genügend Platz um den Sensor einzubauen. Eine Lampe kostet derzeit unter 20 Euro, ich habe mir vor längerem gleich mehrere besorgt und bin sehr zufrieden.

Keine Produkte gefunden.

Im inneren der Solarlampe ist noch genügend Platz für unser Modul

Der Einbau ist kinderleicht, einfach das Gehäuse aufschrauben und die kleine Lochrasterplatine wie im Bild zu sehen mit etwas Heißkleber an den Ecken fest fixieren. Die Drähte zur Spannungsversorgung können einfach direkt an das Batteriefach angelötet werden, am Modul kann man die Programmier-Stiftleiste zur Spannungsversorgung nutzen.

Das Ganze am besten noch mit etwas Isolierband abdecken und dann wieder zusammenschrauben und an der Hauswand irgendwo befestigen.

Am besten platziert man solche Lampen in 2 bis 3 m Höhe (der WLAN-Sensor ist nicht erkennbar)

Dass die Lampe selbst die Temperatur beeinflusst, braucht man kaum befürchten, da diese nur wenige Sekunden leuchtet wenn eine Bewegung erfasst wird. Auch das ESP12E-Modul selbst heizt nichts auf, da es ja nur alle 15 Minuten ganz kurz aktiviert wird. Allerdings kann die Sonne natürlich die Lampe erwärmen. Man kann das Ganze also noch verbessern indem man lediglich den dreipoligen Temperatursensor DS18B20 durch ein Loch irgendwo nach außen führt.
Auf jeden Fall ist das sicher eine unauffällige und recht günstige Lösung mit doppeltem Nutzen.

ESP12E – Cube Server

Als Server der die Temperaturen von mehreren solcher Sensoren empfangen kann, verwende ich ein NodeMCU-Board, so wie ich es im letzten Beitrag schon beschrieben habe.
Ich habe die damalige Steckbrett-Schaltung lediglich auf Lochraster zusammengelötet.

Wie Ihr im Bild seht, habe ich das Display per Flachbandkabel mit der Lochrasterplatine verbunden, damit ich dieses anschließend in ein kleines würfelartiges Holzgehäuse einbauen kann. Übrigens, wenn ihr euch das mühselige anlöten von Flachbandkabel an solche Display etwas vereinfachen wollt, dann könnt ihr einen Stiftleisten-Wannenstecker Adapter  nutzen, ich habe dafür eine Platine layoutet, ihr findet sie auch beim Platinenservice. Die Projektbeschreibung zum Stiftleisten-Adapter findet ihr hier.

Ansonsten enthält die Platine lediglich noch den Temperatursensor, einen kleinen Piezo-Lautsprecher und einen Anschluss für einen Taster. Den Temperatursensor habe ich später allerdings per Kabel angesteckt und etwas nach außen geführt, da sich Display und Modul doch recht stark erwärmen und dadurch die Messung verfälschen. Fertig sieht das Ganze dann wie im nachfolgenden Bild aus.
Da ich das Ganze in ein würfelförmiges Eigenbau-Gehäuse eingebaut habe, habe ich es ESP12E Cube-Server genannt.

Am besten stellt man ihn im Wohnzimmer in Sichtweite auf, so verpasst man keine wichtigen Ereignisse

Man hat also stets Innentemperatur und Außentemperatur gut im Blick. Das Programm habe ich auch ein wenig optimiert, so dass auch schon die Farbe der Anzeige etwas Aufschluss über die Temperatur gibt.

Der vordere Taster kann beliebig in der Programmierung verwendet werden. Ich möchte über diesen ESP12E–Cube Server auch noch Temperaturen von anderen Zimmern und Stellen ausgeben, daher werde ich den Taster später dazu nutzen um verschiedene Anzeigen umzuschalten. Auch andere Dinge, wie beispielsweise „Post im Briefkasten“ wird demnächst über diesen Server angezeigt. Alle Dinge im Haus, die man im direkten Blick haben möchte, kann man gut über so ein zentrales Display anzeigen lassen. Als Spannungsquelle dient ein normales USB-Netzteil für den Server, alternativ kann man natürlich auch mal eine Powerbank* nutzen. In der Rückwand habe ich ein Loch gelassen, so dass der USB-Stecker für die Spannung und Programmierung ohne zu öffnen eingesteckt werden kann (siehe Foto).

Die untere Hülse enthält übrigens den Temperatursensor für die lokale Temperatur, er sollte wie erwähnt wegen der Eigenwärme etwas vom Gehäuse entfernt platziert werden, daher diese Hülse.

Hier die Schaltung unseres Servers mit kleinem Lautsprecher und programmierbarem Taster. Der Piezo Lautsprecher ist nur sehr leise, er kann für Rückmeldungen oder Tasterbestätigungen einen leisen Signalton erzeugen.

Hier übrigen der aktuelle Programmcode meines Servers, falls Ihr ähnliches umsetzen wollt. Der Code funktioniert wunderbar, ist aber recht flott zusammengebastelt und noch nicht optimiert, da ich erst noch andere Sensoren anbinden wollte und oft durch die Optimierungen etwas die Übersicht verloren geht. Falls ihr den Code ausbaut, solltet ihr darauf achten das Display-Aktualisierungen im fertigen Programm nur an einer Stelle aus der Loop-Funktion heraus durchgeführt werden, bei mehreren Sensoren könnte es ansonsten passieren das quasi gleichzeitig auf die Grafik-Lib zugegriffen wird, was natürlich zu Abstürzen führen kann.

Ihr findet den Code auch unten unter den Downloads.

/*
 NodeMCU-Server-TFT-Temperatur

 NodeMCU fungiert als Server und empfängt Temperatur per URL
 Temperaturwerte (z.B. Außentemperatur) wird auf angeschlossenem 
 QVGA-Display ausgegeben,
 
 Parameteruebergabe-Syntax:
 http://192.168.2.75/sensor/bewegungsmelder/?pw=passwortxyz&idnr=1
 http://192.168.2.75/sensor/temperatur/?pw=passwortxyz&idnr=1&wert=20
 
 Verwendetes Display: 2.2 Zoll Serial TFT-Farbdisplay; SPI; Auflösung 240x320 Pixel 
 Bezugsquellen Display:
 Amazon - http://amzn.to/2iNmaXx / Amazon - http://amzn.to/2j1VIXK
  
 Temperatur wird über angeschlossenen Sensor DS18B20 ausgelesen und auf dem Display angezeigt
 Temperatursensor DS18B20 an Pin D2 
 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX 
 
 Notwendig ist die angepasste Display-Lib: https://github.com/glennirwin/Adafruit_ILI9340
 
 Programm erprobt ab Arduino IDE 1.6.13
 Projektbeschreibung und weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/


#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9340.h" //verwendete Lib für Display https://github.com/glennirwin/Adafruit_ILI9340
#include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird https://github.com/milesburton/Arduino-Temperature-Control-Library
#include <Base64.h>
#include <OneWire.h>

#define ONE_WIRE_BUS D2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);


float merketemperatur=0;
float merkeaussentemperatur=0;


//Pinbelegung für Display

#define TFT_CS D0 //GPIO 16 interne LED kein Port nötig, da TFT CS an GND
#define TFT_RST 10 //D12 GPIO10 //kein Port nötig, da Reset an Reset angeschlossen
#define TFT_DC D1 // GPIO 5
#define TFT_MOSI D7 // GPIO 13
#define TFT_CLK D5 // GPIO 14
#define TFT_MISO D6 // GPIO 12

#define SPEAKER D4 // GPIO 2 Lautsprecher für Signalton
#define TASTER D3 // GPIO 0 Flash Taster

Adafruit_ILI9340 tft = Adafruit_ILI9340(TFT_CS, TFT_DC, TFT_RST);

//Falls die Anzeige gedreht wird
#define ROTATION_NO 0
#define ROTATION_90 1
#define ROTATION_180 2
#define ROTATION_270 3

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

const char* ssid = "euressid"; //Ihr Wlan,Netz SSID eintragen
const char* pass = "euerwlanpasswort"; //Ihr Wlan,Netz Passwort eintragen
IPAddress ip(192,168,2,75); //Feste IP des neuen Servers
IPAddress gateway(192,168,2,1); //Gatway (IP Router eintragen)
IPAddress subnet(255,255,255,0); //Subnet Maske eintragen


ESP8266WebServer server(80);

void handleRoot() {
 //Temperatur auch bei Url-Aufruf zurückgeben
 String message="*** Ueberwachungs Server - Beispiel von www.mikrocontroller-elektronik.de ***\n";
 String tempstr= String(merketemperatur, 2); 
 message += "Temperatur Innen : " + tempstr +"\n";
 tempstr= String(merkeaussentemperatur, 2); 
 message += "Temperatur Aussen: " + tempstr +"\n";
 server.send(200, "text/plain", message);
}

void handleTemperatur() {
 //printUrlArg(); //fuer Debugz Zwecke

 String stemp =server.arg("wert");
 float temperatur = stemp.toFloat();
 if (merkeaussentemperatur!=temperatur) {
 zeigeAussenTemperatur(temperatur);
 merkeaussentemperatur=temperatur;
 }

 //Temperatur auch bei Url-Aufruf zurückgeben
 String message="*** Ueberwachungs Server - Beispiel von www.mikrocontroller-elektronik.de ***\n";
 String tempstr= String(merketemperatur, 2); 
 message += "Temperatur Innen : " + tempstr +"\n";
 tempstr= String(merkeaussentemperatur, 2); 
 message += "Temperatur Aussen: " + tempstr +"\n";
 server.send(200, "text/plain", message);
}

void printUrlArg() {
 //Alle Parameter seriell ausgeben
 String message="";
 for (uint8_t i=0; i<server.args(); i++){
 message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
 }
 server.send(200, "text/plain", message);
 Serial.println(message);
}
 
void setup() {

 pinMode(TASTER, INPUT); // Port aus Ausgang schalten
 DS18B20.begin(); //lokale Temperaturmessung
 
 Serial.begin(115200);
 Serial.println(" \r\nINIT \r\n") ;

 WiFi.begin(ssid, pass);
 WiFi.config(ip, gateway, subnet);
 while (WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print(".");
 } 
 Serial.println("");
 Serial.print("Verbunden mit ");
 Serial.println(ssid);
 Serial.print("IP address: ");
 Serial.println(WiFi.localIP());
 
 server.on("/",handleRoot) ;
 server.on("/sensor/temperatur/", handleTemperatur);
 server.begin();
 
 Serial.println("HTTP Server wurde gestartet!");

 tft.begin();
 tft.setRotation( ROTATION_270);
 tft_zeichneRahmen();
 tft_zeichneBeschriftung();
 
}


void tft_zeichneBeschriftung(void)
{
 tft.setTextColor(ILI9340_WHITE); 
 tft.setCursor( 10,5);
 tft.setTextSize(2); 
 tft.print("Innentemperatur");

 tft.setCursor( 285,5);
 tft.setTextSize(1); 
 tft.print("O");
 tft.setTextSize(3); 
 tft.print("C");


 tft.setTextColor(ILI9340_WHITE); 
 tft.setCursor( 10,127);
 tft.setTextSize(2); 
 tft.print("Aussentemperatur");

 tft.setCursor( 285,127);
 tft.setTextSize(1); 
 tft.print("O");
 tft.setTextSize(3); 
 tft.print("C");



 tft.setTextSize(1); 
 tft.setCursor( 50,15);
 //tft.print("www.Mikrocontroller-Elektronik.de");
 tft.setTextSize(2); 
 tft.setCursor( 10,210);
// tft.print("NodeMCU Beispiel");
}

void tft_zeichneRahmen( )
{
 
 tft.fillScreen(ILI9340_BLACK);
 
 tft.drawRoundRect(0, 0, tft.width()-1,117, 10, ILI9340_GREEN);
 tft.drawRoundRect(0, 122, tft.width()-1,117, 10, ILI9340_BLUE); 
}


float getTemperatur() {
 float temp;
 int timeout;

 Serial.println("Messe ...");
 timeout=30;
 do {
 DS18B20.requestTemperatures(); 
 temp = DS18B20.getTempCByIndex(0);
 delay(100);
 timeout--;
 if (timeout<0) temp=99.9; //Wenn Sensor defekt
 } while (temp == 85.0 || temp == -127.0) ;

 //Temperatur Korrektur
 temp=temp-0.5;
 
 return temp;
}


void zeigeTemperatur(float temperatur)
{
 char temperaturStr[6];
 //dtostrf(temperatur, 2, 1, temperaturStr);
 dtostrf(temperatur, 4, 1, temperaturStr);
 Serial.print("Temperatur: "); 
 Serial.println(temperaturStr); 


 //Unterschiedliche Farben je nach Temperatur
 uint16_t textfarbe=ILI9340_WHITE; 
 if (temperatur>0) textfarbe=ILI9340_BLUE;
 if (temperatur>7) textfarbe=ILI9340_CYAN;
 if (temperatur>18) textfarbe=ILI9340_MAGENTA ;
 if (temperatur>22) textfarbe=ILI9340_RED ;
 if (temperatur>25) textfarbe=ILI9340_YELLOW ;


 tft.setTextSize(10); 
 tft.setTextColor(textfarbe, ILI9340_BLACK ); 
 tft.setCursor(20,30);
 tft.print(temperaturStr);
 //tone(SPEAKER, 1200,500);
}


void zeigeAussenTemperatur(float temperatur)
{
 char temperaturStr[6];
 //dtostrf(temperatur, 2, 1, temperaturStr);

 //Zweistellige Minustemperaturen passen nicht in der groesse auf LCD, daher Kommastelle weglassen
 int k=1;
 int l=4;
 if (temperatur<-9.9) {
 k=0;
 l=3;
 }

 dtostrf(temperatur, l, k, temperaturStr);
 Serial.print("AussenTemperatur: "); 
 Serial.println(temperaturStr); 

 //Unterschiedliche Farben je nach Temperatur
 uint16_t textfarbe=ILI9340_WHITE; 
 if (temperatur>0) textfarbe=ILI9340_BLUE;
 if (temperatur>7) textfarbe=ILI9340_CYAN;
 if (temperatur>18) textfarbe=ILI9340_MAGENTA ;
 if (temperatur>22) textfarbe=ILI9340_RED ;
 if (temperatur>25) textfarbe=ILI9340_YELLOW ;

 
 tft.setTextSize(10); 
 tft.setTextColor(textfarbe, ILI9340_BLACK ); 
 tft.setCursor(20,152);
 tft.print(temperaturStr);
 tone(SPEAKER, 1000,500);
}


 
void loop(void)
{
 int taste = digitalRead(TASTER);  //Nur Test
 Serial.println(taste); //Nur Test

 server.handleClient();
 
 delay(500); 

 float temperatur = getTemperatur();
 if (merketemperatur!=temperatur) {
 zeigeTemperatur(temperatur);
 merketemperatur=temperatur;
 }
}

Hier noch der Code für den ESP12E der als Außensensor fungiert:

/*
 ESP12E--Client-Aussentemperatur

 Temperatur wird über angeschlossenen Sensor DS18B20 ausgelesen und per Url an einen Server uebertragen.
 Als Server (also Empfaenger) kann ebenfalls ein NodeMcu-Board verwendet werden.
 Ein Beispiel-Empfaenger empfehlen wir das Script "NodeMCU-Server-TFT-Temperatur" auf unser
 Projektseite. Dieses gibt die empfangene Temperatur als auch lokale Temperatur auf einem
 QVGA-Farbdisplay aus.
 Die Temperatur wird nur alle 15 Minuten übertragen um Energie zu sparen und Batterie
 Betrieb zu ermöglichen. Zwischendurch legt sich das Board schlafen.
 
 Temperatursensor DS18B20 an Pin D2 
 
 Bezugsquelle Temperatursensor: Reichelt / Conrad / Amazon - http://amzn.to/2i3WlRX 
 Bezugsquelle NodeMCU Board: http://amzn.to/2iRkZGi

 Notwendige Lib:
 https://github.com/milesburton/Arduino-Temperature-Control-Library
 
 Programm erprobt ab Arduino IDE 1.6.13
 Projektbeschreibung und weitere Beispiele unter https://www.mikrocontroller-elektronik.de/
*/

#include <ESP8266WiFi.h>
#include <DallasTemperature.h> //Siehe Hinweis oben, verwendet wird https://github.com/milesburton/Arduino-Temperature-Control-Library
#include <Base64.h>
#include <OneWire.h>


#define ONE_WIRE_BUS D2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);


const char* ssid = "euressid"; //Hier SSID eures WLAN Netzes eintragen
const char* password = "euerwlanpasswort"; //Hier euer Passwort des WLAN Netzes eintragen

const char* host = "192.168.2.75"; //Server der die temperatur empfangen soll (Feste freie IP angeben)
const char* script = "/sensor/temperatur/"; //Verzeichnis

const char* passwort = "passwortxyz"; //Passwort, derzeit ungenutzt

const char* idnr = "1"; //Hier kann man dem Sensor eine beliebe ID zuteilen (derzeit ungenutzt)
const char* location = "Solarlampe"; //Hier kann man dem Sensor eine beliebe Info zum Raum/Ort des Sensors mitgeteilt werden (derzeit ungenutzt)

const int sleepzeit_Min=15; //Wieviel Minuten soll das Modul nach der Übermittlung der Daten schlafen
const int sleepzeitError_Min=10; //Wieviel Minuten soll das Modul nach Verbindungsproblem schlafen


#define LED D0 //Interne Led auf dem NodeMCU Board LED_BUILTIN

void setup() {
 int timeout;
 
 DS18B20.begin(); 
 Serial.begin(115200);
 delay(10);

 Serial.println();
 Serial.println();
 Serial.print("Verbinde mich mit Netz: ");
 Serial.println(ssid);
 
 WiFi.begin(ssid, password);

 timeout=40;
 while (WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print(".");
 timeout--;
 if (timeout<0){
 Serial.println("WLAN Verbindung kann nicht aufgebaut werden!");
 WiFi.disconnect(); 
 Serial.print("Schlafe jetzt ...");
 ESP.deepSleep( sleepzeitError_Min*60000000); //Angabe in Minuten
 }
 }

 Serial.println("");
 Serial.println("WiFi Verbindung aufgebaut"); 
 Serial.print("Eigene IP des ESP-Modul: ");
 Serial.println(WiFi.localIP());
}


float getTemperatur() {
 float temp;
 int timeout;

 Serial.println("Messe ...");
 timeout=30;
 do {
 DS18B20.requestTemperatures(); 
 temp = DS18B20.getTempCByIndex(0);
 delay(100);
 timeout--;
 if (timeout<0) temp=99.9; //Wenn Sensor defekt
 } while (temp == 85.0 || temp == -127.0) ;
 
 return temp;
}


//In unserem Beispiel wird die loop Schleife eigentlich nur einmal durchlaufen
void loop() {

 char temperaturStr[6];
 float temperatur = getTemperatur();
 dtostrf(temperatur, 2, 1, temperaturStr);
 Serial.print("Temperatur: "); 
 Serial.println(temperaturStr); 

 
 int versuche=1; 
 WiFiClient client;
 const int httpPort = 80;
 int erg;
 do
 {
 Serial.print("Verbindungsaufbau zu Server ");
 Serial.println(host);

 erg =client.connect(host, httpPort);
 if (!erg) {
 versuche++; 
 Serial.println("Client Verbindungsaufbau nicht moeglich!!!");
 if (versuche>3){
 Serial.println("Klappt nicht, ich versuche es spaeter noch mal!");
 client.stop();
 WiFi.disconnect(); 
 Serial.print("Schlafe jetzt ...");
 ESP.deepSleep( sleepzeitError_Min*60000000); //Angabe in Minuten
 }
 }
 delay(2000);
 } while (erg!=1);
 
 String url = script; //Url wird zusammengebaut
 url += "?pw=";
 url += passwort;
 url += "&idnr=";
 url += idnr;
 url += "&location=";
 url += location;
 url += "&wert=";
 url += temperaturStr;
 
 Serial.print("Folgende URL wird aufgerufen: ");
 Serial.println(host + url);
 
 client.print(String("GET ") + url + " HTTP/1.1\r\n" +
 "Host: " + host + "\r\n" + 
 "Connection: close\r\n\r\n");
 unsigned long timeout = millis();
 while (client.available() == 0) {
 if (millis() - timeout > 5000) {
 Serial.println(">>> Client Timeout !");
 Serial.println("Uebergabe klappt nicht, ich versuche es spaeter noch mal!");
 client.stop();
 WiFi.disconnect(); 
 Serial.print("Schlafe jetzt ...");
 ESP.deepSleep( sleepzeitError_Min*60000000); //Angabe in Minuten
 }
 }

 Serial.print("Rueckgabe vom Server:\n");
 while(client.available()){
 String line = client.readStringUntil('\r');
 Serial.print(line);
 }

 client.stop();
 WiFi.disconnect(); 
 Serial.println("\nVerbindung beendet");
 
 Serial.print("Schlafe jetzt ...");
 ESP.deepSleep( sleepzeit_Min*60000000); //Angabe in Minuten
}

Projekt: ESP12E Breadboard Adapter und WLAN-Temperatursensor

Als letztes möchte ich Euch in dem Beitrag noch ein kleines Projekt vorstellen mit dem Ihr noch einfacher mit dem ESP12E-Modul experimentieren aber auch Projekte umsetzen könnt. Ich habe das Projekt schlicht „ESP12E-Adapter“ genannt, es eignet sich aber auch für baugleiche Module mit ESP8266 Chipsatz. Es ist eigentlich auch etwas mehr als nur ein Adapter, denn man kann optional auch Spannungsregler, Temperatursensor, Reset-Taster, Stiftleisten für Programmierung und Jumper sowie diverse Pullup und Pulldown-Widerstände bestücken.

Das ist aber alles optional. Möchte man diese kleine Platine lediglich als reinen Adapter nutzen, damit man das ESP12E Modul in ein Steckbrett einstecken kann, dann braucht man nur die beiden Stiftleisten JP1 und JP2 zu bestücken. Alles andere kann dann auf dem Steckbrett verschaltet werden, im Gegensatz zu dem oben vorgestellten Adapter, werden hier alle Pins des ESP12 Moduls herausgeführt. Alle Pins sind auch beschriftet, das „G“ steht hier für „GPIO“.

Möchte man sich aber die Arbeit auf dem Steckbrett erleichtern, so kann man auch alle wichtigen Kondensatoren und Widerstände gleich auf dem Adapter bestücken.
Das ESP12E-Modul wird übrigens auf der Rückseite des Adapters bestückt, daher sieht man hier im Bestückungsplan nur die Antenne herausragen.

Universeller ESP12E Adapter und WLAN-Temperatursensor (im Platinenservice erhältlich)

Mit Stiftleisten auf dem Breadboard (Steckbrett) sieht es so aus

Bestückungsplan unseres ESP12E-Adapters (vergrößert)

Bauteile Bestückungsliste / Bestellliste zum ESP12E-Adapter

Möchte man diese Platine weniger als Adapter nutzen, sondern viel mehr eine kleine Anwendung damit umsetzen, dann kann man auch ganz auf die äußeren Pinleisten verzichten. Dadurch reduziert sich die Bauhöhe erheblich und man kann die Pins dann direkt zum Anlöten von Drähten für Taster oder Sensoren nutzen. Programmieren lässt sich das Modul wieder ganz einfach über einen USB-Adapter den man an die hintere 4 polige Stiftleiste ansteckt (wir haben es oben schon bei der Lochraster Variante gesehen).
Die zweite Pinleiste kann genutzt werden um Jumper aufzustecken.

Folgende Jumper sind möglich:

• F/GND brücken – Flash Modus, notwendig wenn das Modul programmiert wird
• W/R brücken – Wake-Reset Brücke, sorgt dafür dass sich das Modul selbst wecken kann

Natürlich könnte man statt Jumper dort auch einen Flash.Taster und Reset-Taster anschließen, falls man das vorzieht. Die Stiftleisten können wahlweise gerade oder gewinkelt (nach vorn oder hinten) eingelötet werden, je nachdem wie man es mag.
Als Spannungsregler kann wahlweise ein MCE1700-3302E* als IC1 oder ein MCP1702 3,3v Sot 23 als IC4 eingesetzt werden. Letzterer würde die Bauhöhe noch etwas verringern.
Die Platine kann auch bereits einen Temperatursensor vom Typ DS18B20 als IC1 direkt aufnehmen. Wenn das Modul oft schläft, braucht man auch keine Eigenwärme zu befürchten, ansonsten kann man den Temperatursensor natürlich auch weiter weg anbringen und mit Kabel verbinden.

Bestückt man alles so, hat man einen funktionsfähigen programmierbaren Temperatursensor, es braucht dann nichts weiter außen angeschlossen oder verdrahtet werden. Die genaue interne Verschaltung der Bauteile könnt Ihr auch aus dem Schaltplan genauer ersehen. So ist beispielsweise auch eine Überwachung der Batteriespannung durch einen stromsparenden hochohmigen Spannungsteiler realisiert..

Schaltplan unseres ESP12E-Adapters

Vereinfachte Darstellung der Schaltung mit den Stiftleisten

Einige Widerstände sowie den Spannungsteiler zum Abfragen der Batteriespannung haben wir der Übersicht wegen in der nachfolgenden Schaltungsskizze weggelassen

Downloads

  Eagle-Dateien (ZIP)

  Pinsbelegung ESP12E-Adapter (PDF)

  Pinsbelegung ESP12E (PDF)

  NodeMCU und ESP12E Arduino Sketch Server- und Aussensensor (ZIP)

_{Das Leiterplattenangebot  ist ein Service Angebot der jeweiligen Anbieter. Bei Fragen bezüglich Lieferung und Preis bitte dort nachfragen!}

Links zum Thema

• Einstieg mit dem NodeMCU Board
• Flash-Tool mit integrierter Firmware
• Datenblatt zum USB-Chip CP2102
• Hersteller der ESP8266-Serie spressif.com
• Schaltplan eines ESP12 Moduls (Reverse engineered)
• ESP12E Programmierung über seriellen Adapter
• Neues deutsches Forum zum NodeMCU-Board und der ESP8266-, ESP32-Serie
• Englisches Forum zum ESP8266 / NodeMCU
• Energiesparende Alternative zu WLAN = RFM12B
• Bezugsquelle für NodeMCU Amazon*  / Ebay*
• Bezugsquelle für ESP8266 Modul ESP12-E Amazon* / Ebay* 
• Deutsche Bücher zu NodeMCU und ESP8266
• WiFi Funk-Notruftaster
• Stiftleiste-Wannenstecker Adapter (ideal für oben verwendetes Display)

Weitere Hinweise

Das Projekt unterliegt einer CC-Lizenz - Lizenzhinweis (zum Aufklappen anklicken)

Um ihnen weitgehende Möglichkeiten zum Nutzen der Schaltung einzuräumen, wurde dieses Projekt jetzt unter die CC-Lizenz gestellt. Sie haben So die Möglichkeit die Schaltung beliebig zu verändern oder weiterzugeben. Lediglich die kommerzielle Weitergaben ist nur mit Genehmigung möglich! Genauere Hinweise finden Sie im Lizenztext. Bei einer Veröffentlichung oder Weitergabe ist nachfolgender Text sichtbar zu übernehmen:

---

Falls Dir der Beitrag gefallen oder geholfen hat kannst Du dem Autor aber gerne durch eine kleine Spende Danke sagen!

Projekt (Schaltung & Projektdateien) von Frank ist lizenziert unter einer Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 4.0 International Lizenz. Über diese Lizenz hinausgehende Erlaubnisse können Sie unter https://www.mikrocontroller-elektronik.de/ erhalten. Lizenziert wurde das Projekt von: www.Roboternetz.de & www.Mikrocontroller-Elektronik.de  -  Autor/User Frank Dieser Name und diese Webseiten sind bei der Weitergabe stets deutlich sichtbar zu nennen!

---