WiFi Board: NanoESP bzw. Pretzel-Board

wifi-Pretzel-Board-Titelbild

Gleich unter mehreren Namen und über mehrere Anbieter wird ein interessantes, auf den ersten Blick recht unscheinbares Elektronik-Modul mit WLAN-Funktionalität angeboten. Beim Franzis-Verlag nennt es sich „Pretzel-Board“, bei Conrad nennt es sich „C-Control IoT WIFI Board“ und auf anderen Seiten spricht man von dem NanoESP Board.
Egal wie man es nennt oder woher man es bezieht, es ist ein interessantes kleines Controllerboard, das sich für viele Aufgaben im Haus eignen könnte.

Pretzel-Board ist Arduino kompatibel

Das WIFI Pretzel-Board, wir bleiben hier im Beitrag mal bei der Bezeichnung „NanoESP-Board“ ist kompatibel zu dem bekannten Board Arduino Nano ™, welches dem bekanntesten Board dem Arduino Uno ™ ähnelt, jedoch viel kleiner ist. Das WIFI NanoESP-Board hat ebenfalls 30 Pin´s, ist pinkompatibel und nutzt den gleichen Microcontroller Atmega328 von Atmel sowie eine USB-Schnittstelle und einen sogenannten Bootloader damit es bequem per USB-Kabel über die kostenfreie Arduino Entwicklungsumgebung programmiert werden kann.

wifi-Pretzel-Board-Arduino-Nano-Vergleich

Pinkompatibel, Arduino Nano und das Pretzel-Board

Auch die Baugröße ist in der Breite identisch mit dem Arduino Nano™, allerdings ist es eine ganze Ecke länger, denn es wurde ein komplettes WLAN-Modul vom Typ ESP8266 auf dem Board untergebracht. Und genau das ist es, was dieses Modul so interessant und vielseitig macht!

wifi-Pretzel-Board-Hand

Das Pretzel-Board (IoT Wifi Board) wird fertig aufgebaut geliefert

Volle WLAN-Funktionalität auf dem WIFI NanoESP-Board

Insider werden das WLAN-Modul ESP8266 sicher schon kennen, dieses Modul wird seit geraumer Zeit auch sehr kostengünstig als Einzelmodul angeboten. Im Internet existieren bereits zahlreiche Schaltungen, vorwiegend auch Schaltungen mit einem Arduino-Board, welche dieses Modul zu einer kostengünstigen Anbindung an ein WLAN-Netz verwenden. Das WLAN-Modul ESP8266* verfügt normalerweise über 8 Pin´s, von denen aber nur wenige für die Ansteuerung wirklich benötigt werden. Das WLAN-Modul ESP8266 wird nämlich nur über eine serielle Schnittstelle (RS232 / 3,3V) angesteuert, kann also sehr leicht an beliebige Mikrocontroller angebunden werden. Die eigentliche Ansteuerung erfolgt über einfache AT-Kommandos, wie man es in ähnlicher Form auch von Modems noch kennt. Eine Liste der wichtigsten AT-Befehle findet ihr am Ende dieses Beitrags,

wifi-wlanmodul-esp8266

WLAN-Modul ESP8266, beim Pretzel-Board integriert

Das WLAN-Modul ESP8266 nimmt dabei dem Entwickler sehr viel Arbeit ab,denn es beinhaltet einen integrierten TCP/IP-Stack und aktivierbaren TCP/UDP Server. Es unterstützt viele gängige WLAN Techniken, es kann sich nicht nur als Client in ein WLAN-Netzwerk hängen, sondern könnte auch als eigener Access-Point genutzt werden. Es besitzt sogar noch einen eigenen Mikrocontroller, der sogar ebenfalls noch programmiert werden könnte.

Dieses WLAN-Module erhält man übrigens für ein paar Euro sehr preiswert hier :

Die volle Funktionalität dieses beliebten WLAN-Modul ESP8266 Moduls wurde auf dem Pretzel-Board, alias WIFI NanoESP-Board, übernommen. Man erspart sich somit jegliche Verdrahtung. Auch die notwendige Spannungsanpassung von 5V des Arduino Nano auf 3,3V des ESP8266 Moduls wurde bereits auf dem WIFI NanoESP-Board realisiert.

Da jedoch das NanoESP-Board lediglich die Ports D12/D11  für die Kommunikation benötigt, stehen weiterhin nahezu alle anderen Ports, genauso wie beim Arduino Nano, zur freien Verfügung. In den meisten Fällen kann somit ein vorhandenes Arduino Nano Board, innerhalb einer Schaltung, problemlos durch das WIFI NanoESP-Board (Pretzel-Board) ersetzt werden. Dadurch kann man vorhandene Schaltungen ganz leicht um  WLAN-Funktionalität bereichern.

Schematischer Aufbau des NanoESP-Boards (Pretzel-Board / IoT Wifi Board))

wifi-Pretzel-Board-Verschaltung

Verschaltung des WLAN-Modules mit dem Controller (Bild Urfassung von Fabian Kainka)

Schaltbild des Arduino Nano

SchaltBildArduinoNano

Schaltbild der Arduino Nano Entwickler (siehe auch unsere Download)

wifi-Pretzel-Board-Pinbelegung

 

Programmierung des WIFI NanoESP-Boards genauso wie bei Arduino Nano-Board

Die Programmierung des WIFI NanoESP-Boards unterscheidet sich eigentlich nicht von der Programmierung eines normalen Arduino Nano-Boards oder eines Arduino Uno. Natürlich kann auch hier die normale aktuelle Arduino-Entwicklungsumgebung von der Arduino Seite heruntergeladen werden. In den meisten Fällen muss dann lediglich in der Arduino Entwicklungsumgebung der Arduino Nano als Zielboard und der entsprechende COM-Port ausgewählt werden. Einen speziellen Treiber brauchten wir im Test nicht mehr unter Windows 10 installieren, es lief alles auf Anhieb. In manchen Fällen kann jedoch ein USB-Treiber erforderlich sein, einen entsprechenden Link zu den Treibern listen wir unten unter den Downloads in diesem Beitrag auf. Der Einstieg ist also nicht schwieriger als bei anderen Arduino Boards auch.

Pretzel-Board sagt „Hallo Welt“

Hier mal ein einfaches „Hello World“ Programm, das im seriellen Monitor im Sekundentakt „Hallo Welt“ ausgibt.

/*
Software Serial Examples.
No change necessary.
 */
#include <SoftwareSerial.h>

SoftwareSerial esp8266(11, 12);

void setup()
{
 Serial.begin(19200);
 esp8266.begin(19200);
 esp8266.println("AT");
}

void loop() // run over and over
{
 Serial.write("Hallo Welt\n");
 delay(1000);
}

Entfernung mit Ultraschallsensor SRF02  messen

Auch Sensoren lassen sich wie üblich anschließen und nutzen. Hier mal ein Beispiel mit einem SRF02 Ultraschallsensor. Das Programm misst im Sekundentakt die Entfernung und gibt diese über das serielle Monitorfenster in der IDE aus. Der Sensor wird dabei über die den I2C Bus abgefragt.

WIFI-Pretzel-board-Entfernung-messen-arduino-ide

/*
 PretzelBoard-SRF02 
 Beispiel für PretzelBoard - Arduino Board mit WLAN
 Das Pretzel-Board ist identisch mit dem "IoT Wifi Board" von Conrad
 Beschreibung des Boards udn Beispiels auf der Webseite:
 (c) http://www.mikrocontroller-elektronik.de/
 Aufgabe:
 Entfernung Messen und auf seriellen Schnittstelle im Sekundentakt in cm ausgeben
 */
 
#include <Wire.h> 
#include <SoftwareSerial.h>

#define SRF_ADDRESS 0x70 // Standard Addresse des Ultraschallsensor SRF02 (7 Bit)
#define CMD (byte)0x00 
#define RANGEBYTE 0x02 

byte highByte = 0x00; // Variable für i2c Entfernungsabfrage
byte lowByte = 0x00; // Variable für i2c Entfernungsabfrage

SoftwareSerial esp8266(11, 12);

void setup()
{
 Wire.begin(); //i2C initialisieren
 delay(100); 
 int softRev = getSRF02Version(); 
 
 // Open serial communications and wait for port to open:
 Serial.begin(19200);
 // set the data rate for the SoftwareSerial port
 esp8266.begin(19200);
 
 //send first AT Command to see if ESP8266-Module responds
 esp8266.println("AT");

 Serial.write("PretzelBoard Beispiel von http://www.mikrocontroller-elektronik.de\n");
 Serial.write("SRF02 Firmware Version:");
 Serial.print(softRev, DEC) ;
 Serial.write("\n");
}

void loop() // Arduino Hauptschleife
{
 int entfernung = getSRF02Entfernung(); //Software Version des Sensors SRF02 abfragen
 Serial.write("Entfernung:");
 Serial.print(entfernung, DEC) ;
 Serial.write(" cm\n");
 
 delay(1000); //1 Sekunde warten
}


int getSRF02Version(){ // Firmware Version des SRF02 auslesen
 
 Wire.beginTransmission(SRF_ADDRESS); 
 Wire.write(CMD); 
 Wire.endTransmission();
 
 Wire.requestFrom(SRF_ADDRESS, 1); 
 while(Wire.available() < 0); 
 int software = Wire.read(); 
 
 return(software); 
 
}

int getSRF02Entfernung(){ // Entfernung in cm messen
 
 int range = 0; 
 
 Wire.beginTransmission(SRF_ADDRESS); 
 Wire.write(CMD); // Sende Befehl
 Wire.write(0x51); // Starte Messung
 Wire.endTransmission();
 
 delay(100); // Warte etwas, bis Messung abgeschlossen
 
 Wire.beginTransmission(SRF_ADDRESS); // Lese Entfernung aus
 Wire.write(RANGEBYTE); 
 Wire.endTransmission();
 
 Wire.requestFrom(SRF_ADDRESS, 2); 
 while(Wire.available() < 2); 
 highByte = Wire.read(); 
 lowByte = Wire.read(); 

 range = (highByte << 8) + lowByte; 
 
 return(range); 
}

 

Was kann man mit dem WIFI NanoESP-Board machen?

Zunächst einmal ist das WIFI NanoESP-Board praktisch, da es sehr einfach auf ein Experimentierbrett (Breadboard*) aufgesteckt werden kann. Somit lassen sich sehr leicht Bauteile hinzufügen und verschalten. Es eignet sich also ideal für den Einstieg und Experimente, die heute unter dem Schlagwort „Internet der Dinge“ betitelt werden. Es lässt sich aber genauso gut auf eine vorhandene Platine integrieren. Für unseren Test verwendeten wir einfach einen 40 poligen IC-Sockel, den wir auf eine kleinen Lochrasterplatine gelötet haben. Auf diese Weise muss man nichts an dem Modul selbst löten und man kann es jederzeit einfach wieder herausziehen und für andere Experimente nutzen.

Die Anwendungsgebiete sind enorm vielseitig. Da heute ja fast in jedem Haushalt ein WLAN-Netz vorhanden ist, kann das Modul praktisch mit jeden anderen Teilnehmer beliebig kommunizieren. Auch eine Kommunikation zwischen den Modulen ist natürlich leicht programmierbar. Aber nicht nur das, natürlich kann das Modul auch nach außen einen Internet Verbindung aufbauen, es kann beispielsweise Informationen von Webseiten abrufen oder auch auf anderen Webseiten hinterlassen.
Man könnte beispielsweise sehr leicht eine Webseite realisieren über die verschiedene Zimmertemperaturen, Luftfeuchte und andere Daten des Hauses übersichtlich und aktuell dargestellt werden. Das WIFI NanoESP-Board würde dann in den einzelnen Zimmern praktisch nur um einen Sensor erweitert und würde dann in beliebigen zeitlichen Abständen die Informationen, z.B. per URL an die Webseite übertragen.
Natürlich könnte es automatisiert bestimmte Informationen per Twitter posten oder Wetterinformationen abrufen, also hier sind der Fantasie kaum Grenzen gesetzt. Da das Modul recht günstig ist, kann es ohne Probleme vielfach im Haus oder Garten eingesetzt werden ohne den Geldbeutel zu sprengen.

Das WIFI NanoESP-Board kann aber auch selbst als Server fungieren und eine Webseite bereitstellen. Der Entwickler Fabian Kainka stellt dafür übrigens eine Arduino-Libary zur Verfügung, die den Programmieraufwand nochmals stark reduziert (siehe Downloads).

 

Technische Daten des Pretzel-Board (IoT Wifi Board)

BezeichnungPretzel-Board
NanoESP-Board
C-Control IoT WIFI Board
Preis ca.29 Euro
MikrocontrollerAtmel ATmega 328 (wie Arduino Uno oder Arduino Nano)
Flash Speicher32 KB (0,5 wird vom Bootloader benötigt)
EEPROM1K
Taktrate16 Mhz
I/O Pinsinsgesamt 20 Ports (zwei davon werden auch für WIFI-Modul genutzt)
darunter 6 PWM Ports
darunter 6 analoge Ports
USB-ChipCH340G
Logikspannung5V
Betriebsspannung 7 bis 12V
Belastung per I/O Pin40mA
Belastbarer 3,3V Ausgang50 mA
WLAN-Modul
ChipESP8266
Logikspannung3,3V
WLAN Standards802.11 b/g/n
WLAN-ModisWi-Fi Direct (P2P), Soft-AP
FirmwareAT Firmware Version 0.22
Besonderheiten WLAN ModulIntegrierten TCP/IP Stack, Output Power +19,5 dBm im 8.02.11b Mode,
Integrierter 32 Bit Mikrocontroller , Kommunikation über UART

Aktueller Preisvergleich Pretzel-Board

(IoT Wifi Board)

Pretzel-Board / C-Control IoT WIFI Board
Total*: 23,90 EUR Versand*: n.a. s. Shop
Preis kann jetzt höher sein.
Total*: 23,90 EUR Versand*: n.a. s. Shop Preis kann jetzt höher sein.
Total*: 24,37 EUR Versand*: n.a. s. Shop
Preis kann jetzt höher sein.
Total*: 24,37 EUR Versand*: n.a. s. Shop Preis kann jetzt höher sein.
Total*: 28,94 EUR Versand*: 5,95 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 28,94 EUR Versand*: 5,95 EUR s. Shop Preis kann jetzt höher sein.
Total*: 27,94 EUR Versand*: 4,95 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 27,94 EUR Versand*: 4,95 EUR s. Shop Preis kann jetzt höher sein.
Total*: 28,59 EUR Versand*: 5,60 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 28,59 EUR Versand*: 5,60 EUR s. Shop Preis kann jetzt höher sein.
Total*: 29,95 EUR Versand*: 0,00 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 29,95 EUR Versand*: 0,00 EUR s. Shop Preis kann jetzt höher sein.
Total*: 35,90 EUR Versand*: 5,95 EUR sofort versandfertig
Preis kann jetzt höher sein.
Total*: 35,90 EUR Versand*: 5,95 EUR sofort versandfertig Preis kann jetzt höher sein.
Abruf der Informationen: 03.12.2016 22:58:28. Hinweise zu Preisangaben -klick hier-

Alle hier im Preisvergleich enthaltenen Artikel werden durch Webservices bzw. Online-Schnittstellen unserer Partnerunternehmen bereitgestellt. Es ist möglich, dass angegebene Preis- bzw. Versandkosten seit der letzten Aktualisierung gestiegen sind. Maßgeblich für den Verkauf im angegebenen Shop sind nicht die hier angezeigten Preise und Versandkosten, sondern die zum Zeitpunkt des Kaufs auf der Webseite des Anbieters (Verkäufers) angegebenen Preise und Versandkosten.
* Versandkosten Die auf dieser Webseite angezeigten Versandkosten entsprechen den Informationen, welche durch einen berechtigten Vertreter (Webservices/Online-Schnittstellen) des jeweiligen Shopinhabers an uns übermittelt werden. Erhalten wir keine Informationen über die Höhe und die Bedingungen des Versandes, zeigen wir hierzu keine Informationen an. Genaue Informationen müssen in jedem Fall durch den Kunden auf dem Internetangebot des Shopinhabers/Verkäufers in Erfahrung gebracht werden.
* Amazon.de Versandkosten Amazon liefert in der Regel ab einem Bestellwert von 30,00 EUR versandkostenfrei. Bei Marketplace Artikeln und gebrauchten Artikeln kommen mindestens 3,00 Euro Versandkosten hinzu. Es können Ausnahmen existieren. Alle Angaben innerhalb dieses Preisvergleichs sind ohne Gewähr. Alle genanten Preise und Versandkosten beinhalten die gesetzliche Mehrwertsteuer (Mwst. inkl.). Marken und Produktnamen sind Warenzeichen der jeweiligen Eigentümer.
* Bei den Links handelt es sich um Affiliate-Links / Fotos stammen aus dem jeweiligen Partnerprogramm.

Pretzel-Board ermittelt Tankinhalt

Um zu demonstrieren wie einfach das Pretzel-Board* alias WIFI NanoESP-Board genutzt werden kann, habe ich mir eine halbwegs sinnvolle Aufgabe für das Modul ausgedacht. Das Modul soll den aktuellen Wasserinhalt (Liter) in einem Regenwassertank als Information bereitstellen.
Nun im Handel werden schon unzählige Geräte angeboten die dies natürlich auch könnten, aber die wenigsten liefern die Information bequem ins Wohnzimmer! Zudem sind viele Eigenbaulösungen in diesem Bereich nicht alltagstauglich, da das aggressive Regenwasser auf Dauer viele Fühler zerstört (eigene Erfahrung).

Ich habe mich daher entschieden einfach einen Ultraschall-Sensor zur Wasserstandsmessung zu nutzen. Der große Vorteil ist, er muss lediglich oben am Tank, am einfachsten an einem Deckel, angebracht werden. Der Sensor hat somit keinen direkten Kontakt zum Wasser.
Er misst den Abstand zwischen Wasseroberfläche und Tankoberkante. Aufgrund der Tankform und des maximalen Volumens kann man mit Hilfe der Wasserstandshöhe natürlich dann ganz einfach den Tankinhalt berechnen. Und genau das macht das Programm.
Aufgrund der hohen Luftfeuchte sollte man dennoch zu einem wasserdichten Ultraschallsensor greifen, damit eine lange Lebensdauer garantiert ist. Für mein Beispiel hatte ich leider keinen wasserdichten Sensor zur Verfügung, daher nahm ich einen rumliegenden SRF02 der per I2C-Bus angesteuert werden kann. Bei einem anderen Sensor müsste das Programm natürlich leicht angepasst werden (siehe auch Beitrag Ultraschallsensor HC-SR04).

wifi-Pretzel-Board-ultraschall-srf02-2

Experimentierschaltung um Tankinhalt zu messen und auf einer Webseite bereitzustellen

wifi-Pretzel-Board-arduino-screen

Das zugehörige Programm in der Arduino IDE

Da ich auch nicht extra für das Beispiel eine Internet-Seite anlegen wollte, habe ich das WIFI NanoESP-Board so programmiert, dass es als TCP-Server arbeitet und eine eigene Webseite mit dem Tankinhalt bereitstellt. Es muss also lediglich in einem beliebigen Browser die IP des jeweiligen WIFI NanoESP-Boards eingegeben werden. Egal ob man das am Smartphone, Tablet oder PC macht, jedesmal erscheint dann die Webseite mit dem aktuellen Tankinhalt!

Diese Webseite stellt das Modul selbst zur Verfügung

Diese Webseite stellt das Modul selbst zur Verfügung, stets mit aktuellem Tankinhalt

Und was braucht man nun alles dafür: Eigentlich nur das Pretzel-Board * alias WIFI NanoESP-Board, zwei 4,7k Widerstände für I2C-Bus und ein SRF02-Ultraschallsensor *. Und natürlich eine Spannungsquelle, z.B. 9V Batterie oder Netzteil*. Das war´s!

Ihr seht, das Modul hat es in sich. Mit sehr wenig Aufwand lassen sich wirklich brauchbare Dinge realisieren. Man könnte sogar auf ein vorhandenes WLAN-Netz verzichten, denn das Modul ist sogar in der Lage als Access-Point ein eigenes WLAN-Netz aufzuspannen.

 

Beispielprogramm für Füllstand-Messung in einem Tank

Um das Beispiel zu nutzen muss ein SRF02 Ultraschallsensor an das Pretzel-Board angeschlossen werden. Es muss nur 5V, GND und SDA und SCL verbunden werden. SDA und SCL müssen zusätzlich noch mit zwei Widerständen (ca. 4,7k) auf 5V gezogen werden. Nachdem man das Programm per USB auf das Board übertragen hat, wird über die serielle Schnittstelle die IP zurück gemeldet und im seriellen Monitor der IDE angezeigt. Wenn man diese IP im Browser eingibt, bekommt man immer den aktuellen Füllstand angezeigt, Das gesamte Volumen und die Tankhöhe muss natürlich individuell noch im Code angepasst werden. nachfolgend der Code des Arduino-Beispielprogrammes für das Pretzel-Board. Das Programm nutzt keine Lib, der Code würde noch wesentlich kleiner wenn man die NanoESP-Lib nutzt (siehe Downloads).

/*
 PretzelBoard-SRF02-Server
 Beispiel für PretzelBoard - Arduino Board mit WLAN
 Beschreibung des Boards und Beispiels auf der Webseite:
 
Home
Aufgabe: Entfernung einer Flüssigkeit messen und daraus Tankinhalt berechnen und auf einer Webseite anzeigen */ #define SSID "ssid" #define PASSWORD "wlanpasswort" #define LED 9 #define LED_WLAN 13 #define DEBUG true #include <Wire.h> #include <SoftwareSerial.h> #define TANKINHALT 4500 #define TANKHOEHE 155 #define SRF_ADDRESS 0x70 // Standard Addresse des Ultraschallsensor SRF02 (7 Bit) #define CMD (byte)0x00 #define RANGEBYTE 0x02 const char site[] PROGMEM = {"<HTML><BODY><center><table style=\"font-size:24px;padding:5px;border-style:solid;border-width:3px;border-color:red;background-color:#3e3e3e;color:white;\"> <tr> <th style=\"color:yellow;\" colspan=\"2\">REGENWASSERTANK KELLER</th> </tr> <tr> <td >INHALT (Liter):</td> <td >[xxx]</td> </tr> <tr> <td style=\"font-size:11px;padding:10px\" colspan=\"2\">Die gemessene Entfernung betrug [ENTFERNUNG] cm</td> </tr></table></center>"}; byte highByte = 0x00; // Variable für i2c Entfernungsabfrage byte lowByte = 0x00; // Variable für i2c Entfernungsabfrage SoftwareSerial esp8266(11, 12); // RX, TX void setup() { Serial.begin(19200); esp8266.begin(19200); pinMode(LED, OUTPUT); if (!espConfig()) serialDebug(); else digitalWrite(LED_WLAN, HIGH); if (configTCPServer()) debug("Server Aktiv"); else debug("Server Error"); Wire.begin(); //i2C initialisieren delay(100); int softRev = getSRF02Version(); Serial.write("PretzelBoard Beispiel von http://www.mikrocontroller-elektronik.de\n"); Serial.write("SRF02 Firmware Version:"); Serial.print(softRev, DEC) ; Serial.write("\n"); } void loop() { String xBuffer; if (esp8266.available()) // check if the esp is sending a message { if (esp8266.find("+IPD,")) { debug("Incomming Request"); int connectionId = esp8266.parseInt(); if (sendWebsite(connectionId, createWebsite())) debug("Website send OK"); else debug("Website send Error"); } } } boolean sendWebsite(int connectionId, String webpage) { boolean success = true; if (sendCom("AT+CIPSEND=" + String(connectionId) + "," + String(webpage.length()), ">")) { esp8266.print(webpage); esp8266.find("SEND OK"); success &= sendCom("AT+CIPCLOSE=" + String(connectionId), "OK"); } else { success = false; } return success; } String createWebsite() { String xBuffer; for (int i = 0; i <= sizeof(site); i++) { char myChar = pgm_read_byte_near(site + i); xBuffer += myChar; } int entfernung = getSRF02Entfernung(); //Software Version des Sensors SRF02 abfragen int fuellstand=TANKHOEHE -entfernung; //Wir brauchen ja Füllstand vom Boden gemessen long zw=(long) TANKINHALT * fuellstand; int inhalt=(int)(zw / TANKHOEHE); xBuffer.replace("[xxx]", String(inhalt)); xBuffer.replace("[ENTFERNUNG]", String(entfernung)); return xBuffer; } //-----------------------------------------Config ESP8266------------------------------------ boolean espConfig() { boolean success = true; esp8266.setTimeout(5000); success &= sendCom("AT+RST", "ready"); esp8266.setTimeout(1000); if (configStation(SSID, PASSWORD)) { success &= true; debug("WLAN Connected"); debug("My IP is:"); debug(sendCom("AT+CIFSR")); } else { success &= false; } //shorter Timeout for faster wrong UPD-Comands handling success &= sendCom("AT+CIPMODE=0", "OK"); success &= sendCom("AT+CIPMUX=0", "OK"); return success; } boolean configTCPServer() { boolean success = true; success &= (sendCom("AT+CIPMUX=1", "OK")); success &= (sendCom("AT+CIPSERVER=1,80", "OK")); return success; } boolean configTCPClient() { boolean success = true; success &= (sendCom("AT+CIPMUX=0", "OK")); return success; } boolean configStation(String vSSID, String vPASSWORT) { boolean success = true; success &= (sendCom("AT+CWMODE=1", "OK")); esp8266.setTimeout(20000); success &= (sendCom("AT+CWJAP=\"" + String(vSSID) + "\",\"" + String(vPASSWORT) + "\"", "OK")); esp8266.setTimeout(1000); return success; } boolean configAP() { boolean success = true; success &= (sendCom("AT+CWMODE=2", "OK")); success &= (sendCom("AT+CWSAP=\"NanoESP\",\"\",5,0", "OK")); return success; } boolean configUDP() { boolean success = true; success &= (sendCom("AT+CIPMODE=0", "OK")); success &= (sendCom("AT+CIPMUX=0", "OK")); success &= sendCom("AT+CIPSTART=\"UDP\",\"192.168.255.255\",90,91,2", "OK"); return success; } //---------------------------Controll ESP----------------------------------- boolean sendUDP(String Msg) { boolean success = true; success &= sendCom("AT+CIPSEND=" + String(Msg.length() + 2), ">"); //+",\"192.168.4.2\",90", ">"); if (success) { success &= sendCom(Msg, "OK"); } return success; } boolean sendCom(String command, char respond[]) { esp8266.println(command); if (esp8266.findUntil(respond, "ERROR")) { return true; } else { debug("ESP SEND ERROR: " + command); return false; } } String sendCom(String command) { esp8266.println(command); return esp8266.readString(); } //--------------------Debug Functions---------------------- void serialDebug() { while (true) { if (esp8266.available()) Serial.write(esp8266.read()); if (Serial.available()) esp8266.write(Serial.read()); } } void debug(String Msg) { if (DEBUG) { Serial.println(Msg); } } //-------------------SRF02 Functionen----------------------- int getSRF02Version(){ // Firmware Version des SRF02 auslesen Wire.beginTransmission(SRF_ADDRESS); Wire.write(CMD); Wire.endTransmission(); Wire.requestFrom(SRF_ADDRESS, 1); while(Wire.available() < 0); int software = Wire.read(); return(software); } int getSRF02Entfernung(){ // Entfernung in cm messen int range = 0; Wire.beginTransmission(SRF_ADDRESS); Wire.write(CMD); // Sende Befehl Wire.write(0x51); // Starte Messung Wire.endTransmission(); delay(100); // Warte etwas, bis Messung abgeschlossen Wire.beginTransmission(SRF_ADDRESS); // Lese Entfernung aus Wire.write(RANGEBYTE); Wire.endTransmission(); Wire.requestFrom(SRF_ADDRESS, 2); while(Wire.available() < 2); highByte = Wire.read(); lowByte = Wire.read(); range = (highByte << 8) + lowByte; return(range); }

 

Ein Beispielprogramm mit der Lib

Dieses Beispiel demonstriert wie man das Pretzel-Board als Server betreibt und eine Webseite bereitstellt. Durch die Lib wird der Code viel kürzer und übersichtlicher.

/*
 Pretzelboard-mit-Lib.ino
*/
#include <NanoESP.h>
#include <SoftwareSerial.h>

#define SSID "ssid"
#define PASSWORD "passwort"


#define DEBUG true

NanoESP esp8266 = NanoESP();

void setup()
{
 Serial.begin(19200);

 esp8266.init();
 esp8266.configWifi(STATION, SSID, PASSWORD);
 esp8266.startTcpServer(80);

 digitalWrite(13, HIGH);
 debug(esp8266.getIp());
}

void loop() // run over and over
{
 int clientId = esp8266.getId();
 if (clientId >= 0) {
   String webpage = "<h1>Hello World!";
   esp8266.sendDataClose(clientId, webpage);
 }
}

void debug(String Msg)
{
 if (DEBUG)
 {
   Serial.println(Msg);
 }
}

 

Schwächen des Pretzel-Board alias IoT Wifi Board

Unter dem Schlagwort Internet of Things (IoT – Internet der Dinge) wird ja derzeit ein Haufen an Kram angeboten, vieles ist meiner Meinung nicht wirklich brauchbar. Ich finde dieses Pretzel-Board gehört zu den wenigen interessanten Schaltungen die bisher in dem Bereich angeboten werden und sich auch gut für Elektronik-Bastler und Einsteiger eignen.

Energiebedarf für langen Batteriebetrieb zu hoch

wifi-Pretzel-Board-StrombedarfNatürlich kann ein Raspberry Pi das auch alles , er ist aber für viele Anwendungen einfach überdimensioniert, zu teuer und benötigt viel zu viel Strom. Und hier sind wir leider auch beim Knackpunkt des WIFI NanoESP-Boards. Natürlich benötigt es nur ein Bruchteil des Stromes, den z.B. ein Raspberry Pi benötigen würde, dennoch kommt es bei einer laufenden Internetverbindung noch auf ca. 100 bis 150 mA. Und selbst wenn zeitweise das WLAN-Modul deaktiviert wird, so sind immer noch LEDs vorhanden die einige mA Strom verbraten. Ein wirklich langer Batteriebetrieb ist so leider nicht möglich, dazu müsste man den Strombedarf in den Mikroampere-Bereich verlegen können.
Das ist wirklich schade, bei der Entwicklung des Pretzel-Boards wurde einfach nicht an ein energiesparendes Design gedacht, dabei wäre das sehr leicht realisierbar gewesen. Es hätte schon gereicht wenn die LEDs und vielleicht der Spannungswandler abschaltbar gemacht worden wäre, in den meisten Fällen wird man die LEDs nach der Erprobung der Schaltung sowieso nicht mehr brauchen.
Die unnötig hohe Energieverschwendung ist übrigens ein Nachteil der sich durch die ganze Arduino-Familie zieht. Es wären so leicht Schaltungen zu realisieren die sich Monate oder sogar Jahre mit einer Batterie versorgen lassen wenn man nur ein wenig darauf achten würde!
Aber gerade im Falle des Pretzel-Board alias WIFI NanoESP-Board, reduziert man den Anwendungsbereich dadurch erheblich. Wir können also nur hoffen, dass der Entwickler bei der nächsten Version auch darauf ein Auge hat.. Ich stelle mir ein Board ähnlich wie unser Board RN-MikroFunk vor, also ein Board mit langer Batterielaufzeit, nur statt Funkmodul halt mit WLAN-Modul.. Das Pretzel-Board alias WIFI NanoESP-Board ist auf jeden Fall schon nahe dran. Dennoch ist es natürlich auch jetzt schon für viele Bereiche einsetzbar, wenn halt keine lange Batterielaufzeit notwendig ist.

Dokumentation noch etwas dürftig

Ein weiterer Schwachpunkt muss auch genannt werden, das ist die mangelnde Dokumentation. Die mitgelieferte einseitige Beschreibung ist natürlich sehr knapp. Lediglich auf der Seite des Entwicklers findet man eine Reihe der notwendigen Informationen und auch Beispielprogramme.

wifi-Pretzel-Board-Dokumentation

Lieferumfang und mitgelieferte Dokumentation (Doku von Franzis-Verlag als auch Conrad  weitgehend identisch)

Leider ist die Seite ein wenig unübersichtlich aufgebaut und die Informationen sind sehr verstreut, manches findet man nur im Forum, manches auf einzelnen Unterseiten und manches gar nicht.

So sucht man beispielsweise vergebens nach einem Schaltbild der kompletten Schaltung, man findet aber bestenfalls ein Blockschaltbild. Da das Pretzel-Board kompatibel zum Arduino Nano ist, kann man sich natürlich an dessen Schaltbild etwas orientieren. Dennoch, zu einem Board, das zum Experimentieren und Lernen einlädt, gehört einfach ein komplettes Schaltbild und eine gute zusammenhängende Dokumentation dazu. Der Trend, dass sich die Kunden alle Infos zu einem Produkt im Web zusammensuchen müssen, dem folgt auch dieses Produkt. Es bleibt zu hoffen, dass der Verlag oder Entwickler noch etwas nachlegt, vielleicht sogar ein Buch mit Anwendungsbeispielen. (Wunsch wurde inzwischen erhöht, es gibt auch ein Kit mit Buch*, siehe auch unten)
Die wichtigsten Informationen zum Board haben zumindest wir versucht hier im Beitrag zusammenzutragen und zu verlinken. Das meiste lernt man einfach, indem man sich die Beispielprogramme lädt und ausprobiert (siehe Downloads).

Wir bleiben dran und berichten wenn sich was interessantes tut!
Trotz allem hat mir das Pretzel-Board gut gefallen, das Experimentieren damit macht Spaß. 

Weitere Fotos zum Pretzel-Board

ProduktbildProduktbildProduktbildProduktbildProduktbildProduktbildProduktbildProduktbildProduktbild

* = Fotos stammen von der Amazon-API (Amazon-Partnerprogramm )/Link ist ein Affiliate-Link zu Amazon

 

Video zum WIFI Pretzel-Board

Befehlstabelle für das WLAN-Modul / AT-Befehle

Diese Befehle werden einfach in Textform über die serielle Schnittstelle vom Mikrocontroller an das WLAN-Modul gesendet um bestimmte Aufgaben zu erledigen.

Befehl                             Schreibweise
------------------------------------------------
Grundlegendes 
Test Befehl                        AT
Reset                              AT+RST
Firmware Infos                     AT+GMR
Echo An/Aus                        ATE<1/0>

WLAN Befehle 
WLAN-Modus                         AT+CWMODE=<mode>
(1 = Client, 2 = AP, 3 = Dual)
WLAN-Netzwerke suchen              AT+CWLAP
WLAN verbinden                     AT+CWJAP=“<ssid>“,“<pass>“
WLAN trennen                       AT+CWQAP
WLAN-AccesPoint Einstellungen      AT+CWSAP=“<ssid>“,“<pass>“[,<chan>,<enc>]
IP-Adresse ausgeben                AT+CIFSR
DHCP aktivieren/deaktivieren       AT+CWDHCP=<1/0>
Automatisch mit WLAN verbinden     AT+CWAUTOCONN=<1/0>
MAC-Adresse der Station ändern     AT+CIPSTAMAC=<MAC>
IP-Adresse einstellen (Station)    AT+CIPSTA=<IP>
IP-Adresse einstellen (AccesPoint) AT+CIPAP=<IP>
Starte SmartConfig                 AT+CWSTARTSMART=<typ>
Stoppe SmartConfig                 AT+CWSTOPSMART

Kommunikation 
Funktion Ping                      AT+PING=<HOST>
Mehrere Verbindungen zulassen      AT+CIPMUX=<mode>

Datenmodus
(0=Transparent, 1=Datenmodus)      AT+CIPMODE=<mode>
Struktur empfangener Daten +IPD,<id>,<len>:<data>
Verbindung aufbauen                AT+CIPSTART=“<type>“,“<address>“,<port>
Daten senden                       AT+CIPSEND=<id>,<len>
Verbdingung trennen                AT+CIPCLOSE=<id>
 
Server Befehle 
Server starten                     AT+CIPSERVER=1,<port>
Server beenden                     AT+CIPSERVER=0
Server Status & verbundene Clients AT+CIPSTATUS
Server Timeout festlegen           AT+CIPSTO=<timeout>
Verbundene Clients anzeigen        AT+CWLIF

Ausführliche Beschreibung der Befehle im Datenblatt (siehe Downloads)

Update von 14.3.16 – Maker Kit Internet of Things

Das Pretzel-Board gibt es jetzt auch als Kit

Franzis-Maker-Kit-Internet-of-Things-Handbuch

Buch zum Pretzelboard

Das Kit nennt sich „Franzis Maker Kit Internet of Things*“ und besteht aus dem eigentlichen Pretzelboard, einem zweiteiligem Steckbrett, einigen Elektronikbauteilen und einem LCD-Display. Das interessantest ist allerdings das 100 Seiten starke Handbuch. In dem Handbuch werden ca. 20 kleine Projekte mit dem WLAN-Board beschrieben und dokumentiert. Die entsprechenden Beispielprogramme habe ich oben bei den Downloads verlinkt, Sie können aber auch über die Verlagsseite heruntergeladen werden, allerdings muss man sich dort zuvor registrieren.
Das Handbuch ist wirklich sehr schön gestaltet und enthält neben Codebeispielen auch zahlreiche farbige Abbildungen die die Verdrahtung aufzeigen. Dieses Kit enthält die Dokumentation, die ich oben bei dem beschriebenen Pretzelboard als fehlend kritisiert habe, Nur schade das man für diese Dokumentation das ganze Kit kaufen muss, ich hätte mir dieses Buch zumindest als PDF schon für das einzelne Pretzelboard gewünscht.
Das Kit ist sehr gut, es eignet sich ideal für Einsteiger die mit WLAN und Sensoren experimentieren möchten, leider ist der Preis nicht ganz billig. Für Anwender die ohnehin schon Steckbrett und Bauteile Zuhause rumliegen haben, wird daher weiterhin das einzelne Steckbrett mehr Sinn machen, abe rfür neueinsteige rkann es eine interessante Sache sein.

Fotos vom Maker Kit Internet of Things

ProduktbildProduktbildProduktbildProduktbildProduktbildProduktbildProduktbildProduktbild

* = Fotos stammen von der Amazon-API (Amazon-Partnerprogramm )/Link ist ein Affiliate-Link zu Amazon

Maker Kit Internet of Things mit dem Pretzel-Baord
Total*: 50,00 EUR Versand*: n.a. s. Shop
Preis kann jetzt höher sein.
Total*: 50,00 EUR Versand*: n.a. s. Shop Preis kann jetzt höher sein.
Total*: 85,90 EUR Versand*: 5,95 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 85,90 EUR Versand*: 5,95 EUR s. Shop Preis kann jetzt höher sein.
Total*: 79,00 EUR Versand*: 4,95 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 79,00 EUR Versand*: 4,95 EUR s. Shop Preis kann jetzt höher sein.
Total*: 79,95 EUR Versand*: 0,00 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 79,95 EUR Versand*: 0,00 EUR s. Shop Preis kann jetzt höher sein.
Total*: 85,55 EUR Versand*: 5,60 EUR s. Shop
Preis kann jetzt höher sein.
Total*: 85,55 EUR Versand*: 5,60 EUR s. Shop Preis kann jetzt höher sein.
Total*: 85,90 EUR Versand*: 5,95 EUR sofort versandfertig
Preis kann jetzt höher sein.
Total*: 85,90 EUR Versand*: 5,95 EUR sofort versandfertig Preis kann jetzt höher sein.
Abruf der Informationen: 03.12.2016 22:58:25. Hinweise zu Preisangaben -klick hier-

Alle hier im Preisvergleich enthaltenen Artikel werden durch Webservices bzw. Online-Schnittstellen unserer Partnerunternehmen bereitgestellt. Es ist möglich, dass angegebene Preis- bzw. Versandkosten seit der letzten Aktualisierung gestiegen sind. Maßgeblich für den Verkauf im angegebenen Shop sind nicht die hier angezeigten Preise und Versandkosten, sondern die zum Zeitpunkt des Kaufs auf der Webseite des Anbieters (Verkäufers) angegebenen Preise und Versandkosten.
* Versandkosten Die auf dieser Webseite angezeigten Versandkosten entsprechen den Informationen, welche durch einen berechtigten Vertreter (Webservices/Online-Schnittstellen) des jeweiligen Shopinhabers an uns übermittelt werden. Erhalten wir keine Informationen über die Höhe und die Bedingungen des Versandes, zeigen wir hierzu keine Informationen an. Genaue Informationen müssen in jedem Fall durch den Kunden auf dem Internetangebot des Shopinhabers/Verkäufers in Erfahrung gebracht werden.
* Amazon.de Versandkosten Amazon liefert in der Regel ab einem Bestellwert von 30,00 EUR versandkostenfrei. Bei Marketplace Artikeln und gebrauchten Artikeln kommen mindestens 3,00 Euro Versandkosten hinzu. Es können Ausnahmen existieren. Alle Angaben innerhalb dieses Preisvergleichs sind ohne Gewähr. Alle genanten Preise und Versandkosten beinhalten die gesetzliche Mehrwertsteuer (Mwst. inkl.). Marken und Produktnamen sind Warenzeichen der jeweiligen Eigentümer.
* Bei den Links handelt es sich um Affiliate-Links / Fotos stammen aus dem jeweiligen Partnerprogramm.

 

Nützliche Bücher zum Thema

Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer
EUR 39,80
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>
Das ESP8266-Projektbuch. Heimautomation mit dem WLAN-Chip
EUR 24,90
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>
Arduino: Elektronik, Programmierung, Basteln
EUR 29,90
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>
Die elektronische Welt mit Arduino entdecken
EUR 39,90
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>
Arduino-Workshops: Eine praktische Einführung mit 65 Projekten
EUR 29,90
Der Arduino ist eine preiswerte und flexible Open-Source-Mikrocontroller-Plattform, die entwickelt wurde, um Bastlern einfache Elektronikprojekte zu ermöglichen. Mit einer nahezu unbegrenzten Palette von Erweiterungselementen für die Ein- und Ausgänge - wie Sensoren,...
Gewöhnlich versandfertig in 24 Stunden
Mehr Infos* >>  |  zum Shop* >>

* = Fotos stammen von der Amazon-API (Amazon-Partnerprogramm )/Link ist ein Affiliate-Link zu Amazon

5 Gedanken zu “WiFi Board: NanoESP bzw. Pretzel-Board

  1. radbruch

    Hallo Frank

    Danke für den umfangreichen Artikel.

    Das Design des Boards hat meiner Meinung noch einen großen Fehler: Die Verbindung zwischen Nano und ESP belegt die Ports Mosi und Miso der SPI-Schnittstelle des Nano. Wenn man trotzdem in den Genuss von schnellem Hardware-SPI kommen möchte, kann man die USART to SPI-Funktion des Mega328 nutzen:

    http://www.roboternetz.de/community/threads/68785-Suche-USART-to-SPI-Library-mit-SD-Card-Unterst%C3%BCtzung

    Gruß

    Michasp

    Antworten
  2. Martin

    Die Idee, einen ESP8266 an einen Arduino anzuflanschen kommt mir 2016 sinnlos vor: der ESP8266 läßt sich wie ein Arduino programmieren und hat ungleich mehr power, Speicher… (als ob man mit einem Schlitten ein Snowmobil zieht, nur weil das Snowmobil ein Autoradio hat). Lieber ein günstiges ESP8266-Modul, zB. das Wemos D1* mini – oder das „Witty cloud*“ (ersteres mein Favorit, letztes hat zumindest noch ne RGB-LED, Schalter und LDR an board, so dass man direkt was zu spielen hat)

    Antworten
  3. Jürgen Beckamp

    Hallo Frank, ich habe das Conrad „Internet of Things“ gekauft. Das Handbuch ist gut geschrieben.
    Das Board ging einige Tage, bis ca. zur Übung 2.5, dann ist es den Hitzetod gestorben.
    Das neue baugleiche Conrad „C-CONTROL …“ wird auch nach ca. 10 Sek. zu heiß zum anfassen. Leider kann es in der Zeit nicht mal alle WLANs auflisten, es stellte den Dienst ein.
    Der ESP wird sehr schnell heiß, dann auch der ISP und dann das 3,3V-Teil.
    Habe nur ich eine Serie erwischt, oder ist es bei einem neuem Ersatz auch zu erwarten?
    Gruß
    Jürgen

    Antworten
    • Frank Autor des Beitrags

      Es wird zwar bei mir auch warm, aber solche Probleme hatte ich bislang noch nicht. Auch nicht mit zu hoher Spannung versorgt?

      Antworten

Schreibe einen Kommentar

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

Top