Internet of Things with the NanoESP

Everything about the NanoESP WiFi-Board

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

The Board

The NanoESP board has many names. Franzis calls it Pretel Board and Conrad C-Controll IoT WiFi Board. But inside its is all the same: an easy-to-use and Arduino compatible development board in the context of the Internet of Things.

By simple AT commands you can e. g. launch a Web server, set the module as an access point or establish connection with your home network.

Board Features:
• Arduino™ compatible
• Integrated TCP/IP stack, activatable TCP/UDP server
• Control of the WLAN module by simple AT commands
• Suitable for WLAN & the module can be used as an access point

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.

Advent Calendar 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.

das-lernpaket-iot

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.

The Conrad advent calendar Internet of Things

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

Conrad Shop

Christmas to arrive. The Arduino compatible microcontroller with integral WLAN module (Pretzelboard) and the included components are perfectly suited for 24 themed, diverse and exciting experiments. Internet of Things includes the communication and control of sensors and actuators in a large network.

The various aspects of the IoT theme are explored in practice by using simple examples starting from simply switching an LED on or off with a smartphone, the creation of a Web server or the long-term monitoring by means of sensors. All circuits are put up on a pinboard; no soldering is required.

der-conrad-adventskalender-iot-2016

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

Shorten the waiting time for Christmas with exciting and enjoyable experiments done with the Internet of things. Thereby send push messages on your smartphone or build an alarm system with a motion sensor that informs you of suspicious movements. Learn how to use various web services, such as Twitter, and use the protocol for the Internet of things: MQTT.

The Internet-of-things advent calendar contains all construction pieces for 24 experiments, including a uniquely developed hardware board with integrated WLAN-module which can be progammed via the free Arduino IDE.

Driver -NanoESP & Pretzelboard

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

The Pretzelboard (NanoESP) needs a driver for the USB-to-Serial Chip CH340G to work properly. You can download the driver here:

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

Linux Version

Mac Version (Attention: There seems to be a problem with MAC OS Sierra. Bellow are two links with walkthroughs:
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 )

Android Version

There is a Setup.exe file (Windows Version) in the Zip-Folder which needs to be executed. Choose Install in the following Window.

Maker Kit für Smart Home

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

ghfgh

Licht, Heizung, Alarm oder Pfl anzenbewä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 Lang-zeitü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!

Day 24: Christmas Tree Lighting

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

Last but not least, you will find another programmable RGB-LED behind the door of the Advent calendar. Thus, we have two LEDs which you can interconnect to light your Christmas tree. We will need the following setup today.

Setup of the Christmas tree light. The longer legs of the LEDs are on the right

Activate the program and import the flow of today. Disable all previous flows and change the broadcast IP of the UDP node, if necessary.

Day 23: Alarm System

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

The day before last reveals a tilt sensor behind the door of the Advent calendar. The sensor detects, if it is tilted. We will use it today as a sensor for an alarm system. The speaker from two days ago serves us as the signal generator. We will need the following setup.

Alarm Setup

As usual, activate the program of today and install the Node-RED flow into the environment. Also adjust the MQTT topic and disable all previous flows.

Day 22: Climate Guard

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

The door of day 21 reveals again a sensor, which we will use to measure the humidity level present. With the following circuit we will build a comprehensive indoor climate monitor.

The indoor climate monitor circuit

Our experiment today uses three sensors: the temperature sensor (NTC), the light sensor (photo transistor) and the humidity sensor. Altogether they deliver a real good impression of the current climate situation in a room. Let’s start the program of today.

Day 21: Piano Player

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

The door of day 21 reveals a loudspeaker. We will use it in our experiment today to play some music. We will need a very simple setup for this.

Setup

In our experiment we will connect the speaker to one of the board’s two DAC outputs. DAC means digital/analogue converter and with this we can generate an analogue signal using digital commands. In our experiment today, we will use it to produce sounds, and to be more precise, we are talking about piano sounds. The notes, pauses and keys are sent via UDP by means of an array of numbers.

Day 20: Plant Guard

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

Behind the door is an NTC resistor (Negative Temperature Coefficient) that measures the temperature. Together with the photo transistor and a few wires, we are going to build a plant guard that alerts us, when a plant it is monitoring is exposed to bad conditions. We will use the following setup besides the program of today.

The plant guard

The two yellow wires are just simple wires that can be inserted into the potting soil. They are used to monitor the level of moisture in the soil. During our initial tests, we will just touch the two wires with a finger.

Day 19: CheerLights

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

Today we have a very special LED waiting behind the door. It is an RGB LED with integrated controller (type PL9823, equivalent to WS2812) and with it you can now connect several LEDs in series and control them individually by means of a protocol. Today we will start by controlling one LED only. Here, an experiment that is almost customary in my Advent calendars fits in handy: the CheerLights project by Hans Schaaler. For all those who do not yet know the project: these are globally linked colourful lights which can be controlled simultaneously via Twitter commands. And here Node-RED fits in very well. The experiment today requires the following setup besides the program of today.

Day 18: Candle Alarm

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

And today we have a small diode waiting behind the door. We are going to use the diode as temperature sensor for particular high temperatures and with it we will build a small candle guard.

Breadboard Setup

Today’s setup consists of the diode and the potentiometer, which we will use as a 10-kOhm resistor. This resistance is fixed and cannot be adjusted. The board will measure the voltage at the diode and sends the values to Node-RED via MQTT.

Day 17: Time-controlled Lights

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

The door of day 17 reveals another potentiometer. Now we have one potentiometer for each LED and thus we will develop the program of Day 13, the Smart Lights, so that we will get a more convenient and intuitive dimming feature. We will also learn today how we can start timed events with Node-RED.

Breadboard Setup

Activate today’s program in the web interface. As always disable previous flows and change the MQTT topic to reflect your personal ID and then install today’s flow into the Node-RED environment.

Day 16: Universal Remote-Control

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

The door today reveals the counterpart to yesterday’s component, namely an IR diode. Now you can build a real remote-control for your TV and control it conveniently via smartphone and website. We will use the following setup.

Setup of remote controls with IR receiver and transmitter diode

Select the program for today. The board will start again in headless mode; the board’s website will not be available but you will have the board’s MQTT feature. To switch to default mode, remove the jumper on pin 23 and restart the board.

Day 15: Remote Control Receiver

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

The door reveals a very special component today, namely an infrared receiver module. You can use it to 15. Tag receive customary infrared remote-control signals. We will use the following setup.

This is how you properly connect the IR module to the board

After the circuit is set up, select today’s program. Please note that you will not be able to reach the board’s website, because it is deactivated for our experiment today. The board works now in headless mode and has no visible interface. If you want to run the website again to activate other programs, for example, you only have to pull out the jumper from pin 23 and restart the board. Everything will run as usual.

Day 14: Smart Lights

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

The door of day 14 reveals another LED. Now we have two LEDs with resistors and two buttons and 14. Tag cables, enough to build a complex lighting system. We will use the following setup:

Setup with four loose cables (yellow) as touch buttons

Enable today’s program and install today’s flow. Don’t forget, replace [PID] with your personal ID and the easiest way is using the trick with the Editor.

Day 13: Smart Switch for Soundboard

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

Today we will find again a 1 kOhm resistor hidden behind the door of the Advent calendar. But we are not going to use it today. Instead I would like to show you how you can build a smart touch switch. We will use a simple setup that is made up of four loose hanging wires as touch buttons and a wire jumper to pin 23.

Four yellow wires serving as touch buttons

Our experiment today is special for its program, which you should activate now on the configuration page. Once enabled, you will notice that the status LED flashes briefly and then turns off, because the board is again running in the power-saving deep-sleep mode. It will not wake up after certain time however. It will wake up only, when you touch one of the touch buttons. The board then sends information via the touch button to the broker who triggered the wakeup. It will look something like this:

Day 12: MQTT Button

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

Today we will find again a button hidden behind the door of the Advent calendar. In our experiment today we will continue to cover the MQTT protocol, but this time in conjunction with Node-RED. We will also learn how two buttons can be evaluated simultaneously. The experiment today is structured as follows:

Setup with two buttons

So now we have two buttons that we can use. We activate the program for today. Then we import the Node-RED flow. You need to adapt it slightly by replacing [PID] in the topic with your personal MQTT ID. That’s pretty easy if you use this trick:

Day 11: MQTT

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

There is a cable set again hidden behind the door today. We will need it in the next few days when the setups become more complex.

Over the past few days we have sent most of our data via UDP. This protocol is very convenient; on the one hand it has a small overhead (data is sent in addition to the actual application data) and on the other hand, it is a broadcasting system and can thus send data to several devices simultaneously. But today we will learn about a second protocol that plays a major role in IoT. This is the message protocol MQTT (Message Queue Telemetry Transport) and it was specifically developed for machine-to-machine communication (M2M). The reason that this is such a brilliant protocol is due to its compactness and simplicity when it comes to exchanging data between devices such as control data, measurement data or text. Compared to HTTP, the overhead is very small. That is why embedded devices such as microcontrollers like our NodeESP can process the data well.

Day 10: Deep Sleep

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

There is a battery compartment for three A batteries (4.5 V) hidden behind the door today that will 10. Tag power the board independently of a power outlet. For economical battery operation, we have the deepsleep mode. This mode allows the board to go into a deep sleep where it uses almost no power at all. After a certain time, the board wakes up, performs a modest task and goes back to sleep shortly after. In this mode a lot of energy is saved due to the long sleep and short wake times and ultimately the batteries will supply power to the board for months. The setup we will use today includes again the light sensor and it gets a wire jumper that connects pin 23 and GND.

Day 9: A Mood Light

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

There is a photo transistor hidden behind the door today. We will use it to measure the ambient brightness. The potentiometer is in series with the phototransistor potentiometer in our circuit and you will be able to change the sensor sensitivity with the potentiometer. In this circuit the reading value will increase when dimming the sensor.

Todays Circuit

You will see this happening today in our user interface within the gauge element. But again, you first import and start today’s flow in your Node-RED environment and of course, you have to disable the one from yesterday. Also, do not forget to enable today’s program on the configuration page and adjust the IP of the UDP send node.

Day 8: A Controller

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

Breadboard Construction

On the eighth day you will find a potentiometer behind the door. We are going to use it as voltage divider. You can set a voltage between 0 V and 3.3 V, which is measured by the board and sent to NodeRED. On top of to the functions of yesterday’s stairway light, you can also send the measured values.

The Flow of Today

As usual you can obtain today’s flow from here. Don’t forget to disable yesterday’s flow and you may need to adjust the send-IP. The flow of today also has a new node for the dashboard, namely a gauge to visually display the measured value.

Day 7: Stairway Light

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

There is a red LED hidden behind the door today. We are going to use this to build a simple stairway light with web interface. We will thus build the following circuit and, of course, activate today’s program.

Breadboard Construction (short LED pin is up)

Locate the Node-RED flow below and import. Deactivate yesterday’s flow after the import to make sure the UDP receive nodes do not get in your way. This time the flow also has a send node besides the receiving node. You may need to adapt the send node to reflect your broadcast IP. A message that arrives at the UDP will be converted back to a JSON object by means of a JSON string, which is pure text. The difference here is that you can now access also individual attributes.

Tag 6: Touch to Speach

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

Behind the sixth door of the Advent calendar is a 1 kOhm resistor, which we will use tomorrow. Today we will continue with Node-RED and try out the touch function of the board. As always you will select the program of today. And today we will also build the following circuit. The yellow wires with one free end are the touch sensors.

Breadboard Construction: Three wires suspended in the air from one end

Once set up, you can restart Node-RED using the terminal and the node-red command. Then open the Node-RED editor via http://127.0.0.1:1880/. Today we will install a few nodes. To do this, click on the three dashes in the top right corner where you will see manage palette under which all the installed nodes are listed. Select the Install tab and you will see a large number of different modules that you can install. For today we are searching for the module node-red-dashboard. Click the Install button. A message appears warning you that installation may be difficult at times. Just click Ok, this module is easy to install. After a short while, a success message appears, and the new nodes are now in your node row.

Day 5: Node-RED

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

Behind the fifth door of the Advent calendar is a button and we are going to use it today in our experiment instead of the boot button. We will connect the button to pin 18 and GND in such a way that when pressed, it will pull the pin to ground, thus to LOW. If you have selected the program of the day and you press the button, a message is sent via UDP.

Day 4: UDP and JSON

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

Behind the fourth door of the Advent calendar is a set of cables that is very useful for the upcoming hardware setup. But today in our project we are going to look at the JSON format; what is it and how does it help us communicating with the board.

As usual, first you need to activate today’s program. You will also need the Packet Sender program with the same settings that we were using yesterday. Today, a message appears only after you briefly press on the board’s boot button. This message looks like this:

Day 3: UDP and Packet Sender

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

Today’s door reveals another breadboard. It can be plugged into the board of yesterday. The NodeESP board can now be placed on both boards together. However, this constellation will not work for everyone. Breaking off the side parts of the boards is the easiest solution. I have done this by fitting the boards into each other and then bending one until a side part broke off. I did the same thing with the other board. But you could use pliers, too. Without the side parts, you can place the boards closer to each other, and then there won’t be a problem with the grid. Simply plug the NodeESP board onto both boards as shown in the picture. This leaves enough room for other components. In today’s project, we will learn how to connect to the board from your PC without using the web browser.

Day 2: OnBoard LED and Update

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

On the second day you will find a breadboard for the upcoming experiments hidden behind the door. I would recommend however, that you do not yet plug your NodeESP into the board. Let’s first look today at how we launch the programs preinstalled on the board and bring the board up to date.

Reconnect your board first to a power source. Wi-Fi data that you entered yesterday is still stored and the board should automatically connect to your Wi-Fi network. Then access the board page using the IP or mDNS name (http: //nodeesp.local/). Now, the first thing you do is searching for possible software updates. To do this, open the configuration page, click Advanced Settings at the bottom and click on Check for Firmware Updates.

Day 1: The NodeESP Board

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

This is the first day of the 2018 Advent calendar project. The time has come to open the first window. Behind this calendar door you will find a microcontroller board. The main task today is to connect to the home network and to become acquainted with the board.

The NodeESP board with WPS button selected

In a first step we will supply power to the board by simply connecting the board using a MicroUSB cable to the PC or to a standard smartphone charger. You will need at least 300mA to power the board. Older laptops and USB hubs may pose a problem, if they do not have an external power supply however. After a short while the RGB LED on the board turns on and glows yellow. Initialisation is complete. Now all you have to do is enter your Wi-Fi data. There are two ways to do that:

NodeESP Technical Specs

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

nodeesp

Wed, 24 Oct 2018 15:58:50 +0200

Der IoT Adventskalender 2018

Day 24: Christmas Tree Lighting Day 23: Alarm System Day 22: Climate Guard Day 21: Piano Player Day 20: Plant Guard

Das NodeESP Board

Firmware Neuigkeiten und Bug Report NodeESP Kommandoreferenz das-nodeesp-board NodeESP Technical Specs NodeESP Firmware Reinstallieren

Maker Kit für Smart Home

The NanoESP Page

Wed, 24 Oct 2018 15:58:17 +0200

WiFi UDP Y-Network consisting of three NanoESP (Pretzel Boards) and Laptop

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

Download: Ernteroboter_Programme

We have designed a computer network consisting of one Server (NanoESP S), two Arduino Clients (NanoESP C1 and C2) and a Laptop as third Client (running there either Packet Sender https://packetsender.com/download or TWedge of TEC-IT https://www.tec-it.com/de/download/Default.aspx ), to construct a small UDP WiFi network. We denote it as Y-configuration, which symbolizes the connections. The center is the Server S, at the ends of the inclined arms of the Y are the Arduino Clients C1 and C2 and the vertical line is the connection to the Laptop as third Client.

Day 24: Gift box

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

With the last test in this Advent, we get really Christmasy. We’re building a reusable gift box with which you can delight your relatives. Every time someone opens the present, the contents are lit up in an individual colour, and a Christmas sound plays.

Behind today’s door is a retro-reflective sensor. This is actually two components, an IR transmitter diode and a phototransistor. It’s not very easy to see which way the elements have to be connected in terms of polarity. For this reason, it’s best if you connect the photoelectric sensor with the connection cables according to the example shown. Then you won’t be able to switch the polarity as easily.

Day 23: MQTT Climate

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

Behind the door for today is a battery clip for a 9 V block, with which you can make the entire system moveable. An alternative to a battery is a power bank (a rechargeable battery pack, normally for mobile phones). You can see in today’s layout picture how to connect a 9 V battery correctly.

This is how you can connect a 9 V battery to today's layout

Climate data should be captured again today. But this time they are published through the MQTT broker and are thus accessible worldwide. The data could thus be called up via a plug-in and stored in a database.

Day 22: MQTT Cheerlights

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

Today’s trial is about MQTT and a global project that was presented last year: the Cheerlights Project by Hans Schaaler. For everyone who doesn’t know the project: It’s about globally networked coloured lights that can be simultaneously controlled through Twitter commands. Another version of this project was part of last year’s Advent calendar. This year we have the version with MQTT and expanded functions.

Behind today’s door is a 1-kohm resistor. The layout consists of the RGB LED with series resistors and a button.

Day 21: House automation

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

In today’s test, we’ll illuminate the characteristics and possibilities of MQTT in more detail by creating a practical scenario. In the example, there is a building with two rooms, each of which has a light switch, a light and an alarm sensor. The light switch switches the light of the respective room on or off. The alarm sensors activate a building-wide alarm.

Normally, seven different devices would be used here, which are all connected to each other through an MQTT broker. But since we probably have only one NanoESP, this will simulate all devices. For this reason, today’s layout looks somewhat complicated. The LED D3 is used today as the second light. Therefore, today it won’t show you whether you’re connected to the WLAN. The tilt sensors are used on the extension cables as alarm sensors. A person could, for example, attach them to doors or windows so that they trigger an alarm if the entry opens. Behind today’s door is the second sensor.

Day 20: MQTT (Message Queue Telemetry Transport)

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

For the last days of this Advent, you’ll now become familiar with a subject that plays a large role in the realm of the IoT. We’re dealing with the messaging protocol MQTT, which was specially developed for the communication from machine to machine (M2M). The protocol is thus so brilliant because e.g. control data, measurement data or texts can be exchanged very easily and compactly. The overhead (data that’s transferred alongside the actual user data) is much lower than with HTTP and can be processed readily even by embedded devices, meaning microcontrollers like our NanoESP. At the same time, the controller doesn’t constantly have to establish a connection and query whether there’s been a change; instead, the connection is continually maintained and the client automatically gives information about changes.

Day 19: Configuration page for the NanoESP

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

Behind today’s door is another cable. With the two cables it’s possible, for example, to place the RGB LED apart from the board. We’ll need the RGB LED today because the test is about a website with which you can adjust its colours. But that’s not the main aspect: To make the configuration of the NanoESP board especially easy not just for programmers, there is a configuration page through which the WLAN data of the module can be adjusted. But first to the set-up. You see it in the following picture.

Day 18: Weather monitoring

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

Behind today’s door is a very special component, namely a humidity sensor. Together with the phototransistor and the NTC, it creates a weather station for at-home use. The following layout is necessary for this purpose:

The layout with all sensors (resistors 1 kohm)

Today’s layout is a bit fiddly. Especially at the point where the potentiometer on the right of the image sits, it touches the NanoESP. But that’s not really a problem as long as the contact on the left of the image is plugged firmly into the board.

Day 17: Wake Up Light

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

Today’s project deals with a well-known lamp from Phillips, the Wake Up Light. This is an alarm clock that, instead of making a loud noise, slowly increases the brightness. This creates a type of sunrise, and one wakes up in a natural manner.

Behind today’s door is another potentiometer, which is important for tomorrow’s test. The following layout is required today:

The RGB LED with series resistors

The sketch: 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 );
}

(The former Arduino Create embed is no longer available; the code is taken from the download of all sketches.)

Day 16: A web server piano

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

Behind today’s door is a piezo sound transducer. It’s possible to generate sounds with it, which will become clear in today’s test. Today you’re building a type of piano that can be used via a website. See the following picture for the layout:

The correct connection of the piezo sound transducer

The sketch: 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
 }

 }
}

(The former Arduino Create embed is no longer available; the code is taken from the download of all sketches.)

Day 15: A web server

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

Since the Blynk platform was the central point of our projects over the last few days, now we’re coming to a totally new subject: the NanoESP as web server. You’ve already gotten a first impression of it in the test for the first day. In the coming days, we’ll see what all else is possible.

Behind today’s door is a special two-core cable with which you can connect e.g. even LEDs or sensors outside the board. For today’s test, however, no hardware layout is necessary at all. You only need the programme and a browser.

Day 14: Long-term temperature measurement

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

Behind today’s door is an NTC sensor (negative temperature coefficient thermistor). Its conductivity changes depending on the temperature. You’ll use the sensor today to undertake a long-term measurement of the temperature. As a small bonus, you can select a time at which you get a summary by email.

For today’s layout, in addition to the NTC, you’ll also need the potentiometer and a 1-kohm resistor. You can make a fine adjustment of the temperature with the potentiometer.

Day 13: Alarm system with push messages

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

Today’s project deals with a simple silent alarm system with password input for resetting the alarm. So that you get anything at all from the alarm, the board sends a push message to your smartphone. We’ll set the tilt sensor that’s behind today’s door as a motion detector. It can give information about vibrations and thus inform you if someone tips the NanoESP board.

Layout with tilt sensor

The sketch: 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));
}

(The former Arduino Create embed is no longer available; the code is taken from the download of all sketches.)

Day 12: Light monitor

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

Behind today’s door, you’ll find a phototransistor. This is a sensor with which the brightness can be measured. You’ll do that today, but in addition to simple measurement, the project also sounds an alarm as soon as limit values that you’ve pre-set in the app are exceeded. So that everything will function, you have to connect the sensor with a voltage divider circuit at Pin A0, as shown in the picture below. Pay attention to the correct polarity of the phototransistor (short leg to VCC). It does also work the other way round, but not nearly as sensitively.

Day 11: Day- and nightlight

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

Behind today’s door is a 10-kohm resistor, but we don’t need it yet today. Instead, the set-up from yesterday’s test works today as well. In this project, you’ll build a day-night lamp that changes colours at specific times. Thus you can have a bright light shining during the day, while at night only a dim red serves as emergency lighting for a bit of orientation.

The layout from Day 10

The sketch: 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
 }
}

(The former Arduino Create embed is no longer available; the code is taken from the download of all sketches.)

Day 10: Colour mixing

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

Behind today’s door is the reason for the many 1-kohm resistors. Namely, what you find there is a so-called RGB LED RGB stands for red-greenblue, since this LED is actually three LEDs that can be connected through a common cathode. By varying the brightness of the individual LEDs using PWM, you can generate almost every colour conceivable.

You can see the layout of today’s circuit in the following figure. Note that the somewhat longer leg (the cathode) must be plugged into the GND contact strip.

Day 9: Brightness of the real LED

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

Behind today’s door is another 1-kohm resistor. But today you don’t have to change anything in the hardware layout from yesterday. Only a small detail changes on the interface.

The layout from yesterday

You don’t have to re-upload the programme because you’re simply manually adjusting the interface from yesterday. If you’d like to load the interface in the app anyway for safety’s sake, you’ll find the QR code here as usual. But then you also have to re-enter the token in your programme.

Day 8: Virtual LEDs

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

In the test for the sixth day, you saw how a push button on the hardware side can be mapped on a button in the app. However, another widget, namely the LED widget, is much simpler for this instance. In today’s test, you’ll see how to use it properly and what options it offers.

Behind today’s door is another 1-kohm resistor that is important for later tests. Today the circuit from yesterday is expanded by a button.

Day 7: Analogue write

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

Behind today’s door is a potentiometer. You can use it to transfer analogue messages to the Blynk app. To do this, you need to build the circuit according to the picture.

The potentiometer uses the lower wire for the connection to A0

Things can get a bit tight when constructing with the MicroUSB cable. So that everything connects, you first have to disconnect the board from the cable and place the jumpers to be as flat as possible. You also need to be aware that this time the VCC is not applied to the track at the bottom of the image; instead, the track is intended for the connection at Pin A0.

Day 6: The hardware button

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

In yesterday’s test, you realised a simple control of an LED using the Blynk app. Today you’ll see that the control works in both directions. The push-button switch behind today’s door really comes in handy for this purpose. With it, you can expand yesterday’s circuit as follows:

The new layout with push-button switch at D7

You can scan the interface for today here:

Day 5: Blynk

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

You already established a first connection from the board to the Internet yesterday. In the coming days, this connection should be used effectively. So we’re looking at the online platform Blynk, through which short commands, measurement data or messages can be exchanged between the NanoESP board and your smartphone.

Communication with the Blynk Server

Blynk enables the simple control of various IoT boards, e.g. the Raspberry Pi or our NanoESP, using an app. You can put the graphic interface together completely on your own, and programming is also extremely simple. As if that weren’t enough, you can even control the board from anywhere in the world. So it’s totally within the sense of the Internet of Things.

Day 4: Setting up Internet connection

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

Behind today’s door is a 1-kohm resistor. We’re not going to do much with it today, but tomorrow it becomes important. In today’s test, we want to set up an initial connection to your home WLAN network. For this purpose, you need, as you will on many days to come, to enter your WLAN data in the programme.

The Board pings the Goolge server

But first you need to download today’s programme. You can download it via the right button on the from the Arduino Create Iframe.

Day 3: The NanoESP in access point mode

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

Behind the third door is the jumper wire, which is important for many tests. To prepare for later tests, you can place the supply lines GND and VCC on the outermost lanes. You’ll thereby have better access to these important lines later.

The jumpers to GND and VCC

In the project for today, you now get around to changing something in a programme even on your own. The following sample programme serves as a basis:

Day 2: The Arduino IDE

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

This time there’s a breadboard behind the door. On it, you can quickly and easily assemble the hardware layouts of the Advent calendar. Since only the NanoESP is available so far, we’ll start with it.

NanoESP on a breadboard

It’s best if you plug the controller into the breadboard as shown in the picture. That way, the greatest space remains free for experiments; the WLAN module sticks out behind past the breadboard. The micro-USB cable then hangs between the contact sides and is only a minimal disruption. The board needs to be pressed in gently until it touches the contacts.

Tag 1: Das NanoESP-Board

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

It’s the first of December and thus time to open the first door. Behind it is arguably the most important element of the calendar: the NanoESP board. This Arduino-compatible controller with WLAN function is at the centre of the 24 tests.

The NanoESP Board

To s briefly, it can be said that the board is most likely a cross between a board similar to an Arduino Nano and a WLAN module with the name ESP8266. The communication between the two elements runs through a serial port generated via software, which is connected to Pins D11 and D12. You should thus avoid these pins with your own projects.

Library for NanoESP & Pretzel Board

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

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

Pinout NanoESP & Pretzel Board

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

Pinout Pretzel Board (NanoESP)

Download PDF: Pinout Pretzel Board

Day 24: Fire alarm for the Christmas tree

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

The final project consists of several elements you have been introduced to in the course of the advent time. One function is the Cheerlights function presented the day before. You can also receive the current colour of the Cheerlights project and display it with the RGB-LED. The board is also used for long-term monitoring of the temperature. At the same time, the board is used to emit an alarm sound when the temperature exceeds a specific value, e.g. because there is a fire. As a last function, the board can be used as a Christmas bell, by making it play the song Jingle Bells with a time-controlled TalkBack command. All in all, today’s project is an all-rounder for the Christmas tree.

Day 23: Cheerlights

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

Today’s experiment is based on a project by Hans Scharler that is called Cheerlights. The idea is globally linked lights that can be simultaneously controlled via Twitter commands. It is a good example of the world growing closer and closer together with the Internet.

The circuit is similar to previous projects

Behind today’s door, you will find a fourth extension cable with which the RGB-LED can also be placed aside. This can be particularly practical if, for example, you want to hide the board in the Christmas tree while the RGB-LED decorates the top of the tree.

Day 22: TalkBack

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

Today’s project is about another app of the ThingSpeak page, i.e. the TalkBack-App. This function permits creating a command that is read and executed by the controller. What appears nonsensical with a single controller does make sense when using two or an entire network of controllers. Some boards can act as sensors then, e.g. with motion detectors, and send a TalkBack command. Another module reads the command from the ThingSpeak page and then opens the door or reports an alarm.

Day 21: Alarm system

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

Today’s project is an alarm system with which you can, for example, check whether someone opens a drawer without permission. There is a continuous check for whether the connected light sensor is exposed to too much light. If this is the case, an alarm signal will sound and a message will be sent via Twitter.

Lightsensor on A0 and Piezo on D8

Behind today’s door, there is a Piezo speaker that is used as alarm signal encoder. The structure of today’s experiment is shown in the figure.

Day 20: Twitch

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

The website ThingSpeak offers a lot more than just long-time monitoring of sensors. Today’s project is similar to the projects from days 9 and 10 in its basic idea. Information is collected from a website on the internet. In this case, it is whether a specific stream is currently online or not.

There are two decisive advantages of the ThingSpeak version over the first attempts. First, the ThingSpeak page can also call websites via HTTPS (HyperText Transfer Protocol Secure), while the module only supports the unsafe HTTP-protocol. Second, the website can pre-filter important information and thus clearly reduce the data volume to be processed by the controller.

Day 19: ThingSpeak

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

In the last days of the advent time, we will deal with an entirely new subject: the website ThingSpeak. This website has been specifically developed for the subject of Internet of Things and contains various practical functions for you.

Before you tackle the setup and programme as usual, you need to set up an account on the website

www.ThingSpeak.com

Log in with your user data under the item Sign In. You can see a website that shows your channels. Since you have no channels yet, this site will look rather empty. Click New Channel and assign a name, e.g. Light. In this project, you will measure brightness. In the item Field1, you can now assign a name to the field, e.g. Brightness. All other fields can be left empty for now.

Day 18: Universal remote control

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

Yesterday, you built a receiver for infra-red remote controls. Today, you are building the remote control itself. More precisely, you will build a universal remote control that you can operate by computer or Smartphone and with which you can operate your TV or other devices whenever you misplace the original remote control.

The IR-diode at Pin D3

For this project, you need the component behind today’s door: the IR diode. It looks like a simple LED, but it sends light in the invisible infra-red range. The IR-signals are visible to a digital camera, however. The structure of today’s experiment is shown in the figure. Don’t be surprised that the IR-LED is not given a dropping resistor. The effective dropping resistor is the On-resistor of the port, at approx. 30 Ohm. Because of this, the current through the diode is quite high, but the impulses sent are so short that the diode will not take damage.

Day 17: IR module

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

Today’s project permits controlling the controller by remote control. You can change the colour of the RGB-LED with buttons you can choose on an infra-red remote control, and change the background colour of the website right along with it.

TheIR-Modul on Pins D7-D5

Behind today’s door, you will find the important part of today’s project, i.e. the infra-red receiver module. You can connect the module without a cable as shown in the figure below. The program sets the corresponding pins so that the module is supplied with power.

Day 16: GPIO Control

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

Today’s project permits simple control of the digital pins D2-D7 per website. The status of the respective pin is also presented on the website, so that you will never lose the overview.

To review the condition of the pin well, a setup as in the following figure is recommended. Both the RGB-LED and the regular LED are used. The cathodes of the LEDs are now not connected to the long ground line on the outside of the board, but are also at a digital output. Only when these pins are switched low can the LEDs light up.

Day 15: Light sensor

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

Today’s project does not use the web server’s website as a control interface, but as an output element. The brightness measured via a brightness sensor is displayed well-structuredly as a relative value.

The fototranistor at Pin A0

Behind today’s door, there is another photo transistor that serves as a light sensor. The photo transistor looks like an LED, but should not be mistaken for one. The structure of today’s experiment is shown in the figure. The collector of the photo transistor is the shorter connection. It is applied to +5 V.

Day 14: Webserver for the RGB-LED

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

Today’s project is about controlling the RGB-LED by web server. A well-structured interface can be used to change the colour of the LED. The website has also been adjusted and should be easy to display even on Smartphones.

The website on a PC browser

Behind today’s advent calendar door, there is another resistor, but this one is of 10 kΩ (brown, black, orange). You will need it for tomorrow’s experiment.

Day 13: Website with buttons

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

In today’s experiment, the illustration of the website is even more sophisticated. There are now also control elements that permit much more comfortable control of the LED.

The 9V-batterie powers the board

The structure of today’s experiment is no different from yesterday’s: An LED at pin D9, which can be controlled via the module. As an additional component, today’s door once again holds a resistor with 1 kΩ. If necessary, you can now reduce the brightness of an LED by switching two resistors in series.

Day 12: Autonomous webserver

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

The results of yesterday’s experiment are now to be used in an autonomous program. Today’s program not only sends a simple website to the browser, but also permits control of an LED.

The 9V-batterie powers the board

Behind today’s door, you will find a 9-V battery clip that can make your board mobile. As an alternative, you may also use a Power Bank (a battery pack usually used for mobile phones). If you want to use the 9-V-battery, observe that the red wire must be connected to Vin, and the black one to GND. The figure shows the setup of today’s experiment with external power supply.

Day 11: TCP-Webserver

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

In the previous experiments, we dealt with the subject of TCP and access to web servers a lot. Today, the module is to act as a web server of its own for the first time.

Behind the door of the 11th day, there is a special cable that will be very useful soon. A special setup is not necessary today, since the program works similarly to the serial monitor programme of day one.

Day 10: Temperature display

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

Today’s project is an intuitive display of the current temperature. With a single look, you can guess at whether it is sensible to take along a warm jacket.

The RGB-LED on Pins D3, D5 and D6

Behind today’s door, there is another LED. This is a special one. It is an RGB-LED. RGB means Red, Green, Blue, the LED actually is made up of several LEDs with a shared cathode connection. A combination of the different colours with different brightnesses permits presenting almost any colour. The LED can be connected to the PWM outputs D3, D5, D6 of the controller with dropping resistors.

Day 9: TCP time

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

Today’s project uses the functions of the prior test to independently collect information from a website. The program specifically loads the current time from a dedicated website and thus sets the internal clock of the controller that is implemented by library.

Behind today’s door, there is another resistor with 1 kΩ. All three resistors will be needed for tomorrow’s experiment.

The program: Day9_TCPAutoTime

While yesterday’s program still required mostly manual operation, today’s program works mostly autonomously. The controller connects to the website entirely independently:

Day 8: A browser

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

In the last days, we mostly dealt with the UDP protocol with which data can be sent out simply and directly. In the next few days, we will deal with the TCP (Transmission Control Protocol). TCP only permits one connection at a time between precisely two computers. It is mostly used online for browsing on websites.

Behind today’s door, there is another resistor with 1 kΩ (brown, black, red). As with all other parts: keep it safe, even though you are not using this part today yet.

Day 7: Analogous sensor

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

In the last project, a button was used to deal with the simplest form of a sensor. This time, a potentiometer should be used as an analogue sensor to permanently send measured values into the network.

Behind the 7th door of the advent calendar, there is a potentiometer with 10 kΩ. The setup is shown in the lower figure.

The setup on pin A0

The program: Day7_UDPAnalog

Day 6: UDP-Button

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

In yesterday’s program, the first commands were evaluated by the controller. Today’s program maintains this function but can also additionally send a command into the network independently.

The button on pin D8

You will find a button behind today’s door. It is used as a simple sensor here. Connect it to the controller as shown in the setup image.

The program: Day6_UDPSwitch

! Attention: Some MAC-Users reportet a bug in the PacketSender-Software. This bug doesn’t allow you to change the ports. If you have problems with this bug you can change the ports in the Arduino program. All you have to do for todays project is to change the line 83 from
succes &= sendCom(“AT+CIPSTART="UDP","192.168.4.255",90,91”, “OK”);
to
succes &= sendCom(“AT+CIPSTART="UDP","192.168.4.255",5505,5506”, “OK”);

Day 5: Switching an LED

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

Today’s program is finally about controlling hardware via the UDP protocol. In this case, an LED is switched on and off with simple commands.

The LED in Pin D9

You will find an LED board behind the fifth door. The right dropping resistor already was in yesterday’s door. Build the circuit as the picture shows.

The program: Day5_UDPLED

Day 4: UDP bidirectional

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

In yesterday’s project, the UDP communication was tested in one direction, i.e. from the board to the PC. In this program, the module is set so that communication in the other direction is possible as well, almost like in a chat. Behind the fourth door of the Advent calendar, there is a resistor with 1 kΩ (brown, black, red). The component is not used in today’s test yet, but should be kept for later.

Day 3: UDP-Send

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

In today’s project, data are exchanged between the board and the PC through the WLAN for the first time. The prerequisite for this is that your computer has a WLAN adapter. The UDP (User Datagram Protocol) is used. Another program on the PC-side ensures successful receipt of the messages.

Behind the third door of the calendar, you can find an insulated cable that you will need to build circuits. To prepare for later experiments, you can place the supply lines ground and VCC on the outer tracks.

Day 2: Google Ping

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

With today’s project, you test whether you can reach the Google server. This is used as a test of whether there generally is a connection to the Internet or, e.g., a firewall is blocking the NanoESP-board.

You will find a plug board behind today’s door. The plug board is used as an experimenting platform later, to connect sensors and other elements. It is best if you plug the controller onto the plug board as shown in the following figure. This leaves you the most space for experiments, while the WLAN module protrudes over the plug board at the rear. The micro USB cable is then suspended between the contact sides and will only interfere minimally.

Day 1 - First Steps

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

It is the first day of December and thus time to open the first door. Behind the door, you will find the most important part of this calendar: the Arduino™-compatible NanoESP-board with integrated WLAN module that this calendar is about.

The NanoESP Board

As you can see quite well on the PCB, the board is made up of two components. The left half is an Arduino™-compatible micro controller system that can be compared to the Arduino™ Nano. The right part is the WLAN module with the designation ESP8266. These two components communicate via a serial interface generated by software. The Arduino™-side rather acts as the boss, forwarding the commands to the WLAN module. Some of these commands will already be tried out today on the first day.

Day 0: Download all Projects (Spoiler Alert)

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

Many people asked me when the projects will be ready for download. Every project description including schematics and software will come on its owm December day. But if you can’t wait, you can download only all software files in advance here.

CalenderIoT

Board specifications NanoESP & Pretzel Board

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

On this page you can find the specifications of the Board

Specifications:

Microcontroller: ATmega328
Flash memory: 32 KB (including 0,5 KB for the Bootloader)
SRAM: 2 KB
EEPROM: 1 KB
Taktrate: 16 MHz
I/O-Pins: 20 (including 2 for communication with the WiFi module)
- Included PWM: 6
- Included analog inputs: 6
USB-to-Serial Chip: CH340G
Operating voltage: 5 V
Recommended input voltage:: 7-12 V
Maximum current per I/O pin: 40 mA
Load capacityof the 3.3 V output: 50 mA

WLAN-Modul: ESP8266

Quick Start - NanoESP & Pretzelboard

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

When you attach the board for the first time via the MicroUSB connector, your PC will try to install a driver. If this does not work automatically download and install the driver here.

The ArduinoTM IDE provides the simplest way of programming the development board. Download the IDE from www.Arduino.cc. When you start the software, you first have to choose the correct port and board. For the latter, you select the Arduino NanoTM (ATmega328 processor).

Questions and Answers - NanoESP & Pretzelboard

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

In this section you habe the possibility to ask questions or give suggestions to a subject related to the Pretzelboard (NanoESP) via the commentary function.

AT Commands -NanoESP & Pretzelboard

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


Description	Command
Basics
Test Command	AT
Reset	AT+RST
Firmware Infos	AT+GMR
Echo On/Off	ATE<1/0>

WiFi Commands
WiFi-Modus (1 = Client, 2 = AP, 3 = Dual)	AT+CWMODE=
Search WiFi network	AT+CWLAP
Connect to Wifi	AT+CWJAP=““,““
Disconnect WiFi	AT+CWQAP
Settings WiFi -AccesPoint	AT+CWSAP=““,““[,,]
Show IP	AT+CIFSR
activate/deactivate DHCP	AT+CWDHCP=<1/0>
Auto connect to WiFi	AT+CWAUTOCONN=<1/0>
Change MAC address of AP	AT+CIPSTAMAC=
Set IP address of station	AT+CIPSTA=
Set IP address of AccesPoint	AT+CIPAP=
Start SmartConfig	AT+CWSTARTSMART=
Stop SmartConfig	AT+CWSTOPSMART

Communication
Ping	AT+PING=
Accept multiple connections	AT+CIPMUX=
Set transfer mode (0=normal, 1= unvarnished transmission mode, only for TCP single connection)	AT+CIPMODE=
Structure of received data	+IPD,,:
Start connection	AT+CIPSTART=““,“ “,
Send data	AT+CIPSEND=,
Close connection	AT+CIPCLOSE=

Server Commands
Start TCP server	AT+CIPSERVER=1,
Stop TCP server	AT+CIPSERVER=0
Server status & connected clients	AT+CIPSTATUS
Set server timeout	AT+CIPSTO=
Show connected clients	AT+CWLIF

Internet of Things with the NanoESP

Everything about the NanoESP WiFi-Board

The Board

das-nodeesp-board

Das NodeESP Board

Das NodeESP Board

Advent Calendar IoT - 2018 [Smarthome Edition]

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

das-lernpaket-iot

The Conrad advent calendar Internet of Things

der-conrad-adventskalender-iot-2016

Driver -NanoESP & Pretzelboard

Maker Kit für Smart Home

Day 24: Christmas Tree Lighting

Day 23: Alarm System

Day 22: Climate Guard

Day 21: Piano Player

Day 20: Plant Guard

Day 19: CheerLights

Day 18: Candle Alarm

Day 17: Time-controlled Lights

Day 16: Universal Remote-Control

Day 15: Remote Control Receiver

Day 14: Smart Lights

Day 13: Smart Switch for Soundboard

Day 12: MQTT Button

Day 11: MQTT

Day 10: Deep Sleep

Day 9: A Mood Light

Day 8: A Controller

Day 7: Stairway Light

Tag 6: Touch to Speach

Day 5: Node-RED

Day 4: UDP and JSON

Day 3: UDP and Packet Sender

Day 2: OnBoard LED and Update

Day 1: The NodeESP Board

NodeESP Technical Specs

nodeesp

Der IoT Adventskalender 2018

Das NodeESP Board

Maker Kit für Smart Home

The NanoESP Page

Alles rund ums Board

Die IoT Lernpakete mit dem NanoESP

Der IoT Adventskalender 2016

Der IoT Adventskalender 2015

WiFi UDP Y-Network consisting of three NanoESP (Pretzel Boards) and Laptop

Download: Ernteroboter_Programme

Day 24: Gift box

Day 23: MQTT Climate

Day 22: MQTT Cheerlights

Day 21: House automation

Day 20: MQTT (Message Queue Telemetry Transport)

Day 19: Configuration page for the NanoESP

Day 18: Weather monitoring

Day 17: Wake Up Light

Day 16: A web server piano

Day 15: A web server

Day 14: Long-term temperature measurement

Day 13: Alarm system with push messages

Day 12: Light monitor

Day 11: Day- and nightlight

Day 10: Colour mixing

Day 9: Brightness of the real LED

Day 8: Virtual LEDs

Day 7: Analogue write

Day 6: The hardware button

Day 5: Blynk

Day 4: Setting up Internet connection

Day 3: The NanoESP in access point mode

Day 2: The Arduino IDE

Tag 1: Das NanoESP-Board

Library for NanoESP & Pretzel Board

Ausgelagerte Webseiten für den NanoESP

Wettbewerbsbeitrag: IoTeaTimer

Wettbewerbsbeitrag: Wassermelder mit Twitter-Alarmmeldung

Beitrag zum Kalenderwettbewerb 2015 von Bernhard Kaiser & Michael Gaus

Pinout NanoESP & Pretzel Board

Download PDF: Pinout Pretzel Board