Beiträge on Internet of Things mit dem NanoESP

Alles über NanoESP & Pretzel Board

Wed, 21 Aug 2019 11:06:12 +0200

Das Board

Der NanoESP-Board hat viele Namen. In Franzis Produkten wird das Board oft Pretzel Board genannt. Bei Conrad findet man den NanoESP unter dem Namen C-Control IoT WiFi Board. Doch innen ist immer das gleiche: ein einfach zu bedienendes und Arduino kompatibles Entwicklungsboard für Ihre Internet of Things Projekte.

Über einfache AT-Kommandos können Sie z.B. einen Webserver starten, das Modul als Acces Point einstellen oder die Verbindung zu Ihrem Heimnetzwerk herstellen.

Das NodeESP Board

Sat, 10 Nov 2018 13:50:13 +0100

Das NodeESP Board

Der NodeESP ist ein Experimentier- und Entwicklungsboard für den Bereich IoT und Hausautomatisierung. Die vorprogrammierte Firmware mit integrierter Webseite erlaubt es Ihnen, einfache Konfigurationen vorzunehmen und Programme und Anwendungen kinderleicht in einem Menü auszuwählen. So können Sie durch wenige Mausklicks das Board als smarten Schalter, buntes Licht oder Raumklimasensor konfigurieren und mit anderen Geräten in Ihrem Heimnetz verbinden. Für eigene individuelle Projekte lässt sich das Board außerdem über die Arduino IDE programmieren.

Der Conrad Adventskalender IoT - 2018 [Smarthome Edition]

Wed, 07 Nov 2018 14:11:10 +0100

Adventskalender Internet of Things 2018: Experimente für Smart Home

Dank des Adventskalenders Internet of Things (IoT) muss die Wartezeit bis Weihnachten nicht langweilig werden. Der bereits vorprogrammierte Mikrocontroller in Verbindung mit dem Node-RED Programmier-Tool bietet eine Menge Spielraum für 24 vielfältige und spannende Experimente rund um das Thema Smart Home und Hausautomatisierung.

Internet of Things und Smarthome beinhalten die automatisierte Erfassung und Steuerung von Sensoren und Aktoren in einem großen Netzwerk. Vom automatisierten Ein- und Ausschalten von LEDs über das Steuern Ihres TVs
von irgendwo in der Welt bis hin zur Langzeitüberwachung Ihres Raumklimas, mit einfachen Beispielen werden die verschiedenen Aspekte der Hausautomatisierung praktisch ergründet.

Die IoT Lernpakete

Wed, 20 Sep 2017 12:42:23 +0200

Sie können das Lernpaket unter anderem hier erwerben:

Direkt bei Franzis
Bei Amazon.de
Bei Elektor
Bei Conrad

Das Lernpaket Internet of Things gibt es in mehreren Ausführungen. Es gibt eine Franzis und eine Conrad Version. Beide Lernpakete bringt Ihnen das brandaktuelle Thema IoT anhand von praktischen Beispielen mit ausführlichen Erklärungen näher. Teil des Pakets ist das neue Pretzel Board (NanoESP) mit dem der Einstieg in das komplexe wie spannende Thema spielerisch gelingt.

Der Conrad Adventskalender Internet of Things

Wed, 20 Sep 2017 12:16:48 +0200

Conrad Shop

Mit dem Adventskalenders Internet of Things (IoT) muss die Wartezeit bis Weihnachten nicht angweilig werden. Das neue Arduino kompatible Pretzelboard (NanoESP) mit integriertem WLAN-Modul und die enthaltenden Bauteile sind ideal für 24 vielfältige und spannende Experimente rund um dieses Thema.

Internet of Things beinhaltet die Kommunikation und Steuerung von Sensoren und Aktoren in einem großen Netzwerk. Vom einfachen Ein- und Ausschalten einer LED mit dem Smartphone über das Erstellen eines Webservers bis hin zur Langzeitüberwachung mittels Sensoren, mit einfachen Beispielen werden die verschiedenen Aspekte des Themas IoT praktisch ergründet.

Der Conrad Adventskalender IoT - 2016

Fri, 08 Sep 2017 14:45:58 +0200

Verkürzen Sie die Wartezeit auf Weihnachten mit spannenden und unterhaltsamen Experimenten zum Internet der Dinge. Schicken Sie dabei Push-Nachrichten auf Ihr Smartphone oder bauen Sie eine Alarmanlage mit Bewegungsmelder und lassen Sie sich bei verdächtigen Bewegungen benachrichtigen. Lernen Sie, wie Sie unterschiedliche Webdienste wie z.B. Twitter ansteuern, und nutzen Sie das Protokoll für das Internet der Dinge: MQTT.

Der Internet-of-Things-Adventskalender enthält alle Bauteile für 24 Experimente, darunter eine eigens entwickelte Hardware-Platine mit integriertem WLAN-Modul, die sich über die kostenfreie Arduino IDE programmieren lässt.

User Projekte

Mon, 25 Jan 2016 18:44:05 +0100

Jetzt bist du gefragt!

In diesem Bereich hast du nun die Möglichkeit, deine Projekte, Ideen und Experimente vorzustellen.

Dabei ist es egal, ob du einem bestehenden Projekt eine neue Verpackung gibst, z.B. eine schöne Cheerlights Lampe, oder eine völlig neue Idee hast. Auf dieser Seite kannst du alle deine Projekte eigenständig präsentieren.

Besonders praktisch: Über diese Funktion kannst du außerdem auch Beitrage zu dem aktuellen Wettbewerb einreichen. Und wer weiß, ob nicht in Zukunft noch mehr Wettbewerbe stattfinden.

Treiber- NanoESP & Pretzelboard

Sun, 23 Aug 2015 10:02:42 +0200

Damit das Board an Ihrem PC funktionieren kann, benötigen Sie einen Treiber für den USB-to-Serial Wandler CH340G. Diesen können Sie die hier

Windows (ab Windows 98 bis Windows 10, 32-Bit/64-Bit)

Linux Version

Android Version

Mac Version **(**Hinweis für MAC-Nutzer: Seit Mac OS Sierra scheint es vermehrt Probleme mit dem Treiber zu geben. Es gibt noch keinen offiziellen Treiber vom USB-Chip Hersteller. Allerdings finden Sie hier zwei Links mit alternativen Versionen:
https://github.com/jimaobian/CH34x_Install_V1.3/blob/master/CH34x_Install_V1.3.zip
https://github.com/adrianmihalko/ch340g-ch34g-ch34x-mac-os-x-driver )

Download Beispielprogramme

Fri, 10 Jan 2020 12:18:27 +0100

Auf dieser Seite finden Sie alle im Lernpaket vorgestellten Programme.

Download Neuauflage: Alle Programme

GitHub Repository: https://github.com/FKainka/Lernpaket-IoT

Download Franzis Version: Alle Proramme

Download Conrad Version: Alle Programme - Conrad Version

Achtung:

Es gab eine Änderung im Programm P12_TCPWeather. Der Webservice, den ich in diesem Programm verwendet habe, hat seinen Dienst eingestellt. Ich habe nun einen eigenen Service gestartet, der seine Daten von der Webseite http://www.openweathermap.com/ bezieht. Der Link zu dem neuen und auch in der neuen Version des Programms verwendeten Dienst lautet:

Maker Kit für Smart Home

Sat, 02 Nov 2019 14:51:52 +0100

Smarthome Lernpaket

Licht, Heizung, Alarm oder Pflanzenbewässerung: Im vernetzten Heim lassen sich diese und viele weitere Systeme fernsteuern und automatisieren. Steigen Sie mit diesem Maker Kit ein in die Welt des Smart Homes und lernen Sie grundlegende Prozesse und Techniken kennen und selbst anzuwenden. Als Basis für alle Experimente dient Ihnen ein speziell dafür entwickeltes NodeESP-Board, das in diesem Maker Kit enthalten ist.

Hausautomatisierung leicht gemacht
Vom automatisierten Ein- und Ausschalten von LEDs über das Steuern Ihres TVs von irgendwo in der Welt bis hin zur Langzeitüberwachung Ihres Raumklimas ergründen Sie die verschiedenen Aspekte der Hausautomatisierung. Alle benötigten Bauteile, darunter ein speziell entwickeltes NodeESP-Board, sind in diesem Maker Kit enthalten es kann sofort losgehen!

NanoESP Updaten

Wed, 21 Aug 2019 11:01:57 +0200

Das NanoESP-Board, auch als Pretzelboard bekannt, ist nun schon vor einer ganzen Weile erschienen. Dennoch bekomme ich immer noch Mails von Leuten, die Hilfe benötigen oder Fragen haben. Zuletzt erreicht mich eine Mail mit der Frage, ob man die Firmware des ESP8266 Chips auf einen neueren Stand bringen könnte. Der für das WLAN zuständige Mikrocontroller hat eine AT-Firmware aus dem Jahre 2015 und mittlerweile gibt es verbesserte Versionen der AT-Firmware. Das Problem ist allerdings, dass der Flash-Speicher Chip, auf dem sich die Firmware zum ESP-Controller befindet, nur eine Kapazität von 4 Mbit (also 512 kB) hat und deswegen nicht mit allen neueren Firmware Versionen kompatibel ist. Dennoch habe ich nach einigem Recherchieren eine Firmwareversion gefunden, die kompatibel ist und zudem neue Möglichkeiten bereitstellt. Deswegen finden Sie hier eine Anleitung, wie Sie das Board updaten können.

Check out Blynk_Tag5 app I've made.

Fri, 28 Jun 2019 11:18:48 +0200

Hey,

I’ve made Blynk_Tag5 app. You are welcome to try it out!

To start using it:

Download Blynk App: http://j.mp/blynk_Android or http://j.mp/blynk_iOS
Touch the QR icon and point the camera to the code below or open the link below - http://tinyurl.com/hpo76l3
Enjoy my app!

Tag 24: Tannenbaumbeleuchtung

Mon, 24 Dec 2018 00:00:55 +0100

Hinter dem letzten Türchen des Adventskalenders befindet sich eine weitere programmierbare RGB-LED. Damit haben Sie jetzt zwei LEDs, die Sie zu einer kleinen Weihnachtsbaumbeleuchtung verbinden können. Dazu benötigen Sie den folgenden Aufbau.

Der Aufbau des Weihnachtsbaumlichts. Die langen Beinchen der LEDs befinden sich rechts

Aktivieren Sie dann das Programm und importieren Sie den Flow des heutigen Tages. Deaktivieren Sie alle vorangegangenen Flows und ändern Sie gegebenenfalls die Broadcast-IP des UDP-Nodes.

Tag 23: Alarmanlage

Sun, 23 Dec 2018 00:00:28 +0100

Hinter dem vorletzten Türchen des Adventskalenders befindet sich ein sogenannter Tilt-Sensor (Neigungssensor). Der Sensor erkennt, wenn er gekippt wird. Wir setzen ihn heute als Sensor für eine Alarmanlage ein. Der Lautsprecher von vor zwei Tagen dient uns dabei als Signalgeber. Dazu wird der folgende Aufbau benötigt.

Der Aufbau

Aktivieren Sie zunächst wie gewohnt das Programm des heutigen Tages und fügen Sie anschließend den Node-RED-Flow in die Umgebung ein. Passen Sie außerdem das MQTT-Topic an und deaktivieren Sie alle vorangegangenen Flows.

Tag 22: Klimawächter

Sat, 22 Dec 2018 00:00:26 +0100

Hinter dem Türchen des 22. Tages befindet sich ein neuer Sensor, der die aktuelle Luftfeuchtigkeit messen kann. Wir benutzen ihn, um einen vollständigen Raumklimawächter zu realisieren. Dazu benötigen wir die folgende Schaltung.

Die Schaltung des Raumklimawächters

Der Versuch des heutigen Tages vereint drei Sensoren: den Temperatursensor (NTC), den Lichtsensor (Fototransistor) und den Luftfeuchtesensor. Zusammen können sie einen recht guten Eindruck der aktuellen Klimalage in einem Zimmer abgeben. Dazu müssen Sie aber zunächst das Programm des heutigen Tages starten.

Tag 21: Piano-Player

Fri, 21 Dec 2018 00:00:26 +0100

Hinter dem Türchen des 21. Tages finden Sie einen Lautsprecher. In dem heutigen Versuch werden wir damit etwas Musik abspielen. Dazu benötigen wir den folgenden einfachen Aufbau.

Versuchsaufbau

In diesem Versuch ist der Lautsprecher an einem der beiden DAC-Ausgänge des Boards angeschlossen. DAC bedeutet Digital/Analog-Converter und ermöglicht es, durch digitale Befehle ein analoges Signal zu erzeugen. In dem heutigen Versuch werden wir damit Töne erzeugen, genauer gesagt Töne wie von einem Piano. Die Noten, Pausen und Tonarten werden dabei per UDP übertragen, und zwar als Array von Zahlen.

Tag 20: Pflanzenwächter

Thu, 20 Dec 2018 00:00:58 +0100

Hinter dem Türchen des heutigen Tages befindet sich ein NTC-Widerstand (Negative Temperature Coefficient) zur Messung der Temperatur. Zusammen mit dem Fototransistor und ein paar Drähten bauen wir damit einen Pflanzenwächter, der uns vor schlechten Bedingungen für eine zu überwachende Pflanze warnt. Dazu benötigen wir den folgenden Aufbau und das Programm des aktuellen Tages.

Der Pflanzenwächter

Die beiden gelben Drähte sind dabei einfache Drähte, die in die Pflanzenerde gesteckt werden können. Sie sollen überwachen, wie feucht die Erde ist. Für erste Tests reicht es aber aus, beide Drähte mit einem Finger zu berühren.

Tag 19: Cheerlights

Wed, 19 Dec 2018 00:00:35 +0100

Hinter dem Türchen des heutigen Tages befindet sich eine ganz besondere LED. Es handelt sich um eine RGB-LED mit integriertem Controller (Typenbezeichnung PL9823, vergleichbar mit WS2812). Sie ermöglicht es, mehrere LEDs hintereinanderzuschalten und über ein Protokoll einzeln anzusteuern. Heute werden wir allerdings zunächst eine LED ansteuern. Dafür kommt ein Versuch gerade recht, der schon eine gewisse Tradition in meinen Adventskalendern hat: das Cheerlights-Projekt von Hans Schaaler. Für alle diejenigen, die das Projekt nicht kennen: Es geht um weltweit vernetzte bunte Lichter, die sich simultan über Twitter-Kommandos steuern lassen. Und dazu passt Node-RED sehr gut. Für den Versuch des heutigen Tages benötigen Sie den folgenden Aufbau und das Programm des heutigen Tages.

Tag 18: Kerzenalarm

Tue, 18 Dec 2018 00:00:47 +0100

Hinter dem Türchen des heutigen Tages befindet sich eine kleine Diode. Wir werden diese Diode als Temperatursensor für besonders hohe Temperaturen nutzen. Damit ist es uns möglich, einen kleinen Kerzenwächter zu bauen.

Versuchsaufbau

Der Aufbau des heutigen Tages besteht, neben der Diode, aus einem Poti, das einfach als 10-kOhm-Widerstand herhält. Dieser Widerstand ist fix und kann auch nicht eingestellt werden. Das Board misst nun die Spannung an der Diode und überträgt die Werte über MQTT an Node-RED.

Tag 17: Zeitgesteuerte Lichter

Mon, 17 Dec 2018 00:00:17 +0100

Hinter dem Türchen des 17. Tages befindet sich ein weiteres Poti. Das bedeutet, dass nun für jede LED genau ein Poti zur Verfügung steht. Damit können wir das Programm von Tag 13, die smarten Lichter, um eine etwas praktischere und intuitivere Dimm-Funktion erweitern. Außerdem werden wir heute sehen, wie man mit Node-RED zeitgesteuerte Ereignisse startet.

Versuchsaufbau

Sie müssen das Programm des heutigen Tages in der Weboberfläche aktivieren. Anschließend können Sie den heutigen Flow in die Node-RED-Umgebung einfügen, natürlich nicht, ohne die vorherigen Flows zu deaktivieren und das MQTT-Topic an Ihre persönliche ID anzupassen.

Firmware Neuigkeiten und Bug Report

Sun, 16 Dec 2018 13:58:05 +0100

Auf dieser Seite sollen Neuigkeiten zur Firmware veröffentlicht werden. Bugs können über die Kommentarfunktion gemeldet werden.

Neusete Version: Download Link

Git Repository: https://github.com/FKainka/NodeESP_Firmware

Firmware Update 05.12.2019

Bug Hotfix: Neue SD-Library störte PULLUP-Funktion von Pin 18, Keine SD-Karte an Versuchen mit Pin 18 verwenden!

Firnware Update 04.12.2019 (Stabilitäts Update)

ESP32 Arduino Core updated (v1.11.1)
Verschiedene Libraries geupdatet
Update Vorgang verbessert (md5-Hash)
Config-Verbesert
Diverse Bug fixes

Firnware Update 17.10.2019 (Smarthome Update)

Apps für das Smarthome Lernpaket hinzugefügt
Onboard HTML-Editor zum Verändern der integrierten Webseite und Uploaden von Dateien hinzugefügt (http://nodeesp.local/editor)
Automatische SD-Karten Unterstützung hinzugefügt (SD-Karten werden automatisch unter http://nodeesp.local/sd eingebunden)
Bessere Vorabinformationen beim Auswählen von Apps über die Config-Seite
Neues Update-Verfahren direkt vom GitHub-Repository aus (https://github.com/FKainka/NodeESP_Firmware)
Bug Fixes

Firmware Update 16.12.2018 (Version 2 - Mit MQTT Fix)

Es gibt nun eine neue Version dieser Firmware, in der der MQTT-Bug behoben ist. Dieses Update kann auch über die Update-Funktion auf der Config-Seite geladen werden.

Download Link

Tag 16: Universalfernbedienung

Sun, 16 Dec 2018 00:00:40 +0100

Hinter dem Türchen des heutigen Tages befindet sich das Gegenstück zum gestrigen Bauteil, nämlich eine IR-Diode. Jetzt können Sie eine komplette Fernbedienung für den Fernseher nachbauen, die Sie per Smartphone und Webseite bequem steuern. Dazu benötigen Sie den folgenden Aufbau.

Der Aufbau der Fernbedienungen mit IR-Empfänger und Sendediode

Wählen Sie das Programm des heutigen Tages aus. Das Board startet anschließend wieder im HeadlessModus, in dem die Webseite des Boards nicht erreichbar ist. Stattdessen ist lediglich die MQTT-Funktion des Boards verfügbar. Um in den Standardmodus zu gelangen, müssen Sie die Drahtbrücke an Pin 23 entfernen und das Board neu starten.

Tag 15: Fernbedienungsempfänger

Sat, 15 Dec 2018 00:00:41 +0100

Hinter dem heutigen Türchen befindet sich ein ganz besonderes Bauteil, nämlich ein Infrarotempfangsmodul. Damit ist es möglich, handelsübliche Infrarotfernbedienungssignale zu empfangen. Dazu benötigen wir den folgenden Aufbau.

So schließen Sie das IR-Modul richtig am Board an

Nachdem Sie die Schaltung aufgebaut haben, können Sie das Programm des heutigen Tages auswählen. Die Boardwebseite können Sie dann nicht mehr erreichen, denn sie musste für den Versuch deaktiviert werden. Das Board arbeitet nun im Headless-Modus, also ohne sichtbare Oberfläche. Um wieder die Webseite starten und zum Beispiel andere Programme aktivieren zu können, müssen Sie lediglich die Drahtbrücke an Pin 23 herausziehen und das Board neu starten. Dann läuft wieder alles wie gewohnt.

Tag 14: Smarte Lichter

Fri, 14 Dec 2018 00:00:12 +0100

Hinter dem Türchen des 14. Tages befindet sich eine weitere LED. Nun haben wir zwei LEDs mit Vorwiderständen und zwei Taster sowie genug Kabel, um ein komplexes Lampensystem zu bauen. Dazu benötigen Sie den folgenden Aufbau:

Der Aufbau mit vier losen Kabeln (gelb) als Touch-Buttons

Nun können Sie das Programm des heutigen Tages aktivieren und den heutigen Flow einfügen. Vergessen Sie nicht, die [PID] durch Ihre persönliche ID zu ersetzen, am einfachsten mit dem Editortrick.

Tag 13: Smarter Schalter für ein Soundboard

Thu, 13 Dec 2018 00:00:41 +0100

Hinter dem Türchen des heutigen Tages befindet sich ein weiterer Widerstand mit 1 kOhm, der heute noch keine Rolle spielt. Stattdessen möchte ich Ihnen zeigen, wie man einen smarten Touch-Schalter baut. Dazu ist folgender Aufbau nötig, der nur aus vier lose hängenden Drähten als Touch-Buttons und einer Drahtbrücke an Pin 23 besteht.

Vier gelbe Drähte als Touch-Buttons

Die Besonderheit des heutigen Versuchs besteht vor allem im Programm selbst, das Sie an dieser Stelle über die Konfigurationsseite aktivieren können. Nach dem Aktivieren werden Sie feststellen, dass die Status-LED kurz blinkt und dann erlischt. Das liegt daran, dass das Board wieder im stromsparenden Deep-Sleep-Modus betrieben wird. Aufgeweckt wird es aber nicht nach einer gewissen Zeit, sondern erst, wenn Sie einen der Touch-Buttons berühren. Das Board sendet dann Infos über den Touch-Button zum Broker, der das Aufwecken ausgelöst hat. Das sieht dann z. B. so aus:

Tag 12: MQTT-Button

Wed, 12 Dec 2018 00:00:34 +0100

Hinter dem heutigen Türchen des Adventskalenders finden Sie einen weiteren Button. In dem Versuch des heutigen Tages werden wir uns weiter mit dem MQTT-Protokoll beschäftigen, diesmal in Verbindung mit Node-RED. Außerdem sehen wir, wie zwei Buttons gleichzeitig ausgewertet werden können. Der Versuch des heutigen Tages hat folgenden Aufbau:

Der Aufbau mit zwei Buttons

Es gibt also zwei Buttons, die wir nutzen können. Aktivieren Sie nun das Programm des heutigen Tages. Anschließend können Sie den Node-RED-Flow importieren. Diesen müssen Sie zunächst aber leicht anpassen. Sie müssen nämlich [PID] im Topic durch Ihre persönliche MQTT-ID ersetzen. Das geht aber ganz einfach mit dem folgenden Trick:

Tag 11: MQTT

Tue, 11 Dec 2018 00:00:22 +0100

Hinter dem heutigen Türchen finden Sie wieder einen Satz Kabel, die wir für die nächsten Tage und die komplexer werdenden Aufbauten benötigen werden.

In den letzten Tagen haben wir die meisten unserer Daten mittels UDP übertragen. Dieses Protokoll ist sehr praktisch, da es einerseits einen kleinen Overhead (Daten, die neben den eigentlichen Nutzdaten übermittelt werden) hat und andererseits Broadcast-fähig ist und somit gleich an mehrere Geräte gleichzeitig Daten senden kann. Heute wollen wir aber noch ein zweites Protokoll näher kennenlernen, das im Bereich IoT eine große Rolle spielt. Es geht um das Nachrichtenprotokoll MQTT (Message Queue Telemetry Transport), das speziell für die Kommunikation von Maschine zu Maschine (M2M) entwickelt wurde. Der Grund dafür, dass dieses Protokoll so genial ist, liegt in der Kompaktheit und Einfachheit, mit der Daten wie Steuerdaten, Messdaten oder Texte zwischen Geräten ausgetauscht werden können. Im Vergleich zu HTTP ist der Overhead sehr klein. Deswegen können auch Embeded Devices, also Mikrocontroller wie unser NodeESP, die Daten gut verarbeiten.

Tag 10: Deep Sleep

Mon, 10 Dec 2018 00:00:59 +0100

Hinter dem heutigen Türchen finden Sie ein Batteriefach für drei A-Batterien (4,5 V), um das Board unabhängig von einer Steckdose betreiben zu können. Für einen sparsamen Batteriebetrieb gibt es den DeepSleep-Modus. Dieser erlaubt es dem Board, in einen Tiefschlafmodus zu wechseln und so gut wie gar keinen Strom zu verbrauchen. Nach einer gewissen Zeit weckt sich das Board selbst auf und erfüllt eine kleine Aufgabe, um kurz danach wieder schlafen zu gehen. Durch die langen Schlaf- und kurzen Wachzeiten spart dieser Modus viel Energie und kann das Board so über Monate über die Batterien versorgen. Der Aufbau von heute verwendet wieder den Lichtsensor und bekommt zusätzlich eine Drahtbrücke von Pin 23 nach GND.

Tag 9: Ein Stimmungslicht

Sun, 09 Dec 2018 00:00:33 +0100

Hinter dem heutigen Türchen finden Sie einen Fototransistor. Er wird verwendet, um die Umgebungshelligkeit zu messen. In dieser Schaltung liegt das Poti in Reihe zum Fototransistor. So kann man mit dem Poti die Sensibilität des Sensors verändern. Die Schaltung bewirkt, dass das Abdunkeln des Sensors den Messwert erhöht.

Versuchsaufbau

Dies können Sie im Gauge-Element auf dem Nutzerinterface zum heutigen Tag sehen. Dazu müssen Sie aber zunächst den Flow des heutigen Tages in Ihre Node-RED-Umgebung importieren und starten, natürlich nicht, ohne den gestrigen zu deaktivieren. Vergessen Sie auch nicht, das heutige Programm auf der Konfigurationsseite zu aktvieren und die IP des UDP-Sende-Nodes anzupassen.

Tag 8: Ein Regler

Sat, 08 Dec 2018 00:00:21 +0100

Versuchsaufbau

Hinter dem achten Türchen des Adventskalenders befindet sich ein Potenziometer, das hier als Spannungsteiler verwendet wird. Sie können eine Spannung zwischen 0 V und 3,3 V einstellen, die vom Board gemessen und an Node-RED übertragen wird. Zusätzlich zu dem Treppenhauslicht von gestern können Sie so auch Messwerte übertragen.

Der Flow des heutigen Tages

Externer Inhalt von pastebin.com
Beim Laden werden Daten wie Ihre IP-Adresse an pastebin.com übertragen. Datenschutz

direkt öffnen ↗

Den Flow von heute bekommen Sie wie gewohnt in dem Pastebin Frame. Vergessen Sie nicht, den gestrigen zu deaktivieren und eventuell die Sende-IP anzupassen. In dem heutigen Flow wird außerdem ein neuer Node für das Dashboard verwendet, nämlich ein Gauge (Messgerät), über das der gemessene Wert visuell dargestellt wird.

Tag 7: Treppenhauslicht

Fri, 07 Dec 2018 00:00:03 +0100

Hinter dem heutigen Türchen befindet sich eine rote LED. Damit wollen wir nun ein einfaches Treppenhauslicht mit Webinterface realisieren. Dazu müssen Sie die folgende Schaltung aufbauen und das heutige Programm aktivieren.

Versuchsaufbau (Kurzes Beinchen der LED ist oben)

Den Node-RED-Flow zum Importieren finden Sie in dem unteren Pastebin Frame. Deaktivieren Sie nach dem Importieren den Flow von gestern, damit sich die UDP-Empfangs-Nodes nicht in die Quere kommen. Im Flow selbst finden Sie diesmal neben dem Empfangsnode einen Sende-Node. Diesen müssen Sie wahrscheinlich an Ihre Broadcast-IP anpassen. Wenn am UDP-Note eine Nachricht ankommt, wird sie wieder von einem JSON-String, also reinem Text, in ein JSON-Objekt konvertiert. Der Unterschied ist, dass man nun direkt auf einzelne Attribute zugreifen kann.

Tag 6: Touch to Speach

Thu, 06 Dec 2018 00:00:26 +0100

Hinter dem sechsten Türchen des Adventskalenders finden Sie einen Widerstand mit 1 kOhm, der erst morgen zum Einsatz kommt. Heute wollen wir uns weiter mit Node-RED beschäftigen und die Touch-Funktion des Boards ausprobieren. Dazu müssen Sie wie gewohnt das Programm des heutigen Tages auswählen und außerdem die folgende Schaltung aufbauen. Die gelben Drähte sind die Verbindungsdrähte mit einem freien Ende und fungieren als Touch-Sensoren.

Versuchsaufbau: Drei Drähte hängen an einem Ende in der Luft

Nach dem Aufbau können Sie Node-RED wieder über das Terminal und den Befehl node-red starten. Öffnen Sie dann über die Adresse http://127.0.0.1:1880/ den Node-RED-Editor. Als Erstes werden wir heute ein paar Nodes nachinstallieren. Dazu klicken Sie am rechten oberen Rand auf die drei Striche. Sie finden dann den Punkt manage palette. Hier sind alle installierten Nodes aufgelistet. Wenn Sie nun das Install-Register auswählen, sehen Sie eine riesige Anzahl unterschiedlicher Module, die Sie installieren können. Für heute suchen wir nach dem Modul node-red-dashboard. Klicken Sie auf den Install-Button. Eine Nachricht erscheint, die Sie vor den teilweise schwierigen Installationen warnt. Klicken Sie einfach auf Ok, denn mit diesem Modul verhält es sich einfach. Nach kurzer Wartezeit erscheint eine Erfolgsmeldung, und Sie haben die neuen Nodes in Ihrer Node-Zeile.

Tag 5: Node-RED

Wed, 05 Dec 2018 00:00:49 +0100

Hinter dem fünften Türchen des Adventskalenders finden Sie einen Taster, der in dem heutigen Versuch anstelle des Boot-Buttons eingesetzt werden soll. Der Button wird so an Pin 18 und GND angeschlossen, dass er beim Drücken den Pin auf Masse, also LOW, zieht. Wenn Sie nun das Programm des Tages auswählen und den Button drücken, wird wieder eine Nachricht über UDP übermittelt.

Versuchsaufbau

Heute werden Sie das Programm Node-RED kennenlernen, mit dem Sie Ihre eigenen kleinen Programmabläufe erstellen und Vorgänge automatisieren können. Node-RED ist eine kostenlose Software, die es uns ermöglicht, verschiedene Geräte, Onlinedienste und APIs (Programmierschnittstellen) über eine einfache grafische Oberfläche zu verbinden. Die Verbindungen, Flows genannt, werden dabei einfach per Mausklick gezogen.

Tag 4: UDP und JSON

Tue, 04 Dec 2018 00:00:42 +0100

Hinter dem vierten Türchen des Adventskalenders finden Sie einen Satz Kabel, die für die kommenden Hardwareaufbauten nützlich sind. Im heutigen Projekt wollen wir uns aber anschauen, was das JSONFormat ist und wie es uns hilft, mit dem Board zu kommunizieren.

Zuerst aktivieren Sie wie gewohnt das Programm des heutigen Tages. Außerdem werden Sie das PacketSender-Programm mit den gleichen Einstellungen wie gestern benötigen. Heute erscheint erst dann eine Nachricht, wenn Sie kurz auf den Boot-Button auf dem Board gedrückt haben. Diese Nachricht sieht so aus:

Tag 3: UDP und Packet Sender

Mon, 03 Dec 2018 00:00:52 +0100

Hinter dem heutigen Türchen befindet sich ein weiteres Steckboard. Es lässt sich mit dem gestrigen Steckboard zusammenstecken. Das NodeESP-Board kann dann auf beiden Steckboards gleichzeitig platziert werden. Allerdings hat sich herausgestellt, dass diese Konstellation nicht bei jedem funktioniert. Die einfachste Lösung ist, die Seitenteile der Steckboards abzubrechen. Dazu habe ich die Boards ineinander gesteckt und einfach solange gebogen, bis ein Seitenteil abgebrochen ist. Mit dem anderen Board bin ich genauso verfahren. Mit einer Zange funktioniert das aber genauso gut. Ohne Seitenteile lassen sich die Steckboards näher beieinander platzieren, und es gibt keine Probleme mit dem Raster. Das NodeESPBoard stecken Sie dann einfach auf beide Boards, wie auf dem Bild zu sehen. So bleibt genügend Platz für weitere Bauteile. Im heutigen Projekt werden wir sehen, wie Sie vom PC aus eine Verbindung zum Board aufbauen können, und zwar ohne den Webbrowser zu verwenden.

Tag 2: OnBoard-LED und Update

Sun, 02 Dec 2018 00:00:45 +0100

Hinter dem Türchen des zweiten Tages finden Sie ein Steckboard für die kommenden Versuchsaufbauten. Ich empfehle aber, Ihren NodeESP noch nicht auf das Steckboard zu stecken. Stattdessen schauen wir uns heute an, wie Sie die vorinstallierten Programme auf dem Board starten können, und bringen das Board außerdem auf den neuesten Stand.

Verbinden Sie Ihr Board zunächst wieder mit einer Stromquelle. Die WLAN-Daten, die Sie gestern eingegeben haben, sind weiterhin gespeichert, und somit sollte sich das Board automatisch mit Ihrem WLAN verbinden. Rufen Sie dann die Boardseite über die IP oder den mDNS-Namen (http://nodeesp. local/) auf. Als Erstes soll nach möglichen Software-Updates gesucht werden. Dazu öffnen Sie die Konfigurationsseite, klicken ganz unten auf den Punkt Advanced Settings und dort auf Check for Firmware Updates.

Tag 1: Das NodeESP-Board

Sat, 01 Dec 2018 00:00:32 +0100

Es ist der erste Tag des Adventskalenderprojekts 2018 und somit Zeit, das erste Türchen zu öffnen. Hinter dem Türchen finden Sie das Mikrocontrollerboard dieses Kalenders. Heute soll es vor allem darum gehen, eine Verbindung zum Heimnetzwerk herzustellen und das Board etwas besser kennenzulernen.

Das NodeESP-Board mit markierter WPS-Taste

Der erste Schritt ist, das Board mit Strom zu versorgen. Sie können das Board einfach per MicroUSB-Kabel mit dem PC oder einem gängigen Smartphone-Ladegerät verbinden. Sie brauchen mindestens 300 mA, um das Board zu starten, ältere Laptops und USB-Hubs ohne externe Stromversorgung könnten problematisch sein. Die RGB-LED auf dem Board beginnt nach kurzer Zeit, gelb zu leuchten. Damit ist die Initialisierung abgeschlossen. Sie müssen nur noch Ihre WLAN-Daten eingeben. Dazu gibt es zwei Möglichkeiten:

NodeESP Kommandoreferenz

Thu, 29 Nov 2018 18:00:44 +0100

Auf dieser Seite finden Sie alle Befehle der vorprogrammierten Firmware aufgelistet. Viele Befehle funktionieren nur in dem entsprechenden Unterprogramm. Befehle zu den Board Einstellungen lassen sich meistens nur über UDP oder die Webseite nutzen.

Buttons

Sendet automatisch eine Nachricht mit allen Zuständen bei Änderung eines Button-Zustands.
Sendet Button State beim Starten
Buttons haben Pullup aktiviert
- Buttons werden gegen Masse geschaltet
- Buttons sind dann HIGH, wenn nicht gedrückt und LOW wenn gedrückt
Default Pins im Beispiel: Pin 16 und Pin 18
Pin_value hat keine Bedeutung


Befehl	Beschreibung	MQTT Topic	Beispiel Anfrage (JSON)
get_button_config

Gibt verwendete Pins und Namen zurück | NodeESP/[PID]/button/config/get | {“cmd”:“get_button_config”} || get_button_state | Gibt den aktuellen Zustand der Buttons zurück | NodeESP/[PID]/button/state/get | {“cmd”:“get_button_state”} |

NodeESP Technische Daten

Sat, 10 Nov 2018 13:42:28 +0100

NodeESP Firmware Reinstallieren

Sat, 10 Nov 2018 12:51:29 +0100

Das NodeESP wird mit einer Firmware ausgeliefert, die bereits einige Beispielprogramme beinhaltet. Diese Firmware lässt sich über die Update Funktion auf der Config-Seite updaten. Die Firmware kann aber auch mit eigenen Programmen überspielt werden.

Doch egal ob man selbst ein paar eigene Programme auf das Board programmiert hat oder die Update Funktion mal nicht so funktioniert hat wie geplant, irgendwann kommt man eventuell an den Punkt, an dem man die Firmware neu installieren möchte. Diese Anleitung beschreibt die Schritte, die nötig sind, um die aktuelle Firmware manuell auf dem Board zu installieren.

Tag 0: Alle Flows des Kalenders

Wed, 07 Nov 2018 14:10:05 +0100

Wie in jedem Jahr finden Sie an dieser Stelle alle Programme (dieses Jahr wohl eher Flows) des IoT Adventskalenders 2018.

Ich verwende dieses Jahr Pastebin um alle Flows an einer Stelle zu speichern und leichter nachträglich bearbeiten zu können. Außerdem hat Wordpress dann keine Chance die Formatierung oder Sonderzeichen zu verändern. Der einfachste Weg zum Kopieren der Flows ist, auf den “Download Raw” Button zu klicken und die sich öffnende Seite komplett zu kopieren. Wenn Sie dann den Text in Node-Red einfügen (Menü->Import->Clipboard) haben Sie automatisch alle Flows in Tabs strukturiert hinzugefügt. Zusätzliche Nodes müssen eventuell noch nachinstalliert werden (z.B. das UI-Node)

WiFi UDP Y-Netzwerk aus drei Pretzelboards und einem Laptop

Mon, 08 Oct 2018 09:50:22 +0200

Anmerkungen von Fabian Kainka:

Im Sommer dieses Jahres erreichte mich eine Mail von Dr. Christian Rempel, mit einer Frage zum NanoESP. Im Rahmen eines Jugend forscht-Projektes sollte ein Pflückroboter realisiert werden. Mehrere NanoESP-Boards wurden dafür vernetzt um untereinander und mit einem Laptop Sensordaten auszutauschen. Ganz nebenbei hat das Projekt auch an anderen Stellen Wellen geschlagen, wie hier auf der TEC-IT Homepage. Außerdem ist aus diesem aufregenden Projekt ein Artikel entstanden, der die Problematik sehr gut beschreibt und eine Lösung bietet, die für viele Nutzer sehr nützlich sein sollte. An dieser Stelle möchte ich deswegen den überaus informativen und gut dokumentierten Artikel (sogar in englischer Version) von Dr. Christian Rempel und Laurin Kettner vorstellen. Viel Spaß beim Lesen.

Tag 24: Geschenkbox

Sat, 24 Dec 2016 00:01:53 +0100

Bei dem letzten Versuch in diesem Advent geht es wieder etwas weihnachtlicher zu. Wir basteln eine wiederverwendbare Geschenkbox, mit der Sie Ihre Verwandten beglücken können. Jedes Mal wenn jemand das Geschenk öffnet, wird der Inhalt in einer individuellen Farbe beleuchtet und ein Weihnachtssound ertönt.

Hinter dem heutigen Türchen befindet sich eine Reflexlichtschranke. Es handelt sich dabei eigentlich um zwei Bauteile, einer IR-Sendediode und einem Phototransitor. Wie genau Sie die Elemente gepolt werden müssen ist nicht ganz einfach zu erkennen. Deswegen stecken Sie am besten die Lichtschranke nach dem unteren Vorbild mit dem Verbindungskabeln zusammen. Dann können Sie die Polung nicht so leicht vertauschen.

Tag 23: MQTT Climate

Fri, 23 Dec 2016 00:01:49 +0100

Hinter dem heutigen Türchen befindet sich ein Batterie-Clip für einen 9-V-Block, mit dem Sie das gesamte System mobil machen können. Eine Alternative zu einer Batterie ist eine Power-Bank (ein Akku-Pack, normalerweise für Handys). Wie Sie eine 9-V-Batterie richtig anschließen, können Sie dem heutigen Aufbaubild entnehmen.

So können Sie eine 9V-Batterie am heutigen Aufbau anschließen

Heute sollen erneut Klimadaten erfasst werden. Diesmal werden sie aber über den MQTT-Broker veröffentlicht, und sind deshalb auch weltweit abrufbar. Über ein Plugin könnten so die Daten abgerufen und in einer Datenbank gespeichert werden.

Tag 22: MQTT Cheerlights

Thu, 22 Dec 2016 00:01:31 +0100

In dem heutigen Versuch geht es um MQTT und um ein globales Projekt, das auch letztes Jahr vorgestellt wurde: nämlich das Cheerlights Projekt von Hans Schaaler. Für alle diejenigen, die das Projekt nicht kennen: Es geht um weltweit vernetzte bunte Lichter, die sich simultan über Twitter-Kommandos steuern lassen. Eine andere Version dieses Projekts war Teil des letztjährigen Adventskalenders. Dieses Jahr gibt es die Version mit MQTT und erweiterten Funktionen.

Hinter dem heutigen Türchen befindet sich ein Widerstand mit 1 kOhm. Der Aufbau besteht aus der RGB-LED mit Vorwiderständen und einem Taster.

Tag 21: Hausautomation

Wed, 21 Dec 2016 00:01:34 +0100

In dem Versuch des heutigen Tages werden wir die Eigenschaften und Möglichkeiten von MQTT genauer beleuchten, in dem wir ein praktisches Szenario kreieren. In dem Beispiel gibt es ein Gebäude mit zwei Räumen mit jeweils einem Lichtschalter, einem Licht und einem Alarmsensor. Die Lichtschalter schalten das Licht des jeweiligen Raums an oder aus. Die Alarmsensoren aktivieren einen gebäudeweiten Alarm.

Normalerweise würden hier sieben verschiedene Geräte zum Einsatz kommen, die alle über einen MQTT-Broker miteinander verbunden sind. Da Sie aber wahrscheinlich nur einen NanoESP haben, simuliert dieser alle Geräte auf einmal. Deswegen sieht der Aufbau des heutigen Tages etwas kompliziert aus. Als zweites Licht wird übriges heute die LED D3 genutzt. Deswegen wird diese heute nicht anzeigen, ob Sie mit dem WLAN-Verbunden sind. Als Alarmsensoren werden die Tiltsensoren an den Verlängerungskabeln genutzt. Man könnte sie beispielsweise an Türen oder Fensterrahmen befestigen, sodass sie einen Alarm triggern wenn sich der Eingang öffnet. Hinter dem heutigen Türchen befindet sich auch der zweite Sensor.

Tag 20: MQTT (Message Queue Telemetry Transport)

Tue, 20 Dec 2016 00:01:05 +0100

Für die letzten Tage in diesem Advent werden Sie nun ein Thema kennenlernen, welches eine große Rolle im Bereich IoT spielt. Es geht um das Nachrichten-Protokoll MQTT (Message Queue Telemetry Transport) welches speziell für die Kommunikation von Machschienen zu Maschinen (M2M) entwickelt wurde. Der Grund warum dieses Protokoll so genial ist, liegt in der Kompaktheit und Einfachheit, mit der Daten wie Steuerdaten, Messdaten oder Texte, ausgetauscht werden können. Im Vergleich zum HTTP ist der Overhead (Daten die neben den eigentlichen Nutzdaten übermittelt werden) sehr kurz und können gerade von Embeded Devices, also Mikrocontrollern wie unserem NanoESP, gut verarbeitet werden. Gleichzeitig muss der Controller nicht selbst immer wieder eine Verbindung aufbauen und erfragen, ob es eine Veränderung gab, sondern die Verbindung wird dauerhaft gehalten und der Client automatisch über Veränderungen Informiert.

Tag 19: Konfigurationsseite für den NanoESP

Mon, 19 Dec 2016 00:01:07 +0100

Hinter dem heutigen Türchen befindet sich ein weiteres Kabel. Mit den beiden Kabeln ist es nun möglich z.B. die RGB LED auch abseits des Boards zu platzieren. Die RGB-LED werden wir heute auch benötigen, denn es geht um eine Webseite, über die die Farbe der LED eingestellt werden kann. Doch das ist nicht der Hauptaspekt: Um das Konfigurieren des NanoESP nicht nur für Programmierer besonders einfach zu gestalten, gibt es eine Konfigurationsseite, über die die WLAN-Daten des Moduls eingestellt werden können. Doch zunächst zum Aufbau:

Tag 18: Klimaüberwachung

Sun, 18 Dec 2016 00:01:35 +0100

Hinter dem heutigen Türchen befindet sich ein ganz besonderes Bauteil, nämlich ein Luftfeuchtesensor. Zusammen mit dem Phototransistor und dem NTC bauen Sie heute eine Klimastation für den Heimgebrauch. Dazu ist folgender Aufbau nötig:

Der Aufbau mit allen Sensoren

Der heutige Aufbau ist etwas kniffelig. Vor allem an der Stelle, an der das rechte Poti auf dem Bild sitzt, kommt es zu einer Berührung mit dem NanoESP. Dies ist aber nicht weiter schlimm, solange der auf dem Bild linke Kontakt fest im Board steckt.

Tag 17: Wake Up Light

Sat, 17 Dec 2016 00:01:56 +0100

Das Projekt des heutigen Tages orientiert sich an einer bekannten Lampe von Phillips, dem Wake Up Light. Es handelt sich dabei um einen sanften Wecker, denn anstelle laut zu tönen wird langsam die Helligkeit erhöht. So entsteht eine Art Sonnenaufgang und der Körper wird auf natürliche Weise wach.

Hinter dem heutigen Türchen befindet sich ein weites Poti, welches für den morgigen Versuch wichtig ist. Heute wird folgender Aufbau benötigt:

Die RGB LED mit Vorwiderständen

Das Programm: A16_P17_WakeUpLight.ino

/*
 TCP-Server: Wakeup light
 Change SSID and PASSWORD.
 RGB-Led (common cathode) on Pins 3,5,6
*/

#include <NanoESP.h>
#include <NanoESP_HTTP.h>
#include <SoftwareSerial.h>
#include "Websites.h"

#include <math.h>
#include <Time.h>

#define SSID "YourSSID"
#define PASSWORD "YourPassword"

#define LED_WLAN 13

#define RED 3
#define GREEN 5
#define BLUE 6
#define GND 4

#define BUTTON 7

NanoESP nanoesp = NanoESP();
NanoESP_HTTP http = NanoESP_HTTP(nanoesp);

//String timeServerIP = ; // time.nist.gov NTP server address
String ntpServerName = "195.145.119.188";//"time.nist.gov";
const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets

int alarmHour = 0, alarmMinute = 2;
bool alarm;
byte cRed = 0, cBlue = 0, cGreen = 0;

unsigned long previousMillis = 0; // will store last time a msg was send
unsigned long interval = 78; //

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

 pinMode(RED, OUTPUT);
 pinMode(GREEN, OUTPUT);
 pinMode(BLUE, OUTPUT);

 pinMode(GND, OUTPUT);
 digitalWrite(GND, LOW);

 pinMode(BUTTON, INPUT);

 //Only Station Mode for TimeSync
 nanoesp.configWifiMode(STATION);
 //delay(1000);

 // Wait till Connected to WiFi
 if (nanoesp.wifiConnected())digitalWrite(LED_WLAN, HIGH); else Serial.println(F("Error WLAN Connect"));

 //Start TCP Server
 if (nanoesp.startTcpServer(80)) Serial.println(F("TCP Server Activ")); else Serial.println(F("TCP Server Error"));

 //Print IP in Terminal
 Serial.println(nanoesp.getIp());

 setSyncProvider(getNtpTime);
 Show_Time();
}


time_t getNtpTime() {
 //convert to time_t , Paramter: connectionId, ServerAdress, Timezone
 return (time_t)getNTPpacket(4, ntpServerName, 2);
}

void loop() {
 String method, ressource, parameter;
 int id ;

 if (http.recvRequest(id, method, ressource, parameter)) {

 Serial.println("New Request from id :" + String(id) + ", method: " + method + ", ressource: " + ressource + " parameter: " + parameter);

 if (ressource == "/") {
 http.sendFromFlash(id, index, sizeof(index));
 nanoesp.closeConnection(id);
 }

 if (ressource == "/settimer") {
 if (parameter != "") {
 //timer=02%3A03&
 String sHour = parameter.substring(parameter.indexOf('=') + 1, parameter.indexOf('%'));
 String sMin = parameter.substring(parameter.indexOf('A') + 1, parameter.indexOf('&'));

 String sDuration = parameter.substring(parameter.indexOf('&') + 1);
 sDuration = sDuration.substring(sDuration.indexOf('=') + 1, sDuration.indexOf('&'));

 alarmHour = sHour.toInt();
 alarmMinute = sMin.toInt();
 int iDuration = sDuration.toInt();
 interval *= iDuration;

 Serial.println("Timer: " + String(alarmHour) + ":" + String(alarmMinute) + " Duartion: " + String (iDuration) );
 Show_Time();

 }
 nanoesp.closeConnection(id);
 }


 if (ressource == "/turnoff") {
 alarm = false;
 cRed = 0; cBlue = 0; cGreen =0;
 analogWrite(RED,cRed); analogWrite(BLUE,cBlue);analogWrite(GREEN,cGreen);
 }

 else {
 http.sendFromFlash(id, error404, sizeof(error404));
 nanoesp.closeConnection(id);
 }
 }
 else {
 if (hour() == alarmHour) {
 if (minute() == alarmMinute) {
 if (!alarm) alarm = true;
 }
 }

 if (alarm) wakeUp();
 }
}

void MorningAlarm() {

 Serial.println("Alarm: - turn lights off");
}


void wakeUp() {
 if (millis() - previousMillis >= interval) {
 previousMillis = millis();
 if (cRed == 0) Show_Time();
 if (cRed < 255) {
 cRed++; analogWrite(RED, cRed );
 }
 else {
 if (cGreen < 255) {
 cGreen++;
 analogWrite(GREEN, cGreen);
 }
 else {
 if (cBlue < 255) {
 cBlue++;
 analogWrite(BLUE, cBlue );
 if (cBlue == 255) Show_Time();
 }
 }
 }
 }
}



// prepare an NTP request to the time server and send to the given
bool sendNTPpacket(int id, String address)
{
 // set all bytes in the buffer to 0
 memset(packetBuffer, 0, NTP_PACKET_SIZE);
 // Initialize values needed to form NTP request
 // (see URL above for details on the packets)
 packetBuffer[0] = 0b11100011; // LI, Version, Mode
 packetBuffer[1] = 0; // Stratum, or type of clock
 packetBuffer[2] = 6; // Polling Interval
 packetBuffer[3] = 0xEC; // Peer Clock Precision
 // 8 bytes of zero for Root Delay & Root Dispersion
 packetBuffer[12] = 49;
 packetBuffer[13] = 0x4E;
 packetBuffer[14] = 49;
 packetBuffer[15] = 52;
 //
 // if we need a cr/lf
 //
 packetBuffer[NTP_PACKET_SIZE ] = 0x0D;
 packetBuffer[NTP_PACKET_SIZE + 1] = 0x0A;
 // all NTP fields have been given values, now
 // you can send a packet requesting a timestamp:
 if ( nanoesp.sendRaw(id, packetBuffer, NTP_PACKET_SIZE)) return true;
 return false;
}

long getNTPpacket(int id, String address, int timeZone) {
 unsigned long secsSince1900;
 byte offset = 40;

 if (!nanoesp.newConnection(id, UDP, address, 123)) Serial.println ("no connection ntp server"); //NTP requests are to port 123
 delay(100);
 if (!sendNTPpacket(id, address)) {
 Serial.println("No time request send");
 return 0;
 }
 nanoesp.setTimeout(2000);
 if (nanoesp.find("+IPD,")) {
 int vid = nanoesp.parseInt();
 nanoesp.find(",");
 int len = nanoesp.parseInt();
 //Serial.println(String(len));
 byte buffer[len];

 nanoesp.find(":");
 nanoesp.readBytes(buffer, 48);

// for (int i = 0; i <= NTP_PACKET_SIZE; i++) {
// Serial.print(buffer[i], HEX);
// }

 // convert four bytes starting at location 40 to a long integer
 secsSince1900 = (unsigned long)buffer[offset + 0] << 24;
 secsSince1900 |= (unsigned long)buffer[offset + 1] << 16;
 secsSince1900 |= (unsigned long)buffer[offset + 2] << 8;
 secsSince1900 |= (unsigned long)buffer[offset + 3];

 nanoesp.find("OK\r\n");
 nanoesp.closeConnection(id);

 // return secsSince1900 + timeZone * SECS_PER_HOUR; // NTP Date
 return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR; // UNIX Date
 }
 else {
 Serial.println("no time recieved");
 nanoesp.closeConnection(id);
 return 0;
 }
}

void Show_Time()
{
 String shour, sminute, ssecond;

 Serial.print("Date: ");
 Serial.print(day());
 Serial.print(".");
 Serial.print(month());
 Serial.print(".");
 Serial.println(year());


 if (hour() <= 9) shour = "0" + String(hour()); else shour = String(hour()); // adjust for 0-9
 if (minute() <= 9) sminute = "0" + String(minute()); else sminute = String(minute());
 if (second() <= 9) ssecond = "0" + String(second()); else ssecond = String(second());
 Serial.println( "Time: " + shour + ":" + sminute + ":" + ssecond );
}

(Die frühere Einbettung über Arduino Create ist nicht mehr verfügbar; der Code stammt aus dem Download aller Programme.)

Tag 16: Ein Webserver Piano

Fri, 16 Dec 2016 00:01:54 +0100

Hinter dem heutigen Türchen befindet sich ein Piezzo Schallwandler. Mit ihm ist es möglich, Töne zu generieren, wie im heutigen Versuch deutlich wird. Sie basteln heute eine Art Klavier, das über eine Webseite bedient werden kann. Doch zunächst der Aufbau:

Der Piezzo richtig angeschlossen

Das Programm: A16_P16_WebserverPiano.ino

/*
 TCP-Server Piano
 Change SSID and PASSWORD.
*/

#include <NanoESP.h>
#include <NanoESP_HTTP.h> //special library for http-connection
#include <SoftwareSerial.h>
#include "Websites.h" //websites in a special file as progmem

#define SSID "YourSSID"
#define PASSWORD "YourPassword"

#define LED_WLAN 13

NanoESP nanoesp = NanoESP();
NanoESP_HTTP http = NanoESP_HTTP(nanoesp);

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

 //! Only if you want to change the ACCESPOINT configuration
 //nanoesp.configWifi(ACCESSPOINT, "NanoESP", "");

 //! Only if you use a new Network
 // nanoesp.configWifi(DUAL, SSID, PASSWORD);

 //Dual Mode
 nanoesp.configWifiMode(DUAL);
 //delay(1000);

 // Wait till Connected to WiFi
 if (nanoesp.wifiConnected())digitalWrite(LED_WLAN, HIGH); else Serial.println(F("Error WLAN Connect"));

 //Start TCP Server
 if (nanoesp.startTcpServer(80)) Serial.println(F("TCP Server Activ")); else Serial.println(F("TCP Server Error"));

 //Print IP in Terminal
 Serial.println(nanoesp.getIp());
}

void loop() {
 String method, ressource, parameter;
 int id;

 if (http.recvRequest(id, method, ressource, parameter)) { //Incoming request, parameters by reference

 Serial.println("New Request from id :" + String(id) + ", method: " + method + ", ressource: " + ressource + " parameter: " + parameter);

 if (ressource == "/") {
 http.sendFromFlash(id, index, sizeof(index));
 nanoesp.closeConnection(id);
 }

 else if (ressource == "/dataonly") { //only data is recieved on this url, no need to send a website
 nanoesp.closeConnection(id);
 }

 else {
 http.sendFromFlash(id, error404, sizeof(error404));
 nanoesp.closeConnection(id);
 }

 if (parameter != "") //the request included parameters
 {
 String strTone;
 if (method == GET) strTone = parameter.substring(6); else strTone = parameter.substring(5); //get note values
 noTone(8);
 tone(8, strTone.toInt(), 200); //play note for 200ms
 }

 }
}

(Die frühere Einbettung über Arduino Create ist nicht mehr verfügbar; der Code stammt aus dem Download aller Programme.)

Tag 15: Ein Webserver

Thu, 15 Dec 2016 00:01:28 +0100

Nachdem in den letzten Tagen vor allem die Blynk-Plattform zentraler Punkt unserer Projekte war, kommt nun ein ganz neues Thema, und zwar der NanoESP als Webserver. Bei dem Versuch des ersten Tages haben Sie bereits einen ersten Eindruck bekommen. In den folgenden Tagen werden Sie sehen, was noch alles möglich ist.

Hinter dem heutigen Türchen befindet sich ein spezielles doppeladriges Kabel, mit dem sich z.B. auch LEDs oder Sensoren außerhalb des Boards einsetzen lassen. Für den heutigen Versuch ist allerdings gar kein Hardwareaufbau nötig. Alles was Sie benötigen ist das Programm und einen Browser.

Tag 14: Langzeit Temperatur Messung

Wed, 14 Dec 2016 00:01:14 +0100

Hinter dem heutigen Türchen befindet sich ein NTC-Sensor (Heißleiter, Negative Temperature Coefﬁcient). Dieser verändert seinen Widerstand in Abhängigkeit von der Temperatur. Sie nutzen den Sensor heute, um eine Langzeitmessung der Temperatur vorzunehmen. Als kleinen Bonus können Sie einen Zeitpunkt auswählen, an dem Sie eine Zusammenfassung per Mail geschickt bekommen.

Für den Aufbau des heutigen Tages benötigen Sie neben dem NTC auch das Poti und einen 1 kOhm Widerstand. Mit dem Poti können Sie einen Feinabgleich der Temperatur vornehmen.

Tag 13: Alarmanlage mit Push Nachrichten

Tue, 13 Dec 2016 00:01:56 +0100

Bei dem Projekt des heutigen Tages handelt es sich um eine einfache, stille Alarmanlage mit Passwort-Eingabe zum Resetten des Alarms. Damit man von dem stillen Alarm überhaupt etwas mitbekommt, sendet das Board eine Push-Nachricht zum Smartphone. Der sich hinter dem heutigen Türchen befindenden Tiltsensor setzen wir hier als Bewegungssensor ein. Er kann über Erschütterungen informieren und somit Bescheid geben, wenn jemand das NanoESP-Board kippt.

Aufbau mit Tiltsensor

Das Programm: A16_P13_Blynk9_PushAlarm.ino

/*
 Blnky9: PushAlarm
 Change ssid, password and token
*/

char ssid[] = "YourSSID";
char password[] = "YourPassword";
char token[] = "YourToken";

String passwordAlarm = "password";
String alarmMsg = "Alarm! Someone touched the NanoESP!";

#define BLYNK_DEBUG
#define BLYNK_PRINT Serial // Comment this out to disable prints and save space
#include <ESP8266_SoftSer.h>
#include <BlynkSimpleShieldEsp8266_SoftSer.h>
#include <SimpleTimer.h>

// Set ESP8266 Serial object
#include <SoftwareSerial.h>
SoftwareSerial EspSerial(11, 12); // RX, TX

ESP8266 wifi(EspSerial);
SimpleTimer timer;

WidgetTerminal terminal(V1);

boolean alarm = false;

void setup()
{
 // Set console baud rate
 Serial.begin(19200);
 EspSerial.begin(19200);

 Blynk.begin(token, wifi, ssid, password);

 //push msg
 Blynk.notify("Alarm active");

 pinMode(2, INPUT_PULLUP);

 //timer for blinking led on alarm
 timer.setInterval(1000L, blinkAlarm);
}

void loop()
{
 Blynk.run();
 if (alarm) timer.run(); else digitalWrite(13, LOW); //blink if alarm active

 if (digitalRead(2)) { //read tilt sensor
 if (!alarm) {
 alarm = true;

 Blynk.notify(alarmMsg); //push msg on alarm

 terminal.println(F("Alarm! Type in Password:"));
 terminal.flush();
 }
 }
}


BLYNK_CONNECTED() {
 Blynk.syncAll();

 terminal.println(F("Blynk v" BLYNK_VERSION ": Device started"));
 terminal.println("-------------");
 terminal.flush();
}


BLYNK_WRITE(V1) //Terminal
{
 //type in password on alarm
 if (alarm) {

 String passInput = param.asStr();

 if (passwordAlarm == passInput) {
 alarm = false;
 terminal.println(F("Alarm deaktivated"));
 terminal.flush();

 }
 else {
 terminal.println(F("Wrong password!"));
 terminal.flush();
 }
 }
}


//timer function for blinking led on alarm
void blinkAlarm()
{
 digitalWrite(13, !digitalRead(13));
}

(Die frühere Einbettung über Arduino Create ist nicht mehr verfügbar; der Code stammt aus dem Download aller Programme.)

Tag 12: Lichtwächter

Mon, 12 Dec 2016 00:01:46 +0100

Hinter dem Türchen des heutigen Tages finden Sie einen Phototransistor. Dabei handelt es sich um einen Sensor, mit dem Helligkeit gemessen werden kann. Dies werden Sie heute auch tun, aber neben dem einfachen Messen gibt das heutige Projekt auch über verschiedene Kanäle Alarm, sobald per App einstellbare Grenzwerte überschritten werden. Damit dies alles auch funktioniert, müssen Sie den Sensor mit einer Spannungsteilerschaltung an den Pin A0 anschließen, wie auf dem unteren Bild zu sehen ist. Beachten Sie die richtige Polung des Phototransistors (kurzes Beinchen an VCC). Andersherum funktioniert er zwar auch, aber lange nicht so empfindlich.

Tag 11: Tag/Nacht Licht

Sun, 11 Dec 2016 00:01:57 +0100

Hinter dem heutigen Türchen befindet sich ein 10 kOhm Widerstand den wir heute aber noch nicht benötigen werden. Stattdessen funktioniert der Aufbau des gestrigen Versuchs auch heute. In diesem Projekt werden Sie eine Tag/Nacht Lampe basteln, die zu bestimmten Uhrzeiten die Farbe wechselt. So können Sie Tagsüber ein helles Licht leuchten lassen, während in der Nacht nur ein dunkles Rot als Notbeleuchtung für etwas Orientierung sorgt.

Der Aufbau von Tag 10

Das Programm: A16_P11_Blynk7_DayNight.ino

/*
Blynk 7: DayNight
Change ssid, password and token
*/

char ssid[] = "YourSSID";
char password[] = "YourPassword";
char token[] = "YourToken";

#define BLYNK_DEBUG
#define BLYNK_PRINT Serial // Comment this out to disable prints and save space
#include <ESP8266_SoftSer.h>
#include <BlynkSimpleShieldEsp8266_SoftSer.h>

// Set ESP8266 Serial object
#include <SoftwareSerial.h>
SoftwareSerial EspSerial(11, 12); // RX, TX

ESP8266 wifi(EspSerial);

boolean isDay;

void setup()
{
 // Set console baud rate
 Serial.begin(19200);
 EspSerial.begin(19200);

 Blynk.begin(token, wifi, ssid, password);
}

void loop()
{
 //all events are handled by functions below
 Blynk.run();
}


BLYNK_CONNECTED() {
 //Sync all states when reconnected
 Blynk.syncAll();
}


BLYNK_WRITE(V1) //DayTimer
{
 if (param.asInt()== 1){
 Blynk.virtualWrite(V0,1);
 Blynk.virtualWrite(V7,0);
 isDay = true;
 Blynk.syncVirtual(V3);
 }
}

BLYNK_WRITE(V4) //NightTimer
{
 if (param.asInt()== 1){
 Blynk.virtualWrite(V0,0);
 Blynk.virtualWrite(V7,1);
 isDay = false;
 Blynk.syncVirtual(V8);
 }
}

BLYNK_WRITE(V0) //Day
{
 if(param.asInt()==1)
 {
 Blynk.virtualWrite(V7,0);
 isDay = true;
 Blynk.syncVirtual(V3);
 }
}

BLYNK_WRITE(V7){ //Night

if(param.asInt()==1)
 {
 Blynk.virtualWrite(V0,0);
 isDay = false;
 Blynk.syncVirtual(V8);
 }
}

BLYNK_WRITE(V3) // change color Day
{
 if (isDay){
 analogWrite(3, param[0].asInt()); // getting first value
 analogWrite(5, param[1].asInt()); // getting second value
 analogWrite(6, param[2].asInt()); // getting N value
 }
}

BLYNK_WRITE(V8) // change color Night
{
 if (!isDay){
 analogWrite(3, param[0].asInt()); // getting first value
 analogWrite(5, param[1].asInt()); // getting second value
 analogWrite(6, param[2].asInt()); // getting N value
 }
}

(Die frühere Einbettung über Arduino Create ist nicht mehr verfügbar; der Code stammt aus dem Download aller Programme.)

Tag 10: RGB-LED

Sat, 10 Dec 2016 00:01:27 +0100

Hinter dem heutigen Türchen befindet sich der Grund für die vielen 1 kOhm Widerstände. Sie finden dort nämlich eine sogenannte RGB-LED. RGB steht für Rot Grün Blau, denn bei dieser LED handelt es sich eigentlich um drei LEDs, die über eine gemeinsame Kathode angeschlossen werden können. Durch Variation der Helligkeit der einzelnen LEDs mittels PWM lassen sich so nahezu alle denkbaren Farben generieren.

Der Aufbau der heutigen Schaltung können Sie auf dem unteren Bild sehen. Beachten Sie dass das etwas längere Beinchen (die Kathode) in die GND Kontaktleiste gesteckt werden muss.

Tag 9: Helligkeit der realen LED

Fri, 09 Dec 2016 00:01:46 +0100

Hinter dem heutigen Türchen befindet sich ein weiterer 1 kOhm Widerstand. Allerdings muss heute nichts am Hardwareaufbau vom gestrigen Tag verändert werden. Es wird lediglich eine Kleinigkeit an der Oberfläche variiert.

Der gestrige Aufbau

Auch das Programm müssen Sie nicht erneut hochladen, wenn Sie einfach die Oberfläche von gestern manuell anpassen. Falls Sie die Oberfläche sicherheitshalber dennoch in die App laden möchten, finden Sie hier wie immer den QR-Code. Allerdings müssen Sie dann auch den Token neu in Ihr Programm eintragen.

Tag 8: Virtuelle LEDs

Thu, 08 Dec 2016 00:01:15 +0100

In dem Versuch des sechsten Tages haben Sie gesehen, wie Sie einen Tastschalter auf der Hardwareseite auf einen Button in der App abbilden können. Ein anderes Widget, nämlich das LED Widget ist für diesen Fall allerdings viel eindeutiger. Wie man dieses Widget richtig einsetzt und welche Möglichkeiten das bietet sehen Sie in dem heutigen Versuch.

Hinter dem heutigen Türchen befindet sich wieder ein 1 kOhm Widerstand, der für spätere Versuche wichtig wird. Heute wird allerdings die Schaltung von gestern mit einem zusätzlichen Taster verwendet.

Tag 7: Analog Write

Wed, 07 Dec 2016 00:01:18 +0100

Hinter dem heutigen Türchen befindet sich ein Potentiometer (kurz Poti). Mit diesem Poti können Sie analoge Messungen an die Blynk App übertragen. Dazu müssen Sie die Schaltung auf dem unteren Bild nachbauen.

Das Poti benutzt heute die untere Leitung für die Verbindung mit A0

Es kann beim Aufbauen etwas eng mit dem MicroUSB-Kabel werden. Damit alles klappt müssen Sie das Board zunächst vom Kabel trennen und die Drahtbrücken möglichst flach platzieren. Zu beachten ist außerdem, dass diesmal nicht VCC auf die im Bild untere Bahn gelegt wurde, sondern die Bahn für den Anschluss an Pin A0 gedacht ist.

Tag 6: Der Hardware Button

Tue, 06 Dec 2016 00:01:21 +0100

In dem gestrigen Versuchen haben Sie eine einfache Steuerung einer LED über die Blynk-App realisiert. Heute werden Sie sehen, dass die Steuerung in beide Richtungen funktioniert. Dafür kommt der Tastschalter hinter dem heutigen Türchen gerade recht. Mit ihm lässt sich die gestrige Schaltung zur folgenden erweitern:

Der neue Aufbau mit Tastschalter an D7

Die Oberfläche des heutigen Tages können Sie hier scannen:

Tag 5: Blynk

Mon, 05 Dec 2016 00:01:46 +0100

Eine erste Verbindung vom Board zum Internet haben Sie gestern bereits hergestellt. In den nächsten Tagen soll diese Verbindung nun auch effektiv genutzt werden. Dabei beschäftigen wir uns mit der Online-Plattform Blynk, über die kurze Kommandos, Messdaten oder Nachrichten zwischen den NanoESP-Board und Ihrem Smartphone ausgetauscht werden können.

Kommunikationswege mit Blynk

Blynk ermöglicht die einfache Ansteuerung von verschiedenen IoT-Boards, wie z.B. dem Rapsberry Pi oder unserem NanoESP, über eine App. Die grafische Oberfläche kann man sich völlig selbständig zusammenstellen, und auch die Programmierung ist denkbar einfach. Als wäre dies noch nicht genug, lässt sich die Steuerung des Boards auch noch von überall auf der Welt vornehmen. Ganz im Sinne des Internet of Things also.

Tag 4: Verbindung mit dem Internet aufbauen

Sun, 04 Dec 2016 00:01:49 +0100

Hinter dem heutigen Türchen verbirgt sich ein 1 kOhm Widerstand. Heute ist noch nicht viel damit anzufangen aber morgen wird er wichtig. In dem heutigen Versuch wollen wir eine erste Verbindung zu Ihrem Heim WLAN Netzwerk einrichten. Dazu müssen Sie, wie an vielen folgenden Tagen, Ihre WLAN-Daten in das Programm eintragen.

Das Board pingt den Google Server an

Doch zunächst müssen Sie das heutige Programm herunterladen. Dies können Sie tun, indem Sie in dem unteren Fenster auf das rechte Symbol klicken. Bei diesem Fenster handelt es sich um ein Iframe der Arduino Create Webseite. Arduino Create ist ein von den Machern von Arduino bereitgestellter online Compiler. Mit Ihm können können Sie direkt im Browser Arduino Programme schreiben und auf ein Board hochladen. Ebenso können Sie die hier vorgestellten Programme in Ihren online Programmordner importieren und vor dem Hochladen anpassen. Dazu benötigen Sie allerdings einen kostenlosen Account und ein passendes Plugin. Ich benutze diese Funktion vor allem, da Sie vor dem Programmdownload einen Blick in den Code werfen können und es für mich einfacher ist, den Code nachträglich zu verändern und einzubinden.

Tag 3: Der NanoESP im AccesPoint-Modus

Sat, 03 Dec 2016 00:01:18 +0100

Hinter dem dritten Türchen befindet sich der für viele Versuche wichtige Schaltdraht. Als Vorbereitung für spätere Versuche können Sie die Versorgungsleitungen GND und VCC auf die äußeren Bahnen legen. Dadurch haben Sie später einen besseren Zugriff auf diese wichtigen Leitungen.

Die Drahtbrücken an GND und VCC

In dem Projekt des heutigen Tages kommen Sie nun dazu, auch selbst etwas in dem Programm zu verändern. Als Grundlage dient uns dabei das Beispielprogramm:

Tag 2: Die Arduino IDE

Fri, 02 Dec 2016 00:01:47 +0100

Diesmal beﬁndet sich hinter dem Türchen ein Steckbrett. Darauf lassen sich schnell und einfach die Hardwareaufbauten des Adventskalenders zusammenstecken. Da bis jetzt nur der NanoESP zur Verfügung steht, fangen wir mit diesem an.

NanoESP auf dem Steckboard

Am besten ist es, wenn Sie den Controller wie auf dem Bild gezeigt auf das Steckboard stecken. Dadurch bleibt der meiste Platz für Experimente, das WLAN-Modul ragt hinten über das Steckboard hinaus. Das Micro-USB-Kabel hängt dann zwischen den Kontaktseiten und stört nur minimal. Das Board muss mit sanfter Gewalt und bis zum Anschlag in die Kontakte gepresst werden.
Am heutigen Tag wollen wir uns außerdem mit der Software beschäftigen, mit der das Board programmiert werden kann. Es handelt sich um die Arduino-Entwicklungsumgebung (kurz Arduino-IDE). Sie können die neuste Version unter http://www.arduino.cc/en/Main/software für Ihr individuelles System herunterladen und anschließend installieren. Beachten Sie, dass Sie mindestens mit Arduino-Version 1.6.5 arbeiten sollten.

Tag 1: Das NanoESP-Board

Thu, 01 Dec 2016 00:01:19 +0100

Es ist der erste Dezember und damit Zeit, das erste Türchen zu öffnen. Dahinter beﬁ ndet sich das wohl wichtigste Element des Kalenders: Das NanoESP-Board. Dieser Arduino-kompatible Controller mit WLANFunktion steht im Mittelpunkt der 24 Versuche.

Das NanoESP Board

Kurz zusammengefasst lässt sich sagen, dass das Board am ehesten eine Kreuzung aus einem Arduino-Nano-ähnlichen Board und einem WLAN-Modul mit dem Namen ESP8266 ist. Die Kommunikation zwischen beiden Elementen läuft über eine per Software generierte serielle Schnittstelle, die an den Pins D11 und D12 angeschlossen ist. Diese Pins sollten Sie also bei eigenen Projekten meiden.

Tag 0: Alle Programm von Kalender 2016

Sat, 08 Oct 2016 14:34:57 +0200

Auch dieses Jahr gibt es wieder die Vorabversion aller Programme zum Ausprobieren.

Wie bereits in dem Handbuch erwähnt wurde speziell für den letzten Teil des Adventskalenders ein eigener Server gemietet und konfiguriert. Dieser ist nun soweit eingestellt, dass auch die letzten Versuche funktionieren. Es kann allerdings immer noch sein, dass es bis zum offiziellen Start im Dezember zu kurzen Downzeiten kommt.

Ein Problem gibt es derzeit noch mit dem Cheerlights Projekt am Tag 23. Ich hoffe, dass ich dieses Problem in den nächsten Tagen lösen kann.

Die neue NanoESP-Library mit MQTT, HTTP und Blynk-Support

Mon, 19 Sep 2016 12:25:19 +0200

Im Kontext des neues IoT Adventskalenders 2016 wurde die Library zum NanoESP um einige Funktionen erweitert. Neben den klassischen Befehlen zum Steuern des Moduls, gibt es in dieser Version auch zwei Sub-Libraries, die das Übermitteln von Webseiten erleichtern oder die Verwendung des beliebten MQTT(http://mqtt.org/) IoT-Protokolls ermöglichen.

download-151556_640

Download

Link auf Github: https://github.com/FKainka/NanoESP

Unter den Beispielen befindet sich außerdem ein Programm, welches Blynk-Projekte (http://www.blynk.cc/) ermöglicht. Damit Sie das Programm verwenden können, benötigen Sie eine zusätzliche Library:

Infos zum neuen Adventskalender

Thu, 08 Sep 2016 14:45:15 +0200

Das Adventskalender Projekt vom letzten Jahr hat anscheinend viel Anklang gefunden. Anhand der Nutzerzahlen konnte ich ablesen, dass viele Interessierte täglich den neuen Versuch auf der Webseite aufgerufen haben und auch in den Kommentarbereichen war ordentlich was los. Es war einfach schön zu sehen, wie Sich viele verschiedene Bastelbegeisterte gegenseitig helfen.

Aus diesem Grund soll auch in diesem Jahr das Adventskalender Projekt durch diese Webseite begleitet werden. In dem letzten Jahr war der die online Unterstützung ein erster Versuch, der anscheinend recht erfolgreich war. Dennoch gab es einige Kritikpunkte, die teilweise auch Ihre Berechtigung hatten. Deswegen habe ich versucht in diesem Jahr einige Dinge besser zu machen.

Ausgelagerte Webseiten für den NanoESP

Sun, 17 Apr 2016 11:33:10 +0200

Gerade im Kontext des Adventskalenders oder den anderen Lernpaketen habe ich einige HTML-Seiten für den NanoESP entworfen. Allerdings hat mich dabei immer gestört, dass zum einen der Speicherplatz ziemlich gering ist zum anderen die Übertragung etwas langsam sein kann, vor allem, wenn die Seite oft neu geladen werden muss. Deswegen habe ich mir eine neue Methode überlegt, bei der die dazustellenden Webseite auf einem anderen Webserver liegt und beim Verbinden mit dem TCP-Server des Boards einfach nachgeladen wird. Der Nachteil ist hier vor allem, dass der Client mit dem Internet verbunden sein muss. Das bedeutet auch, das ein privates Netzwerk mit dem NanoESP als AccesPoint nicht möglich ist. Die Vorteile sind aber komplexere Seiten und schnellere Ladezeiten sowie eine insgesamt Entlastung des Boards. Im Folgenden Stelle ich das System anhand des RGB-LED-Beispiels vor.

Wettbewerbsbeitrag: Neigungssensor – auslesen per IoT- Board, übertragen per WLAN

Tue, 09 Feb 2016 12:57:00 +0100

Beitrag zum Kalenderwettbewerb 2015 von Holger Fritzsch

Mit einer einfachen Zusatzschaltung läßt sich mit dem IoT- Board eine Erschütterung oder Lageänderung von Gegenständen oder Türen detektieren.
Zur Anwendung kommt hier ein RS- Flip Flop bestehend aus 2 Transistoren vom Typ BC547.

Ob man nun eine Tür , Fenster oder Fahrrad überwachen oder Teile vor unbefugter Entnahme sichern will,der kompakte Aufbau des Moduls machts möglich.
Die Schaltung kennt zwei stabile Zustände, nämlich Bereitschaft- und Alarmzustand.
Technisch gesehen entsprechend dem Set- und Reset- Zustand.

Wettbewerbsbeitrag: Quadrocopter Landing Pad

Tue, 09 Feb 2016 12:57:00 +0100

Beitrag zum Kalenderwettbewerb 2015 von Paul Kaczmarczyk

Auszug ausdem PDF:

Projektbeschreibung:

An Weihnachten erhielt ich einen Quadrocopter als Geschenk von meinem Opa. Ich hatte so viel Freude damit, dass ich mir gleich ein zweites Modell vom Typ Blade Inductrix zulegte. Das Fliegen mit dem Quadrocopter macht allerdings besonders viel Spaß, wenn man Aufgaben zu erfüllen hat.

Spielidee

Für die zu bewältigenden Aufgaben kam mir der Gedanke das Landing Pad zu bauen, bei dem die Aufgabe darin besteht durch einen Ring zu fliegen, ohne hängen zu bleiben und dann zu landen, sofern man eine Landefreigabe erhält. Wird die Landefreigabe vom Tower nicht gegeben, so muss man schweben, bis die Landefreigabe erteilt wird. Wird ohne Landefreigabe gelandet, erhält man als Strafe für die Landung einen Punktabzug. Landet man mit Freigabe erhält man Punkte auf sein Konto. Ein Hängenbleiben am Ring soll auch einen Punktabzug zur Folge haben. Um sich mit anderen zu messen, sollen die erreichten Punkte auch in einer Internet-weiten Highscore-Liste namentlich geführt werden. Dieses Geschicklichkeitsspiel soll rundenbasiert ablaufen, wobei die Rundenzeit 60 s beträgt. Läuft die Runde ab, werden die addierten Punkte in die Highscore-Liste eingetragen. Der Start einer neuen Runde soll durch Druck auf einen Taster ermöglicht werden. […]

Wettbewerbsbeitrag: Polarfuchs

Tue, 09 Feb 2016 12:56:00 +0100

Beitrag zum Kalenderwettbewerb 2015 von Nicolaus Cüppers

Der Conrad-Adventskalender „Internet of Things“ war für mich der Einstieg, mich einmal mit dem Thema Arduino zu befassen. Herausgekommen ist das Projekt „Polarfuchs“. Der Name ist angelehnt an das kleinste mir bekannte deutsche Forschungsschiff. Es handelt sich um einen Versuchsaufbau, der ein unbemanntes „Schiff“ nachbildet, was einige Umgebungsdaten erfasst und weiterleitet und parallel dazu seinen eigenen Zustand überwacht.

Es wurde nur der Kalender und zusätzlich eine Stromquelle verwendet. Daher sind die Messmethoden auch nicht unbedingt praxisnahe. Normalerweise würde man für die einzelnen Werte passende Sensoren einsetzen. Das war allerdings nicht die Aufgabe. Vielmehr ging es ja darum, aus einer Hand voll vorhandener Bauelemente das Maximale herauszuholen. Als Schiffsrumpf wird daher der Kalender selbst verwendet. Er bildet durch seinen Plastikkörper mit zahlreichen Einsenkungen eine ideale Schwimmplattform. Es wurden jedoch die üblichen konfektionierten Steckkabel verwendet. Das dem Kalender beiliegende Kabel hätte aber auch gereicht, um die Schaltung aufzubauen. Dann hätte man nur alles etwas enger am Board platzieren müssen.

Wettbewerbsbeitrag: Blumenwächter

Tue, 09 Feb 2016 12:51:00 +0100

Beitrag zum Kalenderwettbewerb 2015 von Leander Hackmann:

Jeder hat Topfpflanzen. Sie verschönern unseren Alltag, benötigen jedoch auch häufig unsere Aufmerksamkeit in Form von Pflege. Um den besten Standort herauszufinden und das regelmäßige Giessen nicht zu vergessen, habe ich folgende Anwendung mit dem Iot-Board entworfen und umgesetzt: ein Datenlogger für Licht und Feuchtigkeit.

Download des Programms

Das Programm

//Blumenwaechter für das NanoESP-Board
//2016 von Leander H.
//Misst alle 30min. Feuchtigkeit und Helligkeit
//Mit Druck auf Taster kann ein Nullpunkt in der Messung als markanter Punkt gesetzt werden#
//Es werden zwei Channels auf Thingspeak.com verwendet (API-Keys in "LightKEY und "MoistureKEY")
//Über "threshold" kann der Pegel zur Warnung eingestellt werden
//Code und Idee von Leander H. -- Funktionen von Fabian Kainka
#include SoftwareSerial.h>
#include Time.h>
//Setup-Bereich
#define SSID "[SSID]"
#define PASSWORD "[Passwort]"
#define LightKEY "[API-KEY]"
#define MoistureKEY "[API-KEY]"
#define threshold 400 //
#define DEBUG true
#define LED_WLAN 13
SoftwareSerial esp8266(11, 12); // RX, TX
int ledGreen = 5;
int ledYellow = 4;
int ledRed = 3;
int sensorPower = 2;
int moistSensor = 2;
String lastminute;
 
const byte thingPost[] PROGMEM = {
 80, 79, 83, 84, 32, 42, 85, 82, 76, 42, 32, 72, 84, 84, 80, 47, 49, 46, 49, 10, 72, 111, 115, 116, 58, 32, 97, 112, 105, 46, 116, 104, 105, 110, 103, 115, 112, 101, 97, 107, 46, 99, 111, 109, 10, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 58, 32, 99, 108, 111, 115, 101, 10, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 32, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 120, 45, 119, 119, 119, 45, 102, 111, 114, 109, 45, 117, 114, 108, 101, 110, 99, 111, 100, 101, 100, 10, 67, 111, 110, 116, 101, 110, 116, 45, 76, 101, 110, 103, 116, 104, 58, 32, 42, 76, 69, 78, 42, 10, 10, 42, 65, 80, 80, 69, 78, 68, 42, 10
};
void setup() {
 pinMode(ledGreen, OUTPUT);
 pinMode(ledYellow, OUTPUT);
 pinMode(ledRed, OUTPUT);
 pinMode(sensorPower, OUTPUT);
 
 Serial.begin(19200);
 esp8266.begin(19200);
 while(!espConfig()){ //Failsafe für WLAN
   delay(200);
 }
 digitalWrite(LED_WLAN, HIGH);
 while(!getTime("chronic.herokuapp.com", "/utc/in+one+hours") == false){ //Failsafe für Zeitsynchro
   delay(200);
 }
 
 sendThingPost(LightKEY, analogRead(A0)); //Erste Übermittlung
 digitalWrite(sensorPower, HIGH);
 delay(200);
 int tmp = analogRead(A2);
 sendThingPost(MoistureKEY, tmp);
 digitalWrite(sensorPower, LOW);
 if(tmp threshold){
    digitalWrite(ledRed, HIGH);
    digitalWrite(ledGreen, LOW);
 }else{
    digitalWrite(ledRed, LOW);
    digitalWrite(ledGreen, HIGH);
 }
}
void loop() {
 String shour, sminute, ssecond;
 if (hour() 9) shour = "0" + String(hour()); else shour = String(hour()); // adjust for 0-9
 if (minute() 9) sminute = "0" + String(minute());  else sminute = String(minute());
 if (second() 9) ssecond = "0" + String(second());  else ssecond = String(second());
 //debug(shour + ":" + sminute + ":" + ssecond);
 
 if(sminute == "0" || sminute == "30"){ //Wird zur halben und vollen Stunde ausgeführt
   if(sminute != lastminute){
         digitalWrite(ledYellow, HIGH);
         if(sendThingPost(LightKEY, analogRead(A0) == false)){
           while(sendThingPost(LightKEY, analogRead(A0) == false)){
             sendThingPost(LightKEY, analogRead(A0));
             delay(200);
           }
         }
         digitalWrite(ledYellow, LOW);
         delay(500);
         digitalWrite(ledYellow, HIGH);
         digitalWrite(sensorPower, HIGH);
         delay(100);
         if(sendThingPost(MoistureKEY, analogRead(A2) == false)){
           while(sendThingPost(MoistureKEY, analogRead(A2) == false)){
             sendThingPost(MoistureKEY, analogRead(A2));
             delay(200);
           }
         }
         digitalWrite(sensorPower, LOW);
         digitalWrite(ledYellow, LOW);
         
         digitalWrite(sensorPower, HIGH);
         delay(100);
         int tmp = analogRead(A2);
         digitalWrite(sensorPower, LOW);
         
         if(tmp threshold){
           digitalWrite(ledRed, HIGH);
           digitalWrite(ledGreen, LOW);
         }else{
           digitalWrite(ledRed, LOW);
           digitalWrite(ledGreen, HIGH);
         }
         
         lastminute = sminute;
   }
 }
 
 if(analogRead(A1) > 500){ //Button zum Setzen eines Nullpunktes
   digitalWrite(ledYellow, HIGH);
   sendThingPost(LightKEY, 0);
   digitalWrite(ledYellow, LOW);
   delay(500);
   digitalWrite(ledYellow, HIGH);
   sendThingPost(MoistureKEY, 0);
   digitalWrite(ledYellow, LOW);
   delay(1000);
 }
}
//Verwendete Funktionen von Fabian Kainka folgen ab hier:
//-----------------------------------------ThingsSpeak Functions------------------------------------
boolean sendThingPost(String key, int value)
{
 boolean succes = true;
 String  Host = "api.thingspeak.com";
 String msg = "field1=" + String(value);
 succes &= sendCom("AT+CIPSTART="TCP","" + Host + "",80", "OK");
 String postRequest = createThingPost("/update", key, msg);
 if (sendCom("AT+CIPSEND=" + String(postRequest.length()), ">"))
 {
   esp8266.print(postRequest);
   esp8266.find("SEND OK");
   if (!esp8266.find("CLOSED")) succes &= sendCom("AT+CIPCLOSE", "OK");
 }
 else
 {
   succes = false;
 }
 return succes;
}  
String createThingPost(String url, String key, String msg)
{
 String xBuffer;
 for (int i = 0; i sizeof(thingPost); i++)
 {
   char myChar = pgm_read_byte_near(thingPost + i);
   xBuffer += myChar;
 }
 String append = "api_key=" + key + "&" + msg;
 xBuffer.replace("*URL*", url);
 xBuffer.replace("*LEN*", String( append.length()));
 xBuffer.replace("*APPEND*", append);
 return xBuffer;
}
String createThingGet(String url, String key)
{
 String xBuffer;
 for (int i = 0; i sizeof(thingPost); i++)
 {
   char myChar = pgm_read_byte_near(thingPost + i);
   xBuffer += myChar;
 }
 String append = "api_key=" + key;
 xBuffer.replace("POST", "GET");
 xBuffer.replace("*URL*", url);
 xBuffer.replace("*LEN*", String( append.length()));
 xBuffer.replace("*APPEND*", append);
 return xBuffer;
}
String createThingGet(String url, String key, String msg)
{
 String xBuffer;
 for (int i = 0; i sizeof(thingPost); i++)
 {
   char myChar = pgm_read_byte_near(thingPost + i);
   xBuffer += myChar;
 }
 String append = "api_key=" + key + "&" + msg;
 xBuffer.replace("POST", "GET");
 xBuffer.replace("*URL*", url);
 xBuffer.replace("*LEN*", String( append.length()));
 xBuffer.replace("*APPEND*", append);
 return xBuffer;
}
String getTCP(String Host, String Subpage)
{
 boolean succes = true;
 succes &= sendCom("AT+CIPSTART="TCP","" + Host + "",80", "OK");
 String getRequest = "GET " + Subpage + " HTTP/1.1rnHost:" + Host + "rnrn";
 succes &= sendCom("AT+CIPSEND=" + String(getRequest.length() + 2), ">");
 return sendCom(getRequest);
}
boolean getTime(String Host, String Subpage)
{
 boolean succes = true;
 int xyear, xmonth, xday, xhour, xminute, xsecond;  //lokal variables
 succes &= sendCom("AT+CIPSTART="TCP","" + Host + "",80", "OK");
 String getRequest = "GET " + Subpage + " HTTP/1.1rnHost:" + Host + "rn";
 succes &= sendCom("AT+CIPSEND=" + String(getRequest.length() + 2), ">");
 esp8266.println(getRequest);
 if (esp8266.find("+IPD"))
 {
   if (esp8266.find("rnrn"))
   {
     xyear = esp8266.parseInt();
     xmonth = esp8266.parseInt();
     xday = esp8266.parseInt();
     xhour = esp8266.parseInt();
     xminute = esp8266.parseInt();
     xsecond = esp8266.parseInt();
     if (xday 0) xday *= -1;          //Because of date seperator - parseInt detects negativ integer
     if (xmonth 0) xmonth *= -1;    //Because of date seperator - parseInt detects negativ integer
     setTime(xhour, xminute, xsecond, xday, xmonth, xyear);
     sendCom("AT+CIPCLOSE", "OK");
     return true;
   }
   else return false;
 }
 else return false;
}
//-----------------------------------------Config ESP8266------------------------------------
boolean espConfig()
{
 boolean succes = true;
 esp8266.setTimeout(5000);
 succes &= sendCom("AT+RST", "ready");
 esp8266.setTimeout(1000);
 if (configStation(SSID, PASSWORD)) {
   succes &= true;
   debug("WLAN Connected");
   debug("My IP is:");
   debug(sendCom("AT+CIFSR"));
 }
 else
 {
   succes &= false;
 }
 //shorter Timeout for faster wrong UPD-Comands handling
 succes &= sendCom("AT+CIPMODE=0", "OK");  //So rum scheit wichtig!
 succes &= sendCom("AT+CIPMUX=0", "OK");
 return succes;
}
boolean configTCPServer()
{
 boolean succes = true;
 succes &= (sendCom("AT+CIPMUX=1", "OK"));
 succes &= (sendCom("AT+CIPSERVER=1,80", "OK"));
 return succes;
}
boolean configTCPClient()
{
 boolean succes = true;
 succes &= (sendCom("AT+CIPMUX=0", "OK"));
 //succes &= (sendCom("AT+CIPSERVER=1,80", "OK"));
 return succes;
}
boolean configStation(String vSSID, String vPASSWORT)
{
 boolean succes = true;
 succes &= (sendCom("AT+CWMODE=1", "OK"));
 esp8266.setTimeout(20000);
 succes &= (sendCom("AT+CWJAP="" + String(vSSID) + "","" + String(vPASSWORT) + """, "OK"));
 esp8266.setTimeout(1000);
 return succes;
}
boolean configAP()
{
 boolean succes = true;
 succes &= (sendCom("AT+CWMODE=2", "OK"));
 succes &= (sendCom("AT+CWSAP="NanoESP","",5,0", "OK"));
 return succes;
}
boolean configUDP()
{
 boolean succes = true;
 succes &= (sendCom("AT+CIPMODE=0", "OK"));
 succes &= (sendCom("AT+CIPMUX=0", "OK"));
 succes &= sendCom("AT+CIPSTART="UDP","192.168.255.255",90,91,2", "OK"); //Importand Boradcast...Reconnect IP
 return succes;
}
//-----------------------------------------------Controll ESP-----------------------------------------------------
boolean sendUDP(String Msg)
{
 boolean succes = true;
 succes &= sendCom("AT+CIPSEND=" + String(Msg.length() + 2), ">");    //+","192.168.4.2",90", ">");
 if (succes)
 {
   succes &= sendCom(Msg, "OK");
 }
 return succes;
}
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);
 }
}

[collapse]

Wettbewerbsbeitrag: IoTeaTimer

Sun, 31 Jan 2016 12:48:25 +0100

Sie kennen das? Sie sitzen in Ihrem Arbeits- oder Bastelzimmer, ganz vertieft in Ihr neues Pretzelboard, plötzlich schießt es siedendheiss durch den Kopf: “Der Tee!” - doch der ist längst eiskalt, steht in der Küche und hat sich in eine tiefschwarze Jauche verwandelt, die höchstens noch als Pflanzenschutzmittel taugt.

Das ist der Auftritt für den IoTeaTimer. Eine Eieruhr mit WLAN-Anschluss? Nein, Ihr persönlicher Erinnerungsagent … lesen Sie weiter in der umfassenden Projektdokumentation, hier als PDF, zum Download.

Wettbewerbsbeitrag: Wassermelder mit Twitter-Alarmmeldung

Fri, 29 Jan 2016 06:57:19 +0100

Beitrag zum Kalenderwettbewerb 2015 von Bernhard Kaiser & Michael Gaus

Bei diesem Projekt handelt es sich um einen Wassermelder, der optisch, akustisch und per Twitter-Meldung Alarm gibt, sobald an den Sensorkontakten Wasser detektiert wird. Er kann z.B. zur Überwachung auf austretendes Wasser aus Waschmaschine oder Spülmaschine dienen und helfen, rechtzeitig vor größeren Überschwemmungen eingreifen zu können. Als Sensorkontakt können einfach 2 Drähte mit abisolierten Enden genommen werden, so wie es auch auf dem Foto zu sehen ist. Verwendet wurden ausschließlich die Bauteile der beiden Adventskalender.

Fernbedienung über WLAN oder Alt und Neu ergänzen sich

Wed, 27 Jan 2016 14:46:30 +0100

Ein Beitrag per Mail von Holger Fritzsch:

Das IoT- Baord regt zum experimentieren an. Auch wenn ich den Kalender vor Weihnachten nicht bekam, so konnte ich Dank der Veröffentlichung des Handbuches die Sache mitverfolgen. Inzwischen habe ich ein Pretzelboard erworben.

Es wird per kostenloser Android- App („UDP- Sender“) im Zusammenhang mit dem Experiment vom Tag 5 (Autor F.Kainka) die Garagenbeleuchtung ein- bzw. ausgeschaltet.

So kann man ein altes Handy, dessen Akku schwächelt, einer Zweitverwendung zuführen. Das Handy baut eine Access- Verbindung zum ESP- Modul auf.

Anleitung für dein erstes User Projekt

Mon, 25 Jan 2016 18:42:04 +0100

Damit du dein Projekt hochladen kannst, musst du dich zunächst auf dieser Seite anmelden und einloggen. Dann erscheint oben eine Leiste, wie die auf dem unteren Bild:

Neuer Beitrag

Auf dem Bild ist auch schon der Punkt ausgewählt, unter dem du dein neues Projekt erstellen kannst. Als nächstes erscheint eine Seite die folgendermaßen aussieht:

Beitrag bearbeiten

Hier kannst du deine Projektbeschreibung eintippen und deine Bilder einfügen. Ein passender Titel hilft auch anderen, den Beitrag schnell zu finden. Wenn dein Artikel fertig ist, klickst du auf “Zur Revision vorlegen”. Dann kann es noch ein wenig dauern, bis der Beitrag schließlich unter User Projekte erscheint, denn ein Administrator schaut noch einmal drüber, ob alles korrekt ist. Übrigens, unter der Texteingabe ist außerdem ein Feld, mit dem du festlegen kannst, ob anderen Nutzer Kommentare zu deinem Projekt abgeben dürfen. Dadurch ist es auch möglich, neue Projektideen zu diskutieren oder gemeinsam das Projekt weiter zu Entwickeln.

Pinout NanoESP & Pretzel Board

Tue, 12 Jan 2016 08:24:58 +0100

Download PDF: Pinout Pretzel Board

Tag 24: Feuermelder für den Weihnachtsbaum

Thu, 24 Dec 2015 00:01:19 +0100

Das Abschlussprojekt besteht aus mehreren Elementen, die Sie im Laufe der Adventszeit kennengelernt haben. Eine Funktion ist die am vorrangegangenen Tag vorgestellte Cheerlights-Funktion. Sie können weiterhin die aktuelle Farbe des Cheerlights-Projekts empfangen und mit der RGB-LED darstellen. Außerdem wird das Board zur Langzeitüberwachung der Temperatur eingesetzt. Gleichzeitig kann das Board einen Alarmton ausgeben, wenn die Temperatur einen bestimmten Wert überschreitet, z.B. weil ein Feuer entsteht. Und als letzte Funktion kann das Board als Weihnachtsglocke eingesetzt werden, indem es über ein zeitgesteuertes TalkBack-Kommando dazu gebracht wird, den Song Jingle Bells zu spielen. Alles in allem ist das heutige Projekt ein Allrounder für den Weihnachtsbaum.

Tag 23: Cheerlights

Wed, 23 Dec 2015 00:01:25 +0100

Der heutige Versuch basiert auf einem Projekt von Hans Scharler, das sich Cheerlights nennt. Die Idee: weltweit vernetzte Lichter, die sich simultan über Twitter Kommandos steuern lassen. Eine gutes Beispiel, dass die Welt mit dem Internet immer enger zusammenwächst.

Hinter dem heutigen Türchen befindet sich ein viertes Verlängerungskabel mit dem sich nun auch endlich die RGB-Led abseits vom Board platzieren lässt. Das kann besonders praktisch sein, wenn Sie beispielsweise das Board im Weihnachtsbaum verstecken wollen während die RGB-LED die Krone des Baums schmückt.

Tag 22: TalkBack

Tue, 22 Dec 2015 00:01:22 +0100

In dem heutigen Projekt geht es um eine weitere App der ThingSpeak-Seite, nämlich der TalkBack-App. Mit dieser Funktion ist es möglich, ein Kommando zu erstellen, das vom Controller ausgelesen und ausgeführt wird. Was mit nur einem Controller zunächst sinnlos erscheint, macht Sinn, wenn man zwei oder sogar ein ganzes Netzwerk von Controllern einsetzt. Einige Boards können dann als Sensoren agieren, beispielsweise mit Bewegungsmeldern, und beim Entdecken einer Bewegung ein TalkBack-Kommando senden. Ein weiteres Modul liest das Kommando von der ThingSpeak-Seite und öffnet dann die Tür oder meldet Alarm.

Tag 21: Twitter Alarmanlage

Mon, 21 Dec 2015 00:01:32 +0100

Bei dem Projekt des heutigen Tages handelt es sich um eine Alarmanlage, mit der Sie beispielsweise überprüfen können, ob jemand ungefragt eine Schublade öffnet. Laufend wird überprüft, ob auf den angeschlossenen Lichtsensor zu viel Licht fällt. Ist dies der Fall ertönt ein Alarmsignal und zusätzlich wird eine Nachricht über Twitter gesendet.

Hinter dem Türchen des heutigen Tages befindet sich ein Piezo-Lautsprecher, der als Alarmsignalgeber verwendet wird. Der Aufbau des heutigen Tages sieht folgendermaßen aus:

Tag 20: Twitch

Sun, 20 Dec 2015 00:01:47 +0100

Die Webseite ThingSpeak bietet einiges mehr als nur die Langzeitüberwachung von Sensoren. Das heutige Projekt ist den Projekten von Tag 9 und Tag 10 in der Grundidee ähnlich. Es werden nämlich Informationen von einer Webseite aus dem Internet bezogen. In diesem Fall geht es darum ob ein bestimmter Stream gerade online ist oder nicht.

Dabei gibt es zwei bedeutende Vorteile der ThingSpeak-Variante gegenüber den ersten Versuchen. Erstens kann über die ThingSpeak Seite auch Webseiten über HTTPS (HyperText Transfer Protocol Secure) angesprochen werden, während das Modul nur das unsicherer HTTP Protokoll unterstützt. Zweites kann die Webseite wichtige Informationen bereits vorfilten und somit die vom Controller zu bearbeitende Datenmenge deutlich verringern.

Tag 19: ThingSpeak

Sat, 19 Dec 2015 00:01:53 +0100

In den letzten Tagen der Adventszeit beschäftigen wir uns mit einem ganz neuen Thema, nämlich der Internetseite ThingSpeak. Diese Seite wurde speziell für das Thema Internet of Things entwickelt und hält verschiedene praktische Funktionen für Sie bereit.

Bevor Sie also wie sonst üblich, den Aufbau und das Programm angehen, müssen Sie sich zunächst einen Account auf der Seite

www.ThingSpeak.com

erstellen. Loggen Sie sich dann mit Ihren Nutzerdaten unter dem Punkt Sign In ein. Sie sehen eine Seite, die Ihre Channels zeigt. Da Sie noch keine Kanäle haben, wird diese Seite ziemlich leer aussehen. Klicken Sie auf New Channel und vergeben einen Namen, z.B. Light, denn Sie werden in diesem Projekt die Helligkeit messen. Unter dem Punkt Field1 können Sie nun noch einen Namen für das Feld vergeben, evtl. Brightness. Alle anderen Felder können vorerst leer bleiben.

Tag 18: Universal Fernbedienung

Fri, 18 Dec 2015 00:01:00 +0100

Gestern haben Sie einen Empfänger für Infrarotfernbedienungen gebaut. Heute bauen Sie sozusagen die Fernbedienung selbst. Genauer gesagt basteln Sie sich eine per Computer oder Smartphone bedienbare Universalfernbedienung, mit der Sie Ihren Fernseher oder andere Geräte steuern können, auch wenn die originale Fernbedienung mal wieder nicht auffindbar ist.

Damit Sie das Projekt angehen können, benötigen Sie das Bauteil, das sich hinter dem heutigen Türchen befindet, die IR-Diode. Sie sieht aus wie eine einfache LED, allerdings sendet sie Licht im nicht sichtbaren Infrarotbereich aus. Die IR-Signale sind aber für eine digitale Kamera sichtbar. Der Aufbau des heutigen Tages können Sie dem unteren Bild entnehmen. Wundern Sie sich nicht, dass die IR-LED keinen Vorwiderstand bekommt. Der wirksame Vorwiderstand ist allein der On-Widerstand des Ports von ca. 30 Ohm. Damit ist der Strom durch die Diode recht groß, die gesendeten Impulse sind aber so kurz, dass die Diode keinen Schaden nimmt.

Tag 17: IR-Modul

Thu, 17 Dec 2015 00:01:46 +0100

Das Projekt des heutigen Tages ermöglicht die Steuerung des Controllers per Fernbedienung. Mit selbst wählbaren Tasten auf einer Infrarot-Fernbedienung Ihrer Wahl können Sie die Farbe der RGB-LED verändern und die Hintergrundfarbe der Webseite gleich mit.

Hinter dem heutigen Türchen befindet sich das für das heutige Projekt bedeutende Bauteil, nämlich das Infrarot-Empfangsmodul. Sie können das Modul wie auf dem unteren Bild ganz ohne Kabel anschließen. Das Programm setzt die entsprechenden Pins so, dass das Modul mit Strom versorgt wird.

Tag 16: GPIO Control

Wed, 16 Dec 2015 00:01:26 +0100

Das Projekt des heutigen Tages ermöglicht die einfache Ansteuerung der digitalen Pins D2-D7 per Webseite. Der Status des jeweiligen Pins wird ebenfalls auf der Webseite dargestellt, sodass man nie den Überblick verliert.

Damit sich der Zustand der Pins gut überprüfen lässt, empfiehlt sich ein Aufbau wie auf dem unteren Bild. Sowohl die RGB-LED als auch die normale LED kommen zum Einsatz. Die Kathoden der LEDs sind diesmal aber nicht an die lange Masseleitung auf der Außenseite des Boards angeschlossen, sondern liegen ebenfalls an einem digitalen Ausgang. Nur wenn diese Pins low geschaltet sind, können die LEDs also leuchten.

Tag 15: Lichtsensor

Tue, 15 Dec 2015 00:01:56 +0100

Das Projekt des heutigen Tages benutzt die Webseite des Webservers nicht als Steueroberfläche, sondern als Ausgabeelement. Die über einen Helligkeitssensor gemessene Helligkeit wird als Relativwert übersichtlich dargestellt.

Hinter dem heutigen Türchen befindet sich ein Fototransistor, der als Lichtsensor dient. Der Fototransistor sieht aus wie ein LED, sollte aber nicht mit einer verwechselt werden. Den Aufbau des heutigen Versuchs zeigt das Bild. Der Kollektor des Fototransistors ist der kürzere Anschluss und liegt an +5 V.

Tag 14: Webserver für die RGB-LED

Mon, 14 Dec 2015 00:01:19 +0100

In dem Projekt des heutigen Tages geht es um die Ansteuerung der RGB-LED mittels Webserver. Über eine übersichtliche Oberfläche kann die Farbe der LED verändert werden. Die Webseite wurde außerdem angepasst, und sollte auch auf Smartphones gut darstellbar sein.

Die Webseite mit ColorPicker

Hinter dem heutigen Adventskalendertürchen befindet sich erneut ein Widerstand, diesmal aber mit 10 kΩ (Braun, Schwarz, Orange). Diesen werden Sie für den morgigen Versuch benötigen.

Tag 13: Webseite mit Buttons

Sun, 13 Dec 2015 00:01:54 +0100

In dem heutigen Versuch ist die Darstellung der Webseite noch ausgefeilter. Außerdem gibt es nun auch Steuerelemente, über die eine LED deutlich komfortabler gesteuert werden kann.

So schließen Sie die LED mit Vorwiderstand am Pin D9 an

Der Aufbau des heutigen Versuchs unterscheidet sich nicht vom dem des gestrigen: Eine LED am Pin D9 die sich über das Modul steuern lässt. Als zusätzliches Bauteil finden Sie hinter dem Kalendertürchen erneut einen Widerstand mit 1 kΩ. Bei Bedarf können sie nun die Helligkeit einer LED reduzieren, indem Sie zwei Widerstände in Reihe schalten.

Tag 12: Autonomer Webserver

Sat, 12 Dec 2015 00:01:02 +0100

Die Ergebnisse des gestrigen Versuches gilt es nun wieder in einem autonomen Programm zu verwenden. Das heutige Programm sendet aber nicht nur eine einfache Webseite an den Browser, sondern es ermöglicht zusätzlich die Ansteuerung einer LED.

Hinter dem heutigen Türchen befindet sich ein 9-V-Batterieclip mit dem Sie das Board mobil machen können. Als Alternative können Sie auch eine Power Bank (ein Akku-Pack, normalerweise für Handys) verwenden. Wenn Sie die 9V-Batterie verwenden wollen, achten Sie darauf, dass der rote Draht mit Vin verbunden werden muss, und der schwarze mit GND. Auf dem unteren Bild sehen Sie den Aufbau des heutigen Versuchs mit externer Stromversorgung.

Tag 11: TCP Webserver

Fri, 11 Dec 2015 00:01:31 +0100

In den vorangegangenen Versuchen haben wir uns viel mit dem Thema TCP und dem Zugriff auf Webserver beschäftigt. Heute soll das Modul erstmalig selbst als Webserver fungieren.

Hinter dem Türchen des 11. Tages befindet sich ein besonderes Kabel, das demnächst noch sehr nützlich sein wird. Ein spezieller Aufbau ist heute nicht nötig, da das Programm ähnlich wie das Serial Monitor Programm des ersten Tages funktioniert.

Das Programm: Day11_TCPServer

Ändern Sie wie bisher die WLAN-Daten und laden Sie das Programm auf Ihr Board. Dann starten Sie den Monitor. Es kann wieder ein paar Sekunden dauern, bis die Meldung erscheint, dass das Board verbunden ist. Wenn die Erfolgsmeldung erschienen ist und die IP des Moduls angezeigt wird, können Sie im Serial Monitor mit dem ersten Befehl beginnen:

Tag 10: Temperaturanzeige

Thu, 10 Dec 2015 00:01:55 +0100

Bei dem heutigen Projekt handelt es sich um eine intuitive Anzeige der aktuellen Temperatur. Mit nur einem Blick kann man abschätzen, ob es sinnvoll ist, eine warme Jacke mitzunehmen.

Hinter dem heutigen Türchen befindet sich eine weitere LED, allerdings keine gewöhnliche. Es handelt sich um eine RGB-LED. RGB steht für Red, Green, Blue oder Rot, Grün, Blau denn die LED besteht eigentlich aus mehreren LEDs mit einem gemeinsamen Kathodenanschluss. Durch eine Kombination der verschiedenen Farben mit unterschiedlichen Helligkeiten, ist es möglich fast jede Farbe darzustellen. Die LED kann, wie im Bild gezeigt, mit Vorwiderständen an die PWM Ausgänge D3, D5, D6 des Controllers angeschlossen werden.

Tag 9: TCP Uhrzeit

Wed, 09 Dec 2015 00:01:25 +0100

Das Projekt des heutigen Tages benutzt die Funktionen des vorigen Tests, um selbständig Informationen aus einer Webseite zu beziehen. Konkret lädt das Programm die aktuelle Uhrzeit von einer speziell dafür konzipierten Seite und stellt damit die per Library realisierte interne Uhr des Controllers.

Hinter dem heutigen Türchen befindet sich erneut ein Widerstand mit 1 kΩ. Für den morgigen Versuch werden alle drei Widerstände benötigt.

Das Programm: Day9_TCPAutoTime

Während das gestrige Programm noch größtenteils per Hand bedient werden musste, arbeitet das heutige Programm weitgehend autonom. Völlig selbständig verbindet sich der Controller mit der Webseite:

Tag 8: Ein Browser

Tue, 08 Dec 2015 00:01:36 +0100

In den vorangegangen Tagen haben wir uns vor allem mit dem UDP-Protokoll befasst, mit dem sich einfach und direkt Daten verschicken lassen. Die folgenden Tage werden wir uns mit dem TCP-Protokoll (Transmission Control Protocol) beschäftigen. TCP lässt immer nur eine Verbindung zwischen genau zwei Rechnern zu. Es kommt vor allem im Internet zum Einsatz wenn es ums Browsen auf Webseiten geht.

Hinter dem heutigen Türchen findet sich erneut ein Widerstand 1 kΩ (Braun, Schwarz, Rot). Wie auch bei allen anderen Bauteilen gilt: gut aufbewahren, auch wenn das Bauteil am heutigen Tag noch nicht zum Einsatz kommen wird.

Tag 7 (special): Hinweis für Arduino Neulinge - Teil 2

Mon, 07 Dec 2015 00:01:26 +0100

Der erste Teil Arduino Beginner Kurses war scheinbar für viele sehr hilfreich. Deswegen habe ich mich dazu entschlossen, auch den zweiten Teil des Handbuches zu überarbeiten und online zu stellen.

In diesem zweiten Teil geht es nun darum, Programme selbst zu schreiben und dabei auch etwas von den Grundlagen in der Arbeit mit Mikrocontrollern zu lernen. Diese Anleitung habe ich bewusst erst heute veröffentlicht, da an dem heutigen Tag auch alle nötigen Bauteile aus dem Adventskalender vorhanden sind, um die kleinen Projekte selbst testen zu können.

Tag 7: Analoger Sensor

Mon, 07 Dec 2015 00:01:23 +0100

Im letzten Projekt wurde mit einem Taster die einfachste Form eines Sensors behandelt. Diesmal soll ein Poti als analoger Sensor zum Einsatz kommen um permanent Messwerte in das Netzwerk zu senden.

Hinter dem 7. Türchen des Adventskalenders befindet sich ein Poti mit 10 kΩ. Der Aufbau wird auf dem untern Bild gezeigt.

Der Aufbau mit Potentiometer an A0

Das Programm: Day7_UDPAnalog

! Achtung: Einige MAC-Nutzer berichten von einem Bug in dem PackerSender-Programm, welcher nicht erlaubt, die Ports umzustellen. Es gibt allerings auch die Möglichkeit die Ports in dem Arduino Programm zu verändern. Falls das Problem auftritt, müssen Sie für den heutigen Versuch die Zeile 100 von
succes &= sendCom(“AT+CIPSTART="UDP","192.168.255.255",90,91,2”, “OK”);
in
succes &= sendCom(“AT+CIPSTART="UDP","192.168.255.255",55005,55006,2”, “OK”);
umändern.

Tag 6: UDP Button

Sun, 06 Dec 2015 00:01:27 +0100

In dem gestrigen Programm wurden erste Kommandos vom Controller ausgewertet. Das heutige Programm behält diese Funktion, kann aber nun zusätzlich selbstständig ein Kommando in das Netzwerk senden.

Hinter dem heutigen Türchen verbirgt sich ein Tastschalter. Er dient hier als einfacher Sensor. Verbinden Sie ihn mit dem Controller wie auf dem Aufbaubild gezeigt.

Der Schalter platzsparend an D8 angeschlossen

Das Programm: Day6_UDPSwitch

! Achtung: Einige MAC-Nutzer berichten von einem Bug in dem PackerSender-Programm, welcher nicht erlaubt, die Ports umzustellen. Es gibt allerings auch die Möglichkeit die Ports in dem Arduino Programm zu verändern. Falls das Problem auftritt, müssen Sie für den heutigen Versuch die Zeile 83 von
succes &= sendCom(“AT+CIPSTART="UDP","192.168.4.255",90,91”, “OK”);
in
succes &= sendCom(“AT+CIPSTART="UDP","192.168.4.255",55005,55006”, “OK”);
umändern.

Fritzing Bauteil - NanoESP & Pretzel Board

Sat, 05 Dec 2015 14:35:14 +0100

Fritzing ist eine Software, mit der man leicht und unkompliziert Aufbaupläne vor allem für Steckboard-Projekte erstellen kann. Viele verschiedene Arduino Controller aber auch Raspberry Pi und andere Boards weden schon in der Software unterstütz und erleichern so den Nutzern, einen übersichtlichen Plan zu erstellen. Dadurch fällt es einem selbst und auch anderen Nutzern leicht, das Projekt nachzuvollziehen und nachzubauen.
Für die Bilder des Adventskalender habe ich ebenfalls die Fritzing Software benutzt und mir dafür ein NanoESP-Bauteil erstellt. Für alle, die ebenfalls mit dem Bauteil Schaltungen mit Fritzing erstellen wollen gibt es hier das Bauteil zum Downloaden.

Tag 5: LED Schalten

Sat, 05 Dec 2015 00:01:37 +0100

In dem heutigen Programm geht es nun endlich darum, Hardware über das UDP-Protokoll zu steuern. In diesem Fall wird eine LED mit einfachen Befehlen ein- und ausgeschaltet.

Hinter dem fünften Türchen befindet sich eine LED. Der passende Vorwiderstand befand sich schon im gestrigen Fach. Bauen Sie die Schaltung auf, wie es das Bild zeigt.

So schließen Sie die LED mit Vorwiderstand am Pin D9 an

Das Programm:****Day5_UDPLED

Tag 4: UDP Bidirektional

Fri, 04 Dec 2015 00:01:21 +0100

In dem gestrigen Projekt wurde die UDP-Kommunikation in eine Richtung, also vom Board zum PC getestet. In diesem Programm wird das Modul so eingestellt, dass eine Kommunikation auch in die andere Richtung möglich ist, fast so wie in einem Chat.

Hinter dem vierten Türchen des Adventskalenders befindet sich ein Widerstand mit 1 kΩ (Braun, Schwarz, Rot). Das Bauteil wird in dem heutigen Versuch noch nicht verwendet, sollte aber unbedingt für später aufbewahrt werden.

Tag 3: UDP-Send

Thu, 03 Dec 2015 00:01:45 +0100

In dem heutigen Projekt werden zum ersten Mal Daten zwischen Board und PC über das WLAN ausgetauscht. Voraussetzung dafür ist, dass Ihr Rechner über einen WLAN-Adapter verfügt. Es wird das sogenannte UDP (User Datagram Protocol) verwendet. Ein weiteres Programm auf der PC Seite sorgt für das erfolgreiche Empfangen der Nachrichten.

Hinter dem dritten Türchen des Kalenders finden Sie ein isoliertes Kabel das für den Aufbau von Schaltungen unerlässlich ist. Als Vorbereitung für spätere Versuche können Sie die Versorgungsleitungen Masse und VCC auf die äußeren Bahnen legen.

Tag 2: Google Ping

Wed, 02 Dec 2015 00:01:40 +0100

Mit dem heutigen Projekt wird getestet, ob Sie den Google-Server erreichen können. Dies dient Ihnen als Test, ob eine prinzipielle Verbindung zum Internet vorhanden ist oder beispielsweise eine Firewall das NanoESP-Board blockiert.

Hinter dem heutigen Türchen finden Sie ein Steckboard. Das Steckboard dient später als Experimentierplattform um Sensoren und anderer Elemente anschließen zu können. Am besten ist es, wenn Sie den Controller wie auf dem untern Bild gezeigt auf das Steckboard stecken. Dadurch bleibt der meiste Platz für Experimente während das WLAN-Modul hinten über das Steckboard hinausragt. Das Micro-USB Kabel hängt dann zwischen den Kontaktseiten und stört nur minimal.

Tag 1 - Hinweis für Arduino Neulinge

Tue, 01 Dec 2015 11:14:14 +0100

Der erste Tag des Adventskalenders ist bereits rum und ich war überrascht und erfreut über all die Kommentare. Sehr gefreut hat mich vor allem die Bereitschaft der Community sich gegengeseitigt mit diesem zugegebenermaßen nicht völlig einfachen Thema zu helfen.

Aus den Kommentaren konnte ich außerdem herauslesen, dass der Ein oder Andere noch nie mit Arduino oder Mikrocontrollern im Allgemeinen zu tun hatte. Deswegen habe ich unter dem unten stehen Link einen längeren Artikel veröffentlicht, der ein Auszug aus einem meiner ersten Schnelleinstieg Hefte darstellt. Ich hoffe, dass ich damit einigen Leuten den Einstieg in den Adventskalender erleichtern kann.

Tag 1: Die ersten Schritte

Tue, 01 Dec 2015 00:01:38 +0100

Es ist der erste Tag im Dezember und damit Zeit, das erste Türchen zu öffnen. Hinter dem Türchen befindet sich das wichtigste Bauteil dieses Kalender, nämlich das Arduino-kompatible NanoESP-Board mit integrierten WLAN-Modul, um das es in diesem Kalender geht.

Das NanoESP Board

Wie man an der Platine recht gut erkennen kann, besteht das Board aus zwei Komponenten. Bei der linken Hälfte handelt es sich um ein Arduino kompatibles Mikrocontrollersystem, das mit dem Arduino Nano verglichen werden kann. Der rechte Teil ist das WLAN-Modul mit der Bezeichnung ESP8266. Diese beiden Komponenten kommunizieren über eine per Software generierte serielle Schnittstelle miteinander. Dabei fungiert die Arduino-Seite eher als der Chef, der die Kommandos an das WLAN-Modul leitet. Einige dieser Kommandos werden schon heute am ersten Tag ausprobiert.

Day 0: Alternative zum ausverkauften Adventskalender (Spoiler Alert)

Fri, 27 Nov 2015 15:18:35 +0100

Der Internet of Things Adventskalender ist nun weitestgehendst ausverkauft. Nur in vereinzelten Conrad Filialen sind noch Exemplare zu erhalten. Viele Leute haben mich allerdings gefragt, ob ich eine Bauteileliste veröffentlichen kann, damit man sich einen Kalender selbst zusammenstellen kann.

Es ist natürlich nicht möglich, die exakt gleichen Bauteile bei jedem Händler zu bekommen, dafür ist die Menge an Herstellern einfach zu groß. Dennoch habe ich mich bemüht, eine Einkaufsliste zusammenzustellen und dabei darauf geachtet, dass möglichst kompatible Elemente verwendet werden (also identisches Pin-Layout, Kenndaten etc.). Es kann dennoch sein, dass bei dem ein oder anderen Versuchen eine Variation der Schaltung verwendet werden muss.

Tag 0: Alle Projekte für Ungeduldige (Spoiler Alert)

Tue, 10 Nov 2015 18:33:13 +0100

Das Interesse am IoT-Adventskalender scheint recht groß zu sein. Daher kam öfter die Frage auf, wann die Programme veröffentlicht werden.

Mein eigentlicher Plan war, dass die Programme jeden Dezembertag zusammen mit dem passenden Artikel veröffentlicht werden. Dies wird auch weiter der Fall sein, aber für alle diejenigen, die das Warten nicht mehr ertragen, gibt es hier alle Programme in einem Ordner zum Download:

Download: CalenderIoT

Achtung:

Es gab eine Änderung im Programm vom Tag 10. Der Webservice, den ich in diesem Programm verwendet habe, hat vor wenigen Tagen seinen Dienst eingestellt. Ich habe nun einen eigenen Service gestartet, der seine Daten von der Webseite http://www.openweathermap.com/ bezieht. Der Link zu dem neuen und auch in der neuen Versio des Programms verwendeten Dienst lautet:

Beispielprojekt - NanoESP & Pretzelboard

Thu, 24 Sep 2015 10:25:30 +0200

In dem hier vorgestellten Beispielprojekt soll eine einfache Ansteuerung einer bunten RGB-LED realisiert werden. Die Steuerung soll über eine Webseite oder auch über eine Smartphone-App möglich sein. Die Verbindung kann sowohl über einen Router, und damit auch aus der Ferne über das Internet, als auch über den AccesPoint des Moduls hergestellt werden. Es ändert sich jeweils nur die zu adressierende IP.

Sie können das vorgestellte Programm hier herunterladen

Der Aufbau der Schaltung auf einem Steckboard

Die Programmierung erfolgt über die Arduino-Oberfläche, die sich jeder kostenlos auf der Seite www.arduino.cc herunterladen kann. Als Board kann einfach das Arduino Nano Board ausgewählt werden (ATmega328p Version). Bevor das Programm hochgeladen wird, müssen die WLAN Daten am Anfang des Programes eingetragen werden.

Diskusionen und Hilfe

Wed, 23 Sep 2015 12:29:36 +0200

Auf dieser Seite können Sie Probleme diskutieren und Hilfe ersuchen rund um das Lernpaket IoT finden.

Achtung:

www.temp.fkainka.de

Durch anpassen der URL kann die Temperatur einer Stadt abgefragt werden. Als Beispiel für Essen:

Technische Daten NanoESP & Pretzel Board

Wed, 23 Sep 2015 08:05:57 +0200

Auf dieser Seite finden Sie einige Technische Daten rund um das Modul

Technische Daten:

Mikrocontroller: ATmega328
Flash Speicher: 32 KB (davon 0,5 KB für den Bootloader)
SRAM: 2 KB
EEPROM: 1 KB
Taktrate: 16 MHz
I/O-Pins: 20 (Davon 2 für die Kommunikation mit dem WLAN-Modul
- davon PWM: 6
- davon analoge Eingänge: 6
USB-to-Serial Chip: CH340G
Betriebsspannung: 5 V
Empfohlene Eingangsspannung: 7-12 V
Maximaler Strom pro I/O-Pin: 40 mA
Belastbarkeit des 3.3-V-Ausgangs: 50 mA

WLAN-Modul: ESP8266

Schnellstart Anleitung - NanoESP & Pretzelboard

Tue, 22 Sep 2015 08:05:40 +0200

Wenn Sie das erste Mal das Board über den MicroUSB-Anschluss verbinden, wird Ihr PC versuchen, einen Treiber zu installieren. Gelingt dies nicht automatisch, laden Sie den Treiber hier herunter.

Die einfachste Art, das Entwicklungsboard zu programmieren, ist über die Arduino™ IDE. Laden Sie diese über die Webseite www.Arduino.cc herunter. Wenn Sie die Software starten, müssen Sie zunächst den richtigen Port und als Board den Arduino™ Nano (Prozessor ATmega328) auswählen.

Die Einstellungen der IDE (unten rechts) und des Seriellen Monitors

Um das WLAN-Modul zu testen, können Sie den seriellen Monitor öffnen und alsBaudrate 19200 angeben. Wenn Sie noch kein anderes Programm in den Controller geladen haben, sollten nun einige Meldungen im Monitor erscheinen. Außerdem können Sie ein offenes WLAN mit der Bezeichnung NanoESP finden. Um das Modul selbst steuern zu können, verwenden Sie die Software Serial-Library über die Pins 11 und 12 mit einer Baudrate von 19200 oder laden Sie einfach das hier verlinkte Programm herunter und übertragen es mit der Arduino-Software auf das Board:

Diskusionen und Hilfe -NanoESP & Pretzelboard

Mon, 21 Sep 2015 10:50:33 +0200

Auf dieser Seite können Sie über die Kommentarfunktion Hilfe ersuchen, Fragen stellen und Vorschläge rund um das Board machen.

AT Befehlsliste - NanoESP & Pretzelboard

Sun, 20 Sep 2015 10:11:14 +0200

Die folgende kurze Liste enthält die wichtigsten Kommandos für die Nutzung des Boards.


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

WLAN Befehle
WLAN-Modus (1 = Client, 2 = AP, 3 = Dual)	AT+CWMODE=
WLAN-Netzwerke suchen	AT+CWLAP
WLAN verbinden	AT+CWJAP=““,““
WLAN trennen	AT+CWQAP
WLAN-AccesPoint Einstellungen	AT+CWSAP=““,““[,,]
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=
IP-Adresse einstellen (Station)	AT+CIPSTA=
IP-Adresse einstellen (AccesPoint)	AT+CIPAP=
Starte SmartConfig	AT+CWSTARTSMART=
Stoppe SmartConfig	AT+CWSTOPSMART

Kommunikation
Funktion Ping	AT+PING=
Mehrere Verbindungen zulassen	AT+CIPMUX=
Datenmodus (0=Transparent, 1=Datenmodus)	AT+CIPMODE=
Struktur empfangener Daten	+IPD,,:
Verbindung aufbauen	AT+CIPSTART=““,“ “,
Daten senden	AT+CIPSEND=,
Verbdingung trennen	AT+CIPCLOSE=

Server Befehle
Server starten	AT+CIPSERVER=1,
Server beenden	AT+CIPSERVER=0
Server Status & verbundene Clients	AT+CIPSTATUS
Server Timeout festlegen	AT+CIPSTO=
Verbundene Clients anzeigen	AT+CWLIF