NanoESP on 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-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.

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

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