ESP12E, Einstieg mit dem ESP8266 Modul

ESP12E-Tutorial

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.

Letzte Aktualisierung am 29.03.2017 / 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 http://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.

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

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 http://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 http://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 http://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
×

 

2 Gedanken zu “ESP12E, Einstieg mit dem ESP8266 Modul

  1. Jens

    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

    Antworten
    • Frank Autor des Beitrags

      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!

      Antworten

Schreibe einen Kommentar

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

Top