Make your own ESP8266 WiFi Shield

Der Pragmatische Architekt  –  1 Kommentare

In der letzten Folge haben wir den preisgünstigen Wifi.Chip ESP8266 kennen gelernt, und seine Möglichkeiten (auch außerhalb der Arduino-Welt) beleuchtet. In der vorliegenden Folge soll Arduino-Hardware in Kombination mit einem ESP8266-Board für die Internet-Konnektivität zum Einsatz kommen.

Um den Arduino drahtlos mit dem Internet zu verbinden, hat die Hardwareschmiede von arduino.cc das Original-Wifi-Shield im Angebot, das allerdings mit Marktpreisen von deutlich über 50 Euro zuzüglich Versandkosten tiefe Löcher in das eigene Budget reißt. Das ist insofern überteuert, als es bereits ein Raspberry-Pi-3-Board für einen ähnlichen Obolus gibt.

Hier wäre auch das Genuino/Arduino-Board MKR1000 interessant. Dieses Board wendet sich speziell an den IoT-Entwickler und integriert WiFi. Es ist in diesem Artikel beschrieben.

ESP8266 als Basis für ein WiFi-Shield

Der preisgünstige ESP8266 ist damit die einzige echte Schnäppchen-Option für Anhänger des Arduino-Ökosystems. Eine geeignete Schaltung für das eigene WiFi-Shield gab es schon ihn der letzten Folge. In der Abbildung sehen Sie meinen eigenen Schaltungsaufbau in Aktion.

Eigene Schaltung mit FTDI-Breakout-Board zur Spannungsversorgung und Anschluss des ESP-01 Boards an einen Arduino Mega

In der Schaltung finden Sie konkret folgende Bauteile:

  • Logic-Level-Konverter für die Trennung zwischen 3,3-V-Logik und 5-V-Logik
  • FTDI-Breakout-Board
  • ESP-01-Board
  • Drahtbrücken
  • Breadboard
Günstiges Prototyping-Shield (Bild: aliexpress.com)

Es bietet sich an, zusätzlich Schalter zu integrieren, um das Board wahlweise als Arduino-Erweiterung oder als eigenständiges System nutzen zu können. Allerdings gibt es fertige Shields mit den beschriebenen Funktionen bereits ab 5 Euro (China) bzw. 11 Euro (Deutschland). Die sind aber meistens mäßig bis gar nicht dokumentiert. Natürlich macht das Selbstentwickeln einer Lösung auch viel mehr Spaß.

Statt des FTDI-Boards könnten Sie auch einen Spannungsregler integrieren, der eine externe Spannungsquelle nach 3.3V transformiert. Dies kommt aber nur in Betracht, wenn Sie das ESP8266-Board ausschließlich über den Arduino, nicht aber als eigenständiges Board nutzen wollen.

Das selbstgebaute ESP8266 Board oder Shield

Eine rudimentäre Schaltung habe ich per Fritzing erstellt. Sie können diese Schaltung ohne große Probleme auf das oben dargestellte Protoshield übertragen, um damit ein eigenes Shield herzustellen. Wer will, kann die Schaltung um LEDs (z.B. für Digital-Port 13) oder Elektrolytkondensatoren zur Spannungsglättung ergänzen.

Bibliotheken

Irgendwann möchten Sie die Hardware (Shield oder Board) als Erweiterung für den Arduino nutzen. Auch hier gibt es zwei Wege: Selbstbau einer Bibliothek oder Nutzung einer bereits existierenden Bibliothek. In der Arduino IDE gelangen Sie durch die folgende Menü-Navigation: Sketch | Include Library | Manage Libraries zu einem Fenster, auf dem Sie rechts oben einen Suchausdruck eingeben können. Suchen Sie dort nach esp8266.

Suche ind er Arduino IDE nach einer ESP8266-Bibliothek.

Und navigieren Sie in der Liste der verfügbaren Bibliotheken bis zur Bibliothek WiFiEsp, um diese auszuwählen und zu installieren.

Nun können Sie über den Pfad File | Examples | WiFiEsp ein Beispiel laden, etwa ConnectWPA. Tragen Sie noch die Zugangsdaten zu Ihrem WLAN in den Code ein, passen Sie dort die Geschwindigkeit der seriellen Ports auf Ihre Gegebenheiten an, und starten Sie den Sketch.

Sie müssten am seriellen Monitor verfolgen können, wie sich der Arduino über den ESP8266 erfolgreich mit dem WLAN verbindet:

Beispiel ConnectWPA aus der Bibliothek WiFiEsp

Damit haben Sie die erste Verbindung geschafft.

Größeres Beispiel mit WiFiEsp: LED per Browser kontrollieren

In einem etwas umfangreicheren Beispiel soll eine LED über den Browser gesteuert werden. Der Benutzer das mit der Bibliothek WiFiEsp mitgelieferte Beispiel WebServerLed angepasst und erweitert. Sie müssen zur Schaltung lediglich eine LED über einen >= 220-Ohm-Widerstand an einem Pin anschließen und die Pin-Nummer(ledPIN) im Sketch eintragen. Wenn alles fertig ist, sollte es wie folgt aussehen:

Links sehen wir die einfache Browserseite, rechts die Ausgaben des Sketches am seriellen Monitor. Die Rolle des Webservers nimmt unser Arduino-Board ein. Zur drahtlosen Kommunikation nutzen wir ein ESP8266-Board und die WiFiEsp-Bibliothek.

Wie kommen wir zu dem obigen Ergebnis? Der Sketch initialisiert während des Setups die seriellen Port, meldet sich am lokalen WLAN an, und startet einen Webserver auf Port 80.

In der Endlosschleife wartet der Sketch auf Client-Anfragen. Erkennt er eine Anfrage, verbindet er sich mit dem Client, und sendet diesem die Webseite zur Steuerung der LED zu. Am Schluss baut der Sketch die Verbindung wieder ab.

Die Methode sendHttpResponse() baut die an den Client gesendete HTML-Seite auf, und sendet Sie an den Client. Die Hilfs-Methode printWifiStatus() gibt zur Kontrolle die aktuellen Wifi-Daten am seriellen Monitor aus.

Der Sketch ist gut kommentiert, sodass Sie sich darin einfach zurechtfinden sollten.

////////////////////////////////////////////////////////////////
// Ein WebServer auf dem Arduino erlaubt die Steuerung einer LED
// Das Beispiel setzt WPA-Netzwerke voraus
////////////////////////////////////////////////////////////////

#include <WiFiEsp.h> // Header von WiFiEsp einbinden

// Entweder SoftSerial (UNO, LEONARDO) auf Pins 6+7 oder
// Hardware-Serial (RX1,TX1) (MEGA, DUE)


#ifndef HAVE_HWSERIAL1
#include "SoftwareSerial.h"
SoftwareSerial Serial1(6, 7); // Virtuelles RX, TX
#endif

char WiFiSSID[] = “…………….”; // Ihre SSID
char WiFiPass[] = “…………….”; // Ihr Zugangs-Passwort
int status = WL_IDLE_STATUS;


// LED: Initialzustand und Pin
int led = LOW;
int ledPIN = 10;

WiFiEspServer WebServer(80); // Vereinbarung des Mini-WebServers

// in WiFiESP ist ein Ringpuffer-Typ vereinbart, den wir nutzen
RingBuffer puffer(24);

//////////////////////////////////////////////////////////////////////
// setup():
// Initialisieren der beiden seriellen Ports, Anmeldung am WLAN
// und Start des Webservers
//////////////////////////////////////////////////////////////////////

void setup()

{
Serial.begin(9600); // Serieller Port zeigt den Status (auf der IDE)
Serial1.begin(115200); // Zweiter serieller Port verbunden mit ESP8266
WiFi.init(&Serial1); // Initialisierung des Ports

// Hat es geklappt?
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("ESP8266 nicht gefunden");
// Wenn nein, dann in Endlosschleife gehen
while (0 == 0);
}

// Verbindung initiieren
while (status != WL_CONNECTED) {
Serial.print("Verbindungsaufbau zu ");
Serial.println(WiFiSSID);
// Verbindung zum WPA-Netzwerk aufbauen
status = WiFi.begin(WiFiSSID, WiFiPass);
}

Serial.println("Verbindung erfolgreich");
printWifiStatus();

// Webserver am Port 80 aktivieren
WebServer.begin();
}

/////////////////////////////////////////////////////////////////
// loop()-Methode:
// In der Endlosschleife warten wir auf eingehende
//
Clientverbindungen, kommunizieren mit dem jeweiligen Client
// und schließen die Verbindung wieder (Session-Ende!)
/////////////////////////////////////////////////////////////////

void loop()

{
// Warten auf Verbindungswünsche von Clients
WiFiEspClient client = WebServer.available();

if (client) { // Client klopft an.
Serial.println("Neue Client-Verbindung"); // Ausgabe auf seriellen
// Monitor

puffer.init(); // Ringpuffer initialisieren
while (client.connected()) { // Solange Client verbunden
if (client.available()) { // Wenn Client was sendet,
char c = client.read(); // wird das Byte gelesen und
puffer.push(c); // im Puffer abgelegt


// Ein HTTP Reauest endet mit zweimal Zeilenvorsprung/Wagenrücklauf
// => Clientrequest gelesen => Daten senden

if (puffer.endsWith("\r\n\r\n")) {
sendHttpResponse(client);
break;
}

// Endung der Anfrage: http://<webaddresse>/AN oder .../AUS?
if (puffer.endsWith("GET /AN")) {
Serial.println("LED wird eingeschaltet");
led = HIGH;
digitalWrite(ledPIN, HIGH);
}
else if (puffer.endsWith("GET /AUS")) {
Serial.println("LED wird ausgeschaltet");
led = LOW;
digitalWrite(ledPIN, LOW);
}
}
}

// Verbindung schließen
client.stop();
Serial.println("Clientverbindung wurde geschlossen");
}
}
///////////////////////////////////////////////////////////
// Methode sendHttpResponse():
//
Methode, mit der wir dem Client eine Webseite senden
///////////////////////////////////////////////////////////

void sendHttpResponse(WiFiEspClient client)

{
// Hier geben wir eine HTTP-Antwort im vorgeschriebenen Format zurück.
// Erst der Header...

client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println();

// Und dann der Inhalt:
client.println("<H1> LED-Steuerung am Arduino </h1> <br>");
client.print("Im Augenblick ist die LED ");
if (led == LOW) client.print(" <b>ausgeschaltet</b>.");
else client.print("<b>eingeschaltet</b>.");
client.println("<br>");
client.println("<br>");
client.println("Klicken Sie <a href=\"/AN\">hier</a>, um die LED einzuschalten<br>");
client.println("Klicken Sie <a href=\"/AUS\">hier</a>, um die LED auszuschalten<br>");

// Und am Schluss weitere Leerzeile einfügen

client.println();
}

///////////////////////////////////////////////////////
// Methode printWifiStatus():
// Ausgabe WiFi-Status und Info im seriellen Monitor
///////////////////////////////////////////////////////

void printWifiStatus()

{
// Netzwerkdaten: SSID
Serial.print("SSID: ");
Serial.println(WiFi.SSID());

// Netzwerkdaten: IP-Adresse

IPAddress ip = WiFi.localIP();
Serial.print("IP Adresse: ");
Serial.println(ip);

// Hinweis im seriellen Monitor
Serial.println();
Serial.print("Um den Fernzugriff zu testen, gehen Sie bitte
auf die Webseite http://");
Serial.println(ip);
Serial.println();
}

Den Sketch können Sie gerne als Basis eigener Projekte einsetzen. Gedient hat der er überwiegend zur Demonstration der Fähigkeiten des ESP8266. Damit sollten Sie jetzt ein gutes Grundwissen besitzen.

Fazit

Der ESP8266 ist ein sehr vielfältig einsetzbarer Chip, der dem Arduino für wenige Euro zu WiFi-Fähigkeiten verhilft, sich aber auch als eigenständiges Board in der Arduino IDE nutzen lässt. Das alles zu einem sehr geringen Preis von nur wenigen Euro. Wer ein bisschen experimentiert, kann dem Baustein allerlei Potenzial entlocken.

Damit haben wir für das Erste das Thema Vernetzung und Kommunikation von IoT-Geräten abgeschlossen. In späteren Folgen werde ich noch auf Themen wie Bluetooth und NFC zu sprechen kommen, bei denen es um Kopplung von "benachbarten" Geräten bzw. um sogenannte Mesh-Networks geht.