WiFi Board: NanoESP bzw. Pretzel-Board

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.

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!

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,

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 :

• Amazon WLAN-Modul*
• Ebay WLAN-Modul*

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

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

Schaltbild des Arduino Nano

Schaltbild der Arduino Nano Entwickler (siehe auch unsere Download)

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.

/*
 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) https://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 https://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)

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

Experimentierschaltung um Tankinhalt zu messen und auf einer Webseite bereitzustellen

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, 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 https://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

Natü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.

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

Video zum WIFI Pretzel-Board

Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.
Mehr erfahren

Video laden

YouTube immer entsperren

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

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

[atkp_product id=’3244′ template=’3158′ itemsperpage=’25’][/atkp_product]

Nützliche Bücher zum Thema

Das ESP8266-Praxisbuch: Mit NodeMCU und ESPlorer*

Artikelname: Das ESP8266 Praxisbuch: Mit NodeMCU und ESPlorer; Produkttyp: ABIS BOOK; Farbe: Silber

29,85 EUR

Das ESP8266-Projektbuch. Heimautomation mit dem WLAN-Chip*

Martin Mohr(Autor)

68,98 EUR

Sensoren – Messen und experimentieren mit Arduino und Raspberry Pi: Messen und experimentieren mit Arduino und Raspberry Pi. In Zusammenarbeit mit c't...*

Karvinen, Tero(Autor)

29,90 EUR

Arduino: Elektronik, Programmierung, Basteln. Das Praxisbuch für den beliebten Mikrocontroller. Über 60 Workshops, kein Vorwissen nötig!*

Kappel, Benjamin(Autor)

25,90 EUR

Die elektronische Welt mit Arduino entdecken*

Bartmann, Erik(Autor)

39,95 EUR

Arduino-Workshops: Eine praktische Einführung mit 65 Projekten (c't Hardware Hacks Edition)*

ABIS_BUCH; Dpunkt.Verlag GmbH; Silber; Boxall, John(Autor)

34,90 EUR

Letzte Aktualisierung am 27.01.2025 / * Affiliate Links