Flickering Jack-o-Lantern Light on an ESP32-C3

Happy Halloween. A real candle in a pumpkin never burns steadily. It dips, jumps and settles again, and that wobble is what makes a jack-o-lantern feel alive. Today you will fake it with one addressable LED and an ESP32-C3 in your browser. The light picks random brightness targets in warm orange and eases toward them, so it flickers without ever looking jittery. I built and ran this sketch on the simulated C3 to check that the strip receives its data.

What you need

• One ESP32-C3 board (the DevKitM-1 in Mokxi).
• One WS2812 LED. In Mokxi it is the same part as a strip or ring, so set its count to 1.
• Three jumper wires.

A WS2812, also sold as a NeoPixel, is an LED with a small chip inside. One data wire tells it exactly what color to show.

Wire it up

From	To	Why
C3 GPIO 5	WS2812 DIN	Data in
C3 5V	WS2812 VDD	Power
C3 GND	WS2812 VSS	Ground

Why GPIO 5? On the C3, pins 18 and 19 double as the USB pins and 20 and 21 as the serial pins on the real board, so they are best left alone for something like this. GPIO 5 is a plain pin, and the built-in Rainbow strip example uses it for its data line too, so it is a safe, boring choice. The C3 runs at 3.3 V logic. Real strips sometimes want a level shifter when powered from 5 V, so keep that in mind if you build it on a bench. The simulator does not model that.

The complete sketch

#include <Adafruit_NeoPixel.h>

const int LED_PIN = 5;
const int LED_COUNT = 1;

Adafruit_NeoPixel pixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

int level = 150;
int target = 150;
unsigned long nextFrame = 0;

void setup() {
  Serial.begin(115200);
  randomSeed(analogRead(0));
  pixel.begin();
  pixel.clear();
  pixel.show();
  Serial.println("Jack-o-lantern lit");
}

void loop() {
  unsigned long now = millis();
  if (now < nextFrame) return;
  nextFrame = now + 30;

  if (random(0, 5) == 0) {
    target = random(40, 256);
  }
  level += (target - level) / 3;

  int red = level;
  int green = level * 2 / 5;
  int blue = level / 40;
  pixel.setPixelColor(0, pixel.Color(red, green, blue));
  pixel.show();
}

Press Run and the LED glows orange and wanders in brightness. The serial monitor says "Jack-o-lantern lit" once.

Walkthrough

Before the line-by-line tour, here is the idea in one breath. Fire is not random noise. A flame leans toward a new brightness and takes a moment to get there, then something changes and it leans somewhere else. The sketch copies that behavior with two numbers, where the light is and where it wants to be, and one rule for moving the first toward the second. Everything else is setup and color.

#include <Adafruit_NeoPixel.h> loads the library. On the ESP32-C3, Mokxi provides this header on top of its WS2812 driver, so the usual Adafruit NeoPixel tutorial code compiles as written. It supports calls such as setPixelColor, Color, fill, clear and setBrightness.

Adafruit_NeoPixel pixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); makes the strip object: one LED, on GPIO 5, with its colors sent in green-red-blue order at 800 kHz, which is how WS2812B LEDs expect them.

level is how bright the light is now, and target is the brightness it is heading toward. Both start at 150. nextFrame stores when the next update is due.

In setup(), Serial.begin(115200) starts the monitor. randomSeed(analogRead(0)) reads GPIO 0, which is an analog input on the C3, so the random numbers differ from run to run. pixel.begin() prepares the data pin. pixel.clear() and pixel.show() start with the LED off, because nothing appears until show() sends the data.

loop() begins with millis(), the number of milliseconds since the board started. If now is less than nextFrame, the function returns and does nothing, so the code runs one animation frame every 30 milliseconds without ever calling delay().

if (random(0, 5) == 0) is true about one time in five. When it is, target gets a new random brightness from 40 to 255. That is the flicker: sometimes the flame wants to be dim and sometimes bright.

level += (target - level) / 3; is the smoothing. Each frame, the light moves a third of the remaining distance toward its target. Big gaps close fast and small ones slowly, which looks like a flame settling. The math uses whole numbers only.

The last three lines build the color. Full orange flame has a lot of red, a medium amount of green and almost no blue, so green is two fifths of the level and blue is one fortieth. As level drops, all three fall together and the orange just gets darker without changing hue. pixel.show() sends the color to the LED.

What to try next

• Change the speed. Raise nextFrame = now + 30 to 60 for a lazier flame.
• Calm or wild. Change random(0, 5) to random(0, 10) for fewer jumps, or random(0, 2) for a restless flame.
• A ghostly version. Set the color to pixel.Color(level / 4, level / 4, level) for a cold blue light.
• Add more LEDs. Set LED_COUNT to 4 and the part's count to 4, then give each LED its own level and target using arrays.
• Add a knob. Wire a potentiometer wiper to GPIO 0 and use analogRead(0) to set how dim the dimmest flicker can be.

When you want a bigger display, the Halloween props guide has more spooky builds, and the ESP32 simulator page shows what else the C3 can do.

Enjoy the evening, and may your pumpkin glow all night long. Ready to build it yourself? Create your free Mokxi account and open the editor in your browser. No installs, no parts to buy.