Make a Porch Light That Turns On at Dusk

Halloween is on October 31, and the best part of a porch display starts as the sun goes down. In this post you will build a light that turns itself on at dusk, using a photoresistor and an Arduino Uno in Mokxi. The interesting part is not the sensor. It is how to stop the lamp from flickering on and off while the daylight fades.

This is a low-voltage LED build. A lamp that plugs into the wall uses mains power, which is outside what I cover here.

What you need

• An Arduino Uno.
• A photoresistor sensor module. In Mokxi it is the ldrmodule part, with the pins VCC, GND, DO and AO.
• The Uno's built-in LED on pin 13 as the "lamp".

A photoresistor (also called an LDR, for light-dependent resistor) is a resistor whose value changes with light. It has a high resistance in the dark and a low one in the light. The module puts it in a divider with a 10 kilohm resistor, so the voltage on AO falls as the light rises. In Mokxi's model the reading is lower in more light and higher in the dark. The module also has a comparator that makes DO go high in the dark, but we will use AO and make the decision in code.

If you build the divider yourself from the bare LDR part, put the LDR on the ground side with 10 kilohms above it to get the same direction. With the LDR on the 5 volt side, the reading rises with light instead, and you would swap the two comparisons below.

Wire it up

This is the wiring of Mokxi's Dusk switch example, so you can start from that project and paste the sketch below over its code.

Module pin	Uno pin	What it does
VCC	5V	Power
GND	GND	Ground
AO	A0	The light as a voltage
DO	pin 2	Not used in this sketch

The lamp needs no wiring, because the Uno's built-in LED is on pin 13 (LED_BUILTIN).

Why a plain threshold flickers

The simplest version says "if the reading is above 500, turn the lamp on". It works, until the light sits close to 500. Clouds drift, a car passes, the reading wobbles by a few counts, and the lamp flips on and off again and again. Mokxi's part page notes that a real comparator board has the same chatter when the light sits right at the threshold.

The fix is hysteresis: two thresholds, with a gap between them. The lamp turns on only when it gets properly dark, and turns off only when it gets properly bright. In between, it keeps doing whatever it was already doing.

The complete sketch

const int LIGHT_PIN = A0;
const int LAMP_PIN = LED_BUILTIN;

const int LAMP_ON_ABOVE = 600;
const int LAMP_OFF_BELOW = 450;
const int SAMPLES = 8;

bool lampOn = false;
unsigned long lastPrint = 0;

int readLight() {
  long total = 0;
  for (int i = 0; i < SAMPLES; i++) {
    total += analogRead(LIGHT_PIN);
    delay(5);
  }
  return total / SAMPLES;
}

void setup() {
  Serial.begin(9600);
  pinMode(LAMP_PIN, OUTPUT);
  Serial.println("Porch light ready");
}

void loop() {
  int light = readLight();

  if (!lampOn && light > LAMP_ON_ABOVE) {
    lampOn = true;
    Serial.println("Dusk: lamp on");
  } else if (lampOn && light < LAMP_OFF_BELOW) {
    lampOn = false;
    Serial.println("Daylight: lamp off");
  }
  digitalWrite(LAMP_PIN, lampOn ? HIGH : LOW);

  if (millis() - lastPrint >= 1000) {
    lastPrint = millis();
    Serial.print("light ");
    Serial.println(light);
  }
}

Walk through it

• Line 1 names the sensor pin, A0. Line 2 names the lamp pin. LED_BUILTIN is the board's own LED.
• Lines 4 and 5 are the two thresholds. The lamp turns on when the reading is above 600 and off when it is below 450. A gap of 150 counts is the dead band.
• Line 6 sets SAMPLES to 8.
• readLight() reads the pin eight times, 5 milliseconds apart, and returns the average. Averaging smooths out small jumps so one odd reading cannot flip the lamp.
• loop() makes the decision. If the lamp is off and the light is above 600, it turns on. Otherwise, if the lamp is on and the light is below 450, it turns off. A reading between 450 and 600 matches neither test, so nothing changes.
• lampOn is the memory. That one variable is what makes hysteresis work: the decision depends on the current state, not only on the new reading.
• digitalWrite(LAMP_PIN, lampOn ? HIGH : LOW) sets the output from the state, in one place.
• The last block prints the reading once a second with millis(), so you can watch the number while you move the slider.

Run it

Press Run and open the serial monitor. Drag the module's light slider and watch what happens. These are the numbers I saw in the simulator, with the lamp state each time:

Light slider	Reading	Lamp
500 lux (bright)	about 250	off
20 lux (dusk)	about 772	turns on
90 lux	about 530	stays on (in the gap)
200 lux	about 389	turns off
70 lux	about 574	stays off (in the gap)
20 lux	about 772	turns on

The two rows in the gap are the point. At 90 lux and at 70 lux the readings are almost the same, yet the lamp is in a different state, because each one remembers where it came from.

Choosing your own thresholds

Print the reading at the brightness where you want the lamp to change, then set the two thresholds a little on either side. A wider gap means fewer false switches. A narrower gap means a more exact switching point. Start wide, then narrow it.

What to try next

• Widen the gap to 250 counts and see how much more the light must change.
• Add a wait: only switch after the reading has stayed past the threshold for 10 seconds.
• Use DO on pin 2 instead of AO and compare. You will see the comparator's hard switch without any gap.
• Wire a second LED so one means "dusk detected" and one means "lamp on".
• Read the LDR part page for the model, and the Arduino LDR guide for more ways to use it.

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