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 AP STA AP+STA Modus | Christian's Technikshop
Hrph Nodemcu LUA WiFi Internet ESP8266 Development Board

Letzte Aktualisierung am 19.03.2024 / Affiliate Links / Bilder von der Amazon Product Advertising API

 

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.

NodeMCU-esp8266-esp12e-hand

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.

ESP12E-Pinbelegung

 

Erste ESP12E Experimente auf dem Breadboard (Steckbrett)

ESP12E-Adapter-handFü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

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.

ESP12E-Adapter-bestueckt-hand

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

ESP12E-Modul-Eigenbau-Adapter

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.

ESP12E-Modul-und-USB-Adapter

 

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:

ESP12E-Grundschaltung

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:

ESP12E-Modul-Grundschaltung-Steckbrett

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.

ESP12E-Beschaltung-Empfehlung

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.

ESP12E-Wland-Temperatursensor

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.

ESP12E-Modul-Lochraster-Temperatursensor

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.

ESP12E-Modul-Lochraster-Temperatursensor-programmieren

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.

ESP12E-Modul-Lochraster-Temperatursensor-Solarlampe3

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.

Solarlampe-Aussenwand

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.

NodeMCU-Server-Lochraster-Test

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.

NodeMCU-Server-Fertig

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

NodeMCU-Server-Fertig-Rueckseite

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.

NodeMCU-mini-server

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

ESP12E-Adapter-PlatineAls 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.

ESP12E-Adapter-bestueckt-beidseitig

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

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

ESP12E-Breadboard-Adapter

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

ESP12E-RN-Adapter-Bestueckung

 

 

Bauteile Bestückungsliste / Bestellliste zum ESP12E-Adapter

AnzahlPlatinen-
bezeichnung
BeschreibungLink / Bezugsquelle
1C11µF Keramik C1206 KondensatorBezugsquelle Reichelt* Best.Nr. X7R 1206FCD 1,0U
1C2SMD Elko ca. 1 bis 100 µFBezugsquelle Reichelt*
2C3,C4 Keramik Kondensator 100nBezugsquelle Reichelt*
1R1 SMD Widerstand 3,9k (M1206)
(nur nötig wenn Temperatursensor genutzt wird)
Bezugsquelle Reichelt*
1R2SMD Widerstand 10k (M1206)
(immer nötig, Pulldown für GPIO15)
Bezugsquelle Reichelt*
1R4SMD Widerstand 470k (M1206)
(R4/R5 bilden Spannungsteiler für Spannungsmessung)
Bezugsquelle Reichelt*
1R5SMD Widerstand 82k (M1206)
(R4/R5 bilden Spannungsteiler für Spannungsmessung)
Bezugsquelle Reichelt*
1IC1Spannungsregler MCP1700-3302E
(optional)
Bezugsquelle Conrad*
1IC2Temperatursensor DS18B20
(Optional)
Bezugsquelle Conrad*
1IC4Spannungsregler MCP1702 3,3v Sot 23
(optional anstelle von IC1)
Bezugsquelle Conrad*
2J1/J212 polige Stift- oder BuchsenleisteBezugsquelle Reichelt*
1J3Vierpolige Stiftleiste zum programmieren und zur SpannungsversorgungBezugsquelle Reichelt*
1J4Fünfpolige Stiftleiste für zwei Jumper (Programmiermodus und Auto Wake)Bezugsquelle Reichelt*
1TasterSMD-Taster
(optionaler Reset-Taster)
Bezugsquelle Reichelt*
2JumperBezugsquelle Reichelt*
1ESP-ModulESP12E -Wlan ModulBezugsquelle Amazon*
1Platine zum ESP12E AdapterPlatinenservice
1USB-UART AdapterAm besten den UM2102 von ELV, da dieser teils nicht mehr erhältlich, kann man aber auch einen ähnlichen nutzen (siehe Amazon Angebote*). Auf die Pinbelegung achten.
Alle Angaben ohne Gewähr

 

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

ESP12E-RN-Adapter-Schaltplan

ESP12E-Adapter-Pinbelegung-neu

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

ESP12E-Aussensensor-mit-Stiftleiste-vereinfacht

 

Downloads

  Eagle-Dateien (ZIP)

  Pinsbelegung ESP12E-Adapter (PDF)

  Pinsbelegung ESP12E (PDF)

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

Leiterplatte zum Projekt bestellen

Neu! Die Leiterplatte für dieses Projekt ist direkt über den Shop PlatinenCenter erhältlich. Da die Platinen dort vorgefertigt werden, sind diese sehr preiswert lieferbar.

Zum Platinen Shop

Individuelle Leiterplatten

Möchtest du keine vorgefertigte Leiterplatte, weil Du vielleicht vorher Änderungen an dem Layout vornehmen möchtest, dann empfehlen ich die Anbieter auf unserer Leiterplatten-Service Seite.

Leiterplatten Hersteller

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

Links zum Thema

 

Weitere Hinweise

Vor dem Aufbau bitte nachfolgende Hinweise lesen:
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:
cc_logo310

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!
Achtung: Es kann keinerlei Garantie für die Fehlerfreiheit der Schaltung oder anderer Projektdateien übernommen werden! Der Nachbau und Betrieb geschieht auf eigene Gefahr! Jegliche Haftung für Schäden oder Verletzungen wird ausgeschlossen! Schadensersatzansprüche, gleich aus welchem Rechtsgrund, sind ausgeschlossen.
Sicherheitshinweise und Haftungsausschluss (zum Aufklappen anklicken)
Dieses Projekt dient vornehmlich für Lehrzwecke und zum Experimentieren. Für den Aufbau sollten ausreichend Elektronik Grundkenntnisse und Kenntnisse bezüglich der Sicherheit (Experimentieren mit Strom und Handhabung gängiger Werkzeuge wie Lötkolben etc.) vorhanden sein. Unter dem Menüpunkt Buchvorstellungen als auch auf der Seite RN-Wissen.de empfehle ich diesbezüglich noch interessante Literatur mit der man sich dies erarbeiten kann. Für Fragen bezüglich Elektronik und Mikrocontroller empfehle ich das Forum: Roboternetz.de Sicherheitshinweise und Haftungsausschluss

 

28 Kommentare zu “ESP12E, Einstieg mit dem ESP8266 Modul”

  1. Jens sagt:

    Vielen Dank für diese Super Einführung in das Thema ESP8266. Dank Deiner gut verständlichen Darstellung wird der Chip sicher noch ein Stück beliebter. Eine kleine Korrektur hinsichtlich des “handelsüblichen” ESP-Adapters hätte ich noch. Ich hatte mir diesen nämlich gerade bei Amazon bestellt und Deine Aussage, dass der Widerstand R1 ein Pullup auf GPIO2 ist, teile ich nicht. Auch auf Deinem Bild kann man erkennen, dass er ein Pulldown auf GPIO15 ist. Man kann sich da leicht verzählen, da sich die Beschriftung auf die 2,54 Raster Pins bezieht und nicht auf das Modul. Vielleicht könntest Du das bei Dir nochmal prüfen und den Text entsprechend anpassen.
    Viele Grüße, Jens

    1. Frank sagt:

      Freut mich das es dir gefällt, danke für Feedback. Dein Korrekturhinweis stimmt tatsächlich, sorry, da habe ich mich tatsächlich geirrt weil ich vermutlich auf die Bezeichnungen der Stiftleisten geschaut hatte. Bei den vielen unterschiedlichen Pinbezeichnungen muss man sowieso immer genau aufpassen, danke für den Korrekturhinweis, ich habe es bereits korrigiert!

  2. Joachim Seeger sagt:

    Hallo Frank
    habe im Netz den ESP 12 F gefunden. Ist das ein Unterschied zu ESP 12 E?

    1. Frank sagt:

      Es gibt ja viele Module von dem Hersteller, ich habe mich bislang vornehmlich nur mit dem ESP12E* beschäftigt. Das ESP12F müsste aber soweit ich weiß identisch und pinkompatibel sein, verbessert wurde hier wohl die Sendeleistung im 802.11b Betrieb, die soll auf 25 dBm angehoben worden sein. Also die Reichweite dürfte ein wenig höher sein. Man könnte die hier vorgestellte Adapter Platine also auch für das ESP12F nutzen. Die ESP12E-Module sind aber deutlich günstiger, was sich bei größeren Mengen schon deutlich bemerkbar macht. Siehe hier ESP12F-Preise*

  3. Oliver-André Urban sagt:

    Ein schöner Artikel.
    So richtig optimal ist der Adapter aber noch nicht. Der ESP-12E/F muss aufgelötet werden. Das ist doch unpraktisch, wenn man seine geringe Größe nutzen möchte und letztlich nur die Progammierbeschaltung über Adapter vornehmen.

    Mein Gedanke dazu wären Pogo-Pins mit feiner Spitze. Eine NodeMCU vom ESP-12E “befreien”, Pogo Pins auflöten (wichtig:genau ausrichten) und diese mit etwas Epoxydharz genau fixieren.
    Damit hat man quasi einen Programmieradapter, genauso wie früher bei Eprom-Brennern mit einem “Sockel”, der mit wenig Kraftaufwand sicher kontaktiert.
    Einen ESP-12E legt man dann nur noch auf die Pogopins, spannt ein oder zwei Gummibander drum und los gehts.

    Noch besser wäre eine 3d gedruckte Fassung für den ESP-12E/F, in dem unten Löcher für die Pogo-Pins sind und oben mit einem Hebel oder Riegel der rein gedrückte ESP fixiert wird.

    1. Frank sagt:

      Ja wenn Du Adapter nur zum programmieren nehmen willst hast Du sicher recht. Ich nehme ihn aber jetzt immer zum umsetzen meiner Projekte, da ist er klein genug. Kleiner wollte ich ihn nicht machen damit auch Einsteiger die SMD teile noch schnell und bequem löten können.

  4. Günter sagt:

    Warum bekomme ich bei Ausdrücken wie

    string temp;
    temp = “Temperatur=” + ” \n”;

    immer eine Fehlermeldung? -> invalid operands of types ‘const char [11]’ and ‘const char [2]’ to binary ‘operator+’

    Hier im Beispielquelltest ist es doch auch so angegeben.

    1. Frank sagt:

      Du musst “String” groß schreiben, das ist eine Klasse!

  5. Martin Kresse sagt:

    Hallo Frank,

    in der Bestückungsliste sind für den Spannungsteiler zur Spannungsmessung Widerstände mit 470k / 82k angegeben, in den Schaltplänen sind diese jedoch nur als 100k / 22k ausgeführt. Funktionieren beide angegebenen Kombinationen quivalent (zumindest rechnerisch sollten sie das ja ungefähr) und ist die Variante mit den höheren Widerständen unter dem Aspekt “Stromsparen im Batteriebetrieb” nicht zu bevorzugen.

    1. Frank sagt:

      Ja es kommt nur auf das Verhältnis an, beide Varianten gehen. Um viel Energie zu sparen ist die Variante mit 470k / 82k (Bestückungsliste) empfehlenswert

  6. Anton Grimpelhuber sagt:

    Hi Frank,

    irgendwie funktioniert die reine Schaltung für die Stromversorgung nicht: Der MCP1700-3302E liefert leer an 5V die geforderten 3,3V. Sobald das Ganze mit den beiden Keramik-Kondesatoren und den Pull-Up-/Down-Widerständen verschaltet ist, fällt die Spannung zwischen VCC und GND gemessen auf 1,05V ab, was dem ESP zu wenig ist.

    Was mache ich falsch? Danke!

    1. Frank sagt:

      Spannungsregler auch richtig herum verwendet. Probier mal anderen, normal ist das nicht.

  7. Rolf sagt:

    Hallo Frank,

    wie vor schon beschrieben ein sehr schönes Projekt. Nachdem ich mir die Einzelteile besorgt und zusammengebaut habe, die Software aufgenudelt hat auch alle funktioniert. Nachdem ich es geschafft habe, bin eigentlich kein C Programmierer, die Anzeige zu Drehen und ein DS3231 Modul anzuhängen und damit Datum und Uhrzeit angezeigt wird, wollte ich nun auch den Ladezustand des Akku’s anzeigen. auf dem Display habe ich eine kleine Anzeige vorbereitet, in der Client Software auch die Messung der Spannung über A0 geschafft und bei der Anzeige des seriellen Monitors wird die Spannung auch in der Zeile von password. id usw. auch angezeigt, nur ich schaffe es nicht die Akkuspannung auf dem Serverdisplay anzuzeigen. Kannst du mir vielleicht mit einen Tip oder Codeschnipsel weiterhelfen. ??

    1. Frank sagt:

      Im Grunde einfach einen weiteren Parameter übertragen und auswerten.

      1. Rolf sagt:

        Wie ich oben schon beschrieben habe bin ich keine C Programmierer und habe erst vor ca. 2 Jahren angefangen mit den Arduino’s. Ich programmiere schon seit 30 Jahren in Basic, Bascom und den alten Basic Versionen von MS, angefangen mit GW Basic. Ich tue mich halt schwer damit die Syntax von C zu verstehen. Ich hab den Code x-mal gelesen und mit anderen verglichen aber ich komme nicht dahinter wie der Wert übertragen wird. Vielleicht liegt es auch an meinen Alter (60) dass das Verständnis etwas länger braucht. Ich will keinen fertigen Code sondern eben nur einen Schubs in die richtige Richtung um das tolle Projekt eben zu erweitern.
        Vielen Dank für die Antwort, für jemand der in C Programmieren kann ist es bestimmt einfach, nur für jemanden der im Prinzip wenig Ahnung hat wie Werte übertragen werden doch etwas schwierig.

        1. Rolf sagt:

          Das hab ich schon mal hin bekommen,

          Folgende URL wird aufgerufen: 192.168.xx.xx/sensor/temperatur/?pw=passwortxyz&idnr=1&location=Solarlampe&wert=6.1&Ubat=1.10
          Rueckgabe vom Server:
          HTTP/1.1 200 OK
          Content-Type: text/plain
          Content-Length: 93
          Connection: close
          Access-Control-Allow-Origin: *

          nur die Anzeige fehlt noch.

        2. Frank sagt:

          Das Projekt ist schon etwas länger her, ich bin da momentan nicht mehr so drin. Wenn man ein Projekt abgeschlossen hat beschäftigt man sich in der Regel mit neuen Projekten und Programmen, es ist dann schwer dann auf die schnelle noch Codezeilen zu älteren Programmen zu liefern. Da müsste man sich erst wieder Stunden einarbeiten. Aber vielleicht kann dir jemand anders der gerade dran ist etwas helfen. Der Artikel soll halt ne gute Basis und schnellen Einstieg ermöglichen, mehr war nicht geplant.

  8. scheisserchen65 sagt:

    Das ist ein super Beitrag, genau richtig für mich als Anfänger.
    Gibt es evtl. ein Bild von der Unterseite der Lochrasterplatine?
    Mich würde die Verkabelung interessieren.
    (Das Bild unter ‘Auf Lochraster könnte ein solcher Temperatursensor wie auf dem nachfolgenden Bild aussehen’)

    1. Frank sagt:

      Sorry, ist schon ne Weile her, das habe ich kein Bild mehr. Bei dem Kabelgewirr würdest Du wohl auch wenig erkennen. Einfach nach Schaltplan verdrahten und gut ist.

  9. Jens sagt:

    Ist der MCP1700 Spannungsregler ausreichend? ich habe gehört das ESP8266 soll Stromspitzen bis über 500mA ziehen. Besser ist wohl ein LF33CV im TO220 Gehäuse.
    Der regelt gut 0,5A und kann bestimmt noch die Stromspitzen abfangen. Aber anderes PIN-out

    1. Frank sagt:

      Also ich hatte bislang noch keine Probleme mit dem verwendeten Spannungsregler, mehr kann ich dazu nicht sagen.

  10. Emrich sagt:

    Sehr hilfreich

  11. Malte sagt:

    Hallo Frank,

    danke für die schöne Einführung. Bin noch ein ziemlicher Neuling, versuche aber jeden Tag etwas zu erarbeiten. Ich habe den Spannungsregler weggelassen und direkt einen CP2102 UART to USB Converter verwendet. Der liefert ja 5 oder eher gesagt die geforderten 3,3 V, leider kann ich das Modul nicht flashen und bekomme auch unter Aduino keine Verbindung. Ansonsten sollte bei mir alles gleich sein, auch nach einem Neustart liegt der GIPI0 auf GND. Beim Reset blinkt die blaue LED kurz. Hast du vielleicht noch einen Tipp, bin schon etwas verzweifelt.

    1. Frank sagt:

      Der CP2102 liefert nicht genug Strom, Du brauchst Spannungsregler!

  12. Falk sagt:

    Hallo

    Zu erstmal Danke für deine Mühen und das du dein Wissen allen zur Verfügung stellst. Finde das Projekt echt klasse.
    Eine frage hätte ich dazu. Bei der Darstellung “Einen WLAN Temperatursensor für Batteriebetrieb bauen” wurde zwischen GPIO15 und GND kein Widerstand verwendet. Bei der Darstellung darüber ist einer eingezeichnet.
    Falls das so richtig ist, das dieser entfallen kann, würde ich mich über eine kurze Erklärung freuen.
    Bin absoluter Anfänger was das anbelangt.

    Gruß
    Falk

    1. Frank sagt:

      Der Widerstand legt das Signal auch nur auf Masse, in der Praxis kann der Widerstand auch entfallen wenn man ihn überbrückt. Man kann dann aber den Port natürlich nicht mehr Als Ein- oder Ausgangsport während des Betriebes nutzen!

  13. Gorcon sagt:

    Hat sich erledigt. war der fehlende Widerstand R3 der in der Stückliste fehlte.

  14. Jens sagt:

    Mittlerweile setze ich entweder einen HT7333 oder 1117-3.3 ein. Der HT7333 hat keine Strombegrenzung und arbeitet mit dem E-12 gut zusammen. Hat einen sehr geringen Drop. Aber wenn man den kurzschließt dann überhitzt er. Der 1117-3.3 klappt auch, braucht aber statte 5 Volt zum regeln. Der MCP1700 scheint den Strom zu begrenzen und führt zu Problemen.

Schreibe einen Kommentar

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

scroll to top