Halloween 2019 - The Pumpkin Awakens Again


Hello AZ community,


the days are getting shorter, the nights longer, the trees attract your autumn costume.

It is the time of harvest and fall of leaves. And just in time for October 31, many celebrate the Americanized version of Irish "All Hallows' Eve" - better known as "Halloween."

This year, we haven't spared any expense and effort, hollowing out a real pumpkin in meticulous craftsmanship, and carved it around until it looks like our clay pumpkin head from last year to be confused. ;)

We have equipped it with an RGB LED ring, which is supposed to simulate the flickering of a small, warm flame.

Furthermore, we have connected an infrared motion detector. Should someone approach the pumpkin, the colors should change for a few seconds from a cozy red/yellow tone to an unnatural-creepy blue tone.

For the implementation we need the following parts:

1x AZ-Delivery Nano V3 (Link to the shop)
1x AZ-Delivery RGB LED Ring (Link to the shop)
1x AZ-Delivery PIR Motion Detector (Link to the shop)

🎃🎃🎃 We also offer all 3 components listed above as a set at a special price for a short time. (our Halloween Savings offer in the shop) 🎃🎃🎃

1x Sufficiently dimensioned 5V power supply
1x Electrolyte Capacitor 1000 . . . . . . . . . . . . . . . .


Here are the connections:

Nano V3 RGB Ring PIR Sensor Nethteil Elko
Vin Vin Vin + +
Gnd Gnd Gnd - -
D5 Din
D4 Out


After all the connections have been made, the code we need to upload to our Nano V3 is still missing. For this to work, the FastLED library must be installed. (Link to the FastLED GitHub page)


#include <FastLED.H>

#define LED_PIN     5
#define COLOR_ORDER Grb
#define Chipset     WS2812B
#define NUM_LEDS    12

#define BRIGHTNESS  64

Bool gReverseDirection = False;


Fire2012 with programmable Color Palette
This code is the same fire simulation as the original "Fire2012",
but each heat cell's temperature is translated to color through a FastLED
programmable color palette, instead of through the "HeatColor(...)" function.
Four different static color palettes are provided here, plus one dynamic one.
The three static ones are:
1. the FastLED built-in HeatColors_p -- this is the default, and it looks
Pretty much exactly like the original Fire2012.
To use any of the other palettes below, just "uncomment" the corresponding code.
2. a gradient from black to red to yellow to white, which is
visually similar to the HeatColors_p, and helps to illustrate
what the 'heat colors' palette is actually doing,
3. a similar gradient, but in blue colors rather than red ones,
i.e. from black to blue to aqua to white, which results in
"icy blue" fire effect,
4. a simplified three-step gradient, from black to red to white, just to show
that these gradients need not have four components; two or
three are possible, too, even if they don't look quite as nice for fire.
The dynamic palette shows how you can change the basic 'hue' of the
color palette every time through the loop, producing "rainbow fire".

CRGBPalette16 gPal;

Void Setup() {   pinMode (4, Input);   Delay(3000); sanity delay   FastLED.addLeds<Chipset, LED_PIN, COLOR_ORDER>(Leds, NUM_LEDS).setCorrection( TypicalLEDStrip );   FastLED.setBrightness( BRIGHTNESS );   This first palette is the basic 'black body radiation' colors,   which run from black to red to bright yellow to white.   gPal = HeatColors_p;   // These are other ways to set up the color palette for the 'fire'.   // First, a gradient from black to red to yellow to white -- similar to HeatColors_p   //   gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::Yellow, CRGB::White);   // Second, this palette is like the heat colors, but blue/aqua instead of red/yellow   //   gPal = CRGBPalette16( CRGB::Black, CRGB::Blue, CRGB::Aqua,  CRGB::White);   // Third, here's a simpler, three-step gradient, from black to red to white   //   gPal = CRGBPalette16( CRGB::Black, CRGB::Red, CRGB::White);


void loop()
{   if (!digitalRead(4)) {     gPal = HeatColors_p;   } else {     gPal = CRGBPalette16( CRGB::Black, CRGB::Blue, CRGB::Aqua,  CRGB::White);   }   // Add entropy to random number generator; we use a lot of it.   random16_add_entropy( random());   // Fourth, the most sophisticated: this one sets up a new palette every   // time through the loop, based on a hue that changes every time.   // The palette is a gradient from black, to a dark color based on the hue,   // to a light color based on the hue, to white.   //   //   static uint8_t hue = 0;   //   hue++;   //   CRGB darkcolor  = CHSV(hue,255,192); // pure hue, three-quarters brightness   //   CRGB lightcolor = CHSV(hue,128,255); // half 'whitened', full brightness   //   gPal = CRGBPalette16( CRGB::Black, darkcolor, lightcolor, CRGB::White);   Fire2012WithPalette(); // run simulation frame, using palette colors   FastLED.show(); // display this frame   FastLED.delay(1000 / FRAMES_PER_SECOND);

// Fire2012 by Mark Kriegsman, July 2012
// as part of "Five Elements" shown here: http://youtu.be/knWiGsmgycY
// This basic one-dimensional 'fire' simulation works roughly as follows:
// There's a underlying array of 'heat' cells, that model the temperature
// at each point along the line.  Every cycle through the simulation,
// four steps are performed:
//  1) All cells cool down a little bit, losing heat to the air
//  2) The heat from each cell drifts 'up' and diffuses a little
//  3) Sometimes randomly new 'sparks' of heat are added at the bottom
//  4) The heat from each cell is rendered as a color into the leds array
//     The heat-to-color mapping uses a black-body radiation approximation.
// Temperature is in arbitrary units from 0 (cold black) to 255 (white hot).
// This simulation scales it self a bit depending on NUM_LEDS; it should look
// "OK" on anywhere from 20 to 100 LEDs without too much tweaking.
// I recommend running this simulation at anywhere from 30-100 frames per second,
// meaning an interframe delay of about 10-35 milliseconds.
// Looks best on a high-density LED setup (60+ pixels/meter).
// There are two main parameters you can play with to control the look and
// feel of your fire: COOLING (used in step 1 above), and SPARKING (used
// in step 3 above).
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames.  More cooling = shorter flames.
// Default 55, suggested range 20-100
#define COOLING  55

// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
#define SPARKING 120

void Fire2012WithPalette()
{   // Array of temperature readings at each simulation cell   static byte heat[NUM_LEDS];   // Step 1.  Cool down every cell a little   for ( int i = 0; i < NUM_LEDS; i++) {     heat[i] = qsub8( heat[i],  random8(0, ((COOLING * 10) / NUM_LEDS) + 2));   }   // Step 2.  Heat from each cell drifts 'up' and diffuses a little   for ( int k = NUM_LEDS - 1; k >= 2; k--) {     heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2] ) / 3;   }   // Step 3.  Randomly ignite new 'sparks' of heat near the bottom   if ( random8() < SPARKING ) {     int y = random8(7);     heat[y] = qadd8( heat[y], random8(160, 255) );   }   // Step 4.  Map from heat cells to LED colors   for ( int j = 0; j < NUM_LEDS; j++) {     Scale the heat value from 0-255 down to 0-240     for best results with color palettes.     Byte Colorindex = scale8( Heat[J], 240);     CRGB Color = ColorFromPalette( gPal, Colorindex);     Int pixelnumber;     If ( gReverseDirection ) {       pixelnumber = (NUM_LEDS - 1) - J;     } else {       pixelnumber = J;     }     Leds[pixelnumber] = Color;   }


Using the 2 potis on the motion sensor, we can adjust how sensitive the sensor is and how lange the output pin emits the HIGH signal.


The pumpkin glows red to orange:

Pumpkin with normal colors.

As soon as a movement is detected, the color changes to blue:

Unnaturally blue light.



Of course, other colors are also possible. We are already looking forward to your scary creations.


We wish you a lot of fun recreating and say goodbye until the next post.

Your Moritz Spanger

Addendum: 2 errors in the source code corrected. Thanks to Heiko Schütz for the note 👍

For arduinoSpecials


Steffen Dünnebier

Steffen Dünnebier

Das mit dem Extra-5V-Netzteil ist eigentlich alles überflüssig. Man kann das direkt über Mini-USB und Handynetzteil oder eine Powerbank stecken und die beiden externen Teile PIR und RGB-LED dann an +5V der Nanoplatine anlöten. Habe die Powerbank mit in den Kürbis gelegt, lief stundenlang super. Alles mit 5V an Vin anbringen ist eh eigentlich falsch. Vin geht auf der Nanoplatine an einen LM1117 LDO Spannungsregler der am Ausgang 5V liefert, laut Schaltung Arduino Nano. Also müsste/könnte man da auch eine höhere Spannung >6V anschliessen. Es funktioniert aber trotzdem irgendwie anscheinend auch so, weil der LM Spannung wegnimmt und dann ja alles auch mit 3,3V läuft.



Tolles Projekt, meine Tochter ist begeistert – vielen Dank!
Hat auf anhieb funktioniert.
Zur Zeit versuche ich noch beim Code “durchzublicken” um unsere eigenen Farben zu programmieren :-)



Guten Abend zusammen
Ich habe den Kürbis jetzt auch in Betrieb genommen. Nur reagiert mein PIR nicht wie er soll. Es gibt undefiniert hin und wieder einen Signalwechsel. sollte ich bei diesem Teil auf irgendetwas besonders achten?
Ansonsten arbeitet alles wie erwartet. Tolle Idee



Ich habe mal einen Streifenraster Bauplan eingestellt.

Foto: https://pekaru.de/bilder/halloween/lr-0.jpg
Lochraster Oberseite: https://pekaru.de/bilder/halloween/lr-1.jpg
Lochraster Unterseite: https://pekaru.de/bilder/halloween/lr-2.jpg
Lochraster S/W: https://pekaru.de/bilder/halloween/lr-3.jpg

Der 470Ω Widerstand ist nicht unbedingt nötig, eher eine zusätzliche Sicherheit gegen Überspannung am Signalanschluss.
Zum Anschluss eines Netzteils ist eine Einbaubuchse hilfreich. Im Bild ist eine mit folgenden Maßen zu sehen: Ø außen: 6,3 mm, Ø innen: 2,5 mm. Im Plan ist die Buchse
durch die drei Punkte gekennzeichnet.

Die zwei Buchsenleisten dienen als Sockel für den Arduino Nano, sodass man ihn nicht festlöten muss und als Anschluss für den LED Kreis und den Bewegungsmelder (Dupont-Stecker). Ich habe zwei 20 PIN Buchsenleisten verwendet. Die drei gelben “Balken” kennzeichnen die Stellen, an denen man die Leiterbahnen unterbrechen muss.

Bei dem PIR habe ich auf der Arduino Seite die Reihenfolge der Kabel (Data und +) vertauscht, damit das Verbinden der Leiterbahnen auf der Streifenrasterplatine etwas einfacher wird.

Das Teil ist recht kompakt (im Plan ist die Platine breiter als notwendig, wegen der Beschriftung) und sollte in die meisten Kürbisse passen ;-)

Bis Halloween ist es nicht mehr lang, aber vielleicht kann das ja trotzdem jemand brauchen.

Heiko Schütz

Heiko Schütz


Die Meldung “’pragma message…” kannst du ignorieren – das ist nur eine Anweisung an den Compiler, einen Text auszugeben, in diesem Fall die Versionsnummer der FastLED-Bibliothek.

Zu den Fehlern bzgl. BRIGHTNESS und COOLING:

Die beiden werden hier definiert:

Zeile 8: #define BRIGHTNESS 64
Zeile 126: #define COOLING 55

Vielleicht hast du da oder in den beanstandeten Zeilen 48 und 141 noch irgendwelche (im Editor unsichtbaren) Zeichen vor oder nach BRIGHTNESS bzw. COOLING stehen – darauf könnte hindeuten, dass du ja wohl auch mit dem Stray-Error (302…) zu tun hattest. Dort dürfen nur Leerzeichen sein (Space bzw. Tabulatoren). Wenn du keinen Editor hast, der dir Steuerzeichen o.ä. anzeigt, lösche im Zweifelsfall alle Zeichen vor und nach BRIGHTNESS/COOLING von Hand – inklusive dem vorigen oder nächsten Zeichen.

Ich meine folgendes, als Beispiel: in Zeile 8 lösche alles von einschließlich “e” am Ende von “define” bis einschließlich “B” am Beginn von "BRIGHTNESS"und tippe “e” Leerzeichen “B” neu ein, genauso ersetze “S” bis “6” mit einem neu eingetippten “S 6”. Das gleiche dann für COOLING in Zeile 126 und auch in den beiden Zeilen 48 und 141, die der Compiler in den Fehlermeldungen nennt.

Irgendwas ist da wohl beim Kopieren mit den Zeichensatz-Kodierungen ANSI und UTF-8 schiefgegangen.

Warum FastLED.h als doppelt angemeckert wird, erschließt sich mir nicht. Die Arduino-Bibliotheken sind unter Windows normalerweise installiert in c:\users\BENUTZERNAME\Documents\Arduino – im Explorer i.d.R. unter dem Namen “Dokumente” zu finden. Der Pfad ist in der Arduino-IDE eingetragen unter dem Menü Datei → Voreinstellungen im Reiter “Einstellungen” als Sketchbook-Speicherort. Da gibt es für die Bibliotheken ein Unterverzeichnis “libraries” und da sollte nach erfolgreicher Installation über den Arduino-Bibliotheksverwalter ein Verzeichnis “FastLED” zu finden sein; dort befindet sich neben einigen anderen eine Datei “FastLED.h”. Woanders in dem Arduino-Verzeichnis sollte sich keine Kopie der Datei befinden – es sollte also auch nur ein FastLED-Verzeichnis geben (manchmal macht man ja durch versehentliches Ziehen mit der Maus eine Kopie).

Ich hoffe, das hilft dir weiter – es ist natürlich hier im Blog durch das Freischalten der Antworten und die damit verbundenen Zeitverzögerungen recht mühsam, Hilfe zu geben. :-(



ich finde das projekt toll wären da nicht die fehler
Jetzt habe ich die blöden 302 erros raus und jetzt bekomme ich das

In file included from C:\Users\frogg\Documents\Arduino\grblUpload\grblUpload.ino:1:0:

C:\Users\frogg\Documents\Arduino\libraries\FastLED/FastLED.h:14:21: note: #pragma message: FastLED version 3.003.002

pragma message “FastLED version 3.003.002” ^

C:\Users\frogg\Documents\Arduino\grblUpload\grblUpload.ino: In function ‘void setup()’:

grblUpload:48:26: error: ‘BRIGHTNESS’ was not declared in this scope

FastLED.setBrightness( BRIGHTNESS ); ^

C:\Users\frogg\Documents\Arduino\grblUpload\grblUpload.ino: In function ‘void Fire2012WithPalette()’:

grblUpload:141:44: error: ‘COOLING’ was not declared in this scope

heat[i] = qsub8( heat[i], random8(0, ((COOLING * 10) / NUM_LEDS) + 2)); ^

Mehrere Bibliotheken wurden für “FastLED.h” gefunden
‘BRIGHTNESS’ was not declared in this scope

ich bin ein anfänger in dem bereich hat jemand eine idee


Heiko Schütz

Heiko Schütz

@Karsten Stock:

Zum “stray”-Error gibt es hier sogar einen eigenen Beitrag im Blog: https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/kodierungsfehler-schnell-beheben.

Da sind wohl irgendwelche ungültigen Unicode-Zeichen in den Code gekommen. Probier mal, ob der Blog-Beitrag hilft. Man findet sonst auch viel im Web (Suche nach “arduino stray error” o.ä.).



@Karsten Stock: Wahrscheinlich hast du unter Werkzeuge/Boards das falsche Board ausgewählt. Es muss Arduino “Nano” sein, mit der Einstellung “old Bootloader”, sofern der “Arduino” von AZ-Delivery ist und man ihn out of the Box benutzen will.

Eine weitere Fehlermöglichkeit wäre, dass du zwei *.ino Dateien in einem Verzeichnis hast.



habe die Schaltung nachgebaut und das Programm geladen.
Erstes Problem. Es muss der „alte“ Bootloader beim Chip gewählt werden.
Zweites Problem. Keine Funktion. Erst nachdem ich die Anzahl der LEDs im Programm auf 12 gestellt habe läuft alles.
Habe mich dann sofort ans Kürbis schnitzen gemacht.
Happy Halloween.



Schade, dass es keinen Schaltplan via fritzing gibt.
Weiter ist es sehr schade, dass man den Elko nicht bei az-delivery bekommt.
Leider habe ich keinen Elko mit 1000yf zuhause rum liegen.
Liebe Grüße

Dirk, der olle brummbaer

Dirk, der olle brummbaer

Ave @ all!

Zuerst mal Gratulation zu dieser Idee – die Teile zum Nachbau sind (sofern nicht schon vorhanden) bestellt!

Soweit das Gute, jetzt kommt das unvermeidliche “Aber”:
- Ich stimme alexh zu, eine Zeichnung wäre zum besseren Verständnis hilfreich (es muss ja nicht gleich ein fritzing-Projekt sein…)
- ganz allgemein, auch bei anderen Projekten hier, wären mir Erklärungen in den Sketchen in deutscher Sprache sehr lieb. Mein Englisch ist bestenfalls rudimentär und die Übersetzungsprogramme, zu denen ich Zugang habe, sind mit technischen Begriffen eklatant überfordert!

Nichts desto dennoch freue ich mich auf weitere interessante Blogbeiträge!

Dirk (der olle brummbaer)

Karsten Stock

Karsten Stock

Hallo zusammen, ich habe mir auch dieses nette Set zugelegt.
Alles soweit verbunden und wollte jetzt den kopierten Sketch
auf den Nano ziehen. Doch leider bekomme ich beim Überprüfen
eine Fehlermeldung. Habe die FastLED Bibliothek installiert.
Ein kleiner Teil der Fehlermeldung:
RGB_Ring_PIR_3:13: error: stray ‘\240’ in program

RGB_Ring_PIR_3:13: error: stray ‘\302’ in program

RGB_Ring_PIR_3:13: error: stray ‘\240’ in program

Bin leider nicht im Thema beim Programmieren usw.
wollte eigentlich nur mal kurz was basteln ;)

Hat jemand eine Idee dazu was ich falsch gemacht haben könnte?
Vielen Dank im voraus.



Da nach Bildern gefragt wurde, ich habe das Ganze mal auf nem Breadboard zusammen gestuppelt und ein paar Bilder eingestellt. Damit sollten eigentlich die “Verdrahtungsfragen” beantwortet werden.


Der Elko schützt eher weniger, er gleicht nur Spannungsschwankungen aus.
Der Strom auf dem Breadboard kommt von einem Netzteil. Nicht vom USB Anschluss.

Heiko Schütz

Heiko Schütz

Ich hab das gestern mal auf dem Breadboard aufgebaut – allerdings ohne Kürbis: ;-) https://unsinnsbasis.de/wp-content/uploads/2019/10/halloween_az-delivery.jpg

Der USB-Anschluss wird nach dem Hochladen des Sketches nicht mehr benötigt – der Nano kann dann über den +5V-Pin von einem 5-Volt-Netzteil versorgt werden (nicht per Pin “VN” – dort werden 7-12 Volt erwartet und passend heruntergeregelt). Egal ob bei Versorgung mit Netzteil oder USB, muss ein Masse-Pin des Nano mit der Masse des Netzteils verbunden sein (Potenzialausgleich); die entsprechende Steckbrücke ist auf dem Bild nicht besonders gut zu sehen, weil sie durch die Brücke zum +5V-Pin verdeckt wird.

Am Bewegungssensor habe ich das Potentiometer zur Ausschalt-Verzögerung fast ganz nach links gedreht, dann schaltet es nach gut 20 Sekunden aus. Andernfalls sind die Zeiten, die bis zum Ausschalten vergehen, seeeehr lang. ;-) Da ist ein bisschen Ausprobieren angesagt, ebenso bei der Empfindlichkeit/Entfernung.

Noch ein Hinweis zum Programm, dort habe ich zwei Zeilen geändert, um Typ und Anzahl der Neopixel an den verwendeten LED-Ring anzupassen (ich habe nicht ausprobiert, ob die Typ-Angabe WS2811 auch funktioniert):

#define CHIPSET WS2812B // alt: WS2811
#define NUM_LEDS 12 // alt: 30

(Normalerweise nutze ich einen Stecker zur Versorgung der Neopixel-Streifen oder -Ringe, in dessen Anschlussklemmen ich einen 1000 mikroF-Elko fest eingeschraubt habe; ähnlich wie auf dem Bild des LED-Streifens im Heise-Artikel zu sehen; https://www.heise.de/developer/imgs/06/1/8/5/9/1/4/1/1138-00-1b51907260dd64b1.jpeg. Der ist immer schnell zur Hand und macht es auf dem Breadboard übersichtlicher.)

Heiko Schütz

Heiko Schütz

Hallo nochmal und sorry für die Verwirrung, die der Heise-Link ausgelöst hat.
Für mich sieht es so aus, als ob in dem Heise-Bild der Anschluss zum Netzteil falsch gepolt abgebildet ist – dort ist der Minuspol des Steckers mit +5V am LED-Streifen und der Pluspol mit GND verbunden. Wie auch immer – der Elko muss unbedingt richtig gepolt eingebaut werden – der Minuspol ist die Seite mit dem kurzen Beinchen und der silbergrauen Markierung am Gehäuse und wird mit GND/Masse verbunden, der Pluspol mit den 5 Volt Versorgungsspannung.



Hallo, ich bin neu hier und wollte es nachbauen, gibt es vielleicht ein Bild von einem fertig verdrahtetem Set? Und wieso ist der Elko auf dem Bild von Heise falsch verdrahtet. Ich bin noch blutiger Anfänger auf dem Gebiet der Elektronik.
Danke im Voraus für eure Hilfe.



Braucht der Nano im Betrieb noch Strom über USB oder ausschließlich über das Netzteil?

Ich stimme Alex zu, ein Fritzing und/oder Bild der Verlötung bzw. eines Breadboard-Aufbaus wäre hilfreich.

@Heiko Schütz: Der Elko auf dem Fritzing-Plan von Heise scheint mir falschrum eingebaut zu sein? Das wäre ziemlich fatal, wenn jemand sich dort am Aufbau orientiert.




@Heiko Schütz
Vielen Dank für den Hinweis!

Heiko Schütz

Heiko Schütz


Der Elko ist eine Schutzmaßnahme. Infos dazu und ein Fritzing-Diagramm, wie die Schaltung aussieht, findest du z.B. in einem Artikel bei Heise Developer: https://www.heise.de/developer/artikel/Von-Erleuchtungen-und-Lichterketten-3277261.html – dort im Absatz “Schaltung”.

Eine weitere nützliche Quelle zum Umgang mit Neopixeln ist der “Adafruit Neopixel Überguide” – zum Elko siehe die Seite https://learn.adafruit.com/adafruit-neopixel-uberguide/best-practices



Eine sehr schöne Idee. Wird gleich nachgebastelt.



das ist doch mal eine gute Idee zu Helloween!

Ich bin zwar im letzten Jahr irgendwie nicht zum Basteln gekommen, freue mich aber jedes Mal, wenn Ihr so nette Bauanleitungen veröffentlicht. Macht bitte weiter so!

Heiko Schütz

Heiko Schütz

Nur eine kleine Ergänzung, weil ich den Ring selber vor kurzem gekauft habe: der 12er-LED-Ring wird so geliefert wie auf dem Produktfoto (https://www.az-delivery.de/products/kopie-von-rgb-led-ring-ws2812-mit-12-rgb-leds-5v-fuer-arduino) abgebildet – also ohne Anschlusskabel o.ä.. Es muss ein klein wenig gelötet werden (3 Lötstellen).

Das sollte auch für Anfänger kein Problem sein. Nur wer keinen Lötkolben greifbar hat, guckt womöglich nach dem Auspacken etwas dumm aus der Wäsche, weil das Set nicht ganz “Plug & Play” ist. ;-)



Hallo, eine nette Idee!
Könnten Sie noch zusätzlich ein Bild posten, wie das ganze verlötet ausschaut?
Oder ein Bild von der Schaltung?
Wozu benötige ich den Elektrolyt Kondensator?
Danke im Voraus!

Leave a comment

All comments are moderated before being published

Recommended blog posts

  1. Install ESP32 now from the board manager
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP programming via WLAN