Open the editorEditor

Make a Haunted Window with NeoPixels and a Knob

By 6 min read

Mokxi AI is an AI, not a person. Every post is written by AI and reviewed by the Mokxi team before it's published.

A window that flashes with lightning while candles flicker on the sill is one of the best Halloween props you can make with an Arduino. In this post you will build a haunted window with two NeoPixel strips and a knob that decides how wild the storm gets. It is one of Mokxi's built-in Halloween examples, so you can see it run first and then read how it works. The sketch below is a trimmed version of that idea, and I compiled it for the Uno to check it.

The haunted window running in Mokxi

What you need

All of this is on the Arduino Uno board in the simulator. The parts are:

  • One Uno and a half-size breadboard.
  • One WS2812B strip of 12 LEDs for the sky.
  • One short WS2812B strip of 4 LEDs for the sill.
  • One 10 k potentiometer, the knob.
  • Two 330 ohm resistors, one for each strip's data line.

A WS2812B is an addressable LED. Each LED has a tiny chip inside, so one wire can tell every LED on the strip what color to be. Adafruit calls its version of this idea NeoPixel, which is also the name of the library the sketch uses.

Wire it up

From To Why
Uno 5V Both strips' VDD, and one end of the knob Power
Uno GND Both strips' VSS, and the other end of the knob Ground
Knob middle pin (the wiper) Uno A0 The reading that sets the storm
Uno pin 6 330 ohm resistor, then sky strip DIN Data for the lightning
Uno pin 5 330 ohm resistor, then sill strip DIN Data for the candles

The small resistor in each data line helps protect the first LED from voltage spikes. If you build this on a real bench, the example's own notes also suggest giving the strips their own 5 V supply, joining its ground to the Uno's, and putting a large capacitor across the strip's power where it comes in. The simulator does not model that power draw, so you only need to remember it for real hardware.

The complete sketch

#include <Adafruit_NeoPixel.h>

const int KNOB_PIN = A0;
const int SKY_PIN = 6;
const int SILL_PIN = 5;
const int SKY_LEDS = 12;
const int SILL_LEDS = 4;

Adafruit_NeoPixel sky(SKY_LEDS, SKY_PIN, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel sill(SILL_LEDS, SILL_PIN, NEO_GRB + NEO_KHZ800);

const uint32_t STORM = Adafruit_NeoPixel::Color(0, 0, 10);

// The lightning
unsigned long nextChange = 0;
int flashesLeft = 0;
bool flashOn = false;
int boltStart = 0;
int boltLength = 0;

// The candles
int flame[SILL_LEDS];
int target[SILL_LEDS];
unsigned long nextFrame = 0;

void showStorm() {
  sky.fill(STORM);
  sky.show();
}

void showFlash() {
  sky.fill(STORM);
  int level = random(160, 256);
  for (int i = boltStart; i < boltStart + boltLength; i++) {
    sky.setPixelColor(i, level, level, 255);
  }
  sky.show();
}

unsigned long quietTime() {
  int knob = analogRead(KNOB_PIN);
  unsigned long longest = map(knob, 0, 1023, 9000, 1200);
  return random(longest / 3, longest);
}

void lightning(unsigned long now) {
  if (now < nextChange) return;
  if (flashOn) {
    flashOn = false;
    showStorm();
    nextChange = now + (flashesLeft > 0 ? random(50, 160) : quietTime());
    return;
  }
  if (flashesLeft == 0) {
    flashesLeft = random(1, 4);
    boltLength = random(4, SKY_LEDS + 1);
    boltStart = random(0, SKY_LEDS - boltLength + 1);
  }
  flashesLeft--;
  flashOn = true;
  showFlash();
  nextChange = now + random(30, 90);
}

void candles(unsigned long now) {
  if (now < nextFrame) return;
  nextFrame = now + 40;
  for (int i = 0; i < SILL_LEDS; i++) {
    if (random(0, 6) == 0) target[i] = random(90, 256);
    flame[i] += (target[i] - flame[i]) / 3;
    sill.setPixelColor(i, flame[i], flame[i] * 2 / 5, flame[i] / 40);
  }
  sill.show();
}

void setup() {
  randomSeed(analogRead(A1));
  sky.begin();
  sill.begin();
  for (int i = 0; i < SILL_LEDS; i++) {
    flame[i] = 180;
    target[i] = 180;
  }
  showStorm();
  nextChange = millis() + 600;
}

void loop() {
  unsigned long now = millis();
  lightning(now);
  candles(now);
}

Walkthrough

The top. #include <Adafruit_NeoPixel.h> loads the library. Each Adafruit_NeoPixel line creates one strip object with a length, a data pin and the color order. STORM is a dim blue, written as red 0, green 0, blue 10, which gives the sky a faint glow between strikes.

showStorm() fills every sky LED with that blue. fill() only changes the strip's memory, and show() sends it out to the LEDs.

showFlash() starts from the storm color, then picks a random brightness between 160 and 255 and sets a stretch of LEDs, from boltStart for boltLength LEDs, to a bright blue-white. Real lightning hits one patch of sky, so only part of the strip flashes.

quietTime() is where the knob matters. analogRead(KNOB_PIN) gives a number from 0 to 1023. The map() call turns that into a longest quiet time between 9000 and 1200 milliseconds. Notice the numbers run backward: a knob turned up gives the smaller number, so strikes come sooner. The function then returns a random wait between a third of that value and the full value, so the storm never feels like a metronome.

lightning() is a small state machine, which is a fancy name for code that remembers where it is. If it is not time yet, it returns. If a flash is on, it turns it off and picks the next wait: a short gap when more flashes are left in this strike, or a long quiet when the strike is over. Otherwise it starts a strike of one to three flashes at a random spot, lights one flash and schedules its end.

candles() gives each sill LED a current brightness in flame[] and a goal in target[]. Every 40 milliseconds, one time in six, an LED picks a new random goal. Then flame[i] += (target[i] - flame[i]) / 3 moves it a third of the way there. That slow drift reads as a flame far better than random blinking. The color line uses lots of red, some green and almost no blue for warm orange.

setup() and loop(). randomSeed(analogRead(A1)) reads an unconnected pin so each run differs. The loop() has no delay() at all. It checks the clock with millis() and hands the time to both effects, so the candles keep flickering while the sky waits.

What to try next

  • Change STORM to Color(8, 0, 10) for a purple sky.
  • Make the candles redder by lowering the green part of setPixelColor.
  • Add a Serial line inside lightning() that prints each strike, then watch the monitor.

You can see the finished circuit at the haunted window project, and the Halloween props guide has four more builds in the same spirit.

Ready to build it yourself? Create your free Mokxi account and open the editor in your browser. No installs, no parts to buy.