PIR and Relay Halloween Fog Trigger

Walk up to a dark porch and a puff of fog rolls out to meet you. That is the effect behind a lot of Halloween props, and the logic behind it is simple: a motion sensor, a switch and a timer. In this post you will build a motion-triggered fog trigger on an Arduino Uno in your browser, using a PIR motion sensor, a relay module and two status LEDs.

A note on safety, said plainly

This post is about the logic and the low-voltage circuit, and everything here runs in a simulation. It is not a guide to wiring anything to wall power, and it does not give any advice on doing that. In the simulated circuit, the relay's contacts switch a small white LED from the 5 V rail. That LED stands in for the input on a fog machine's remote. If you want to take a project like this to real hardware, read the manual that came with your equipment, keep every part that touches mains power well away from this circuit, and ask someone with experience to look it over first.

What you need

An Arduino Uno and a half-size breadboard
A PIR motion sensor
A relay module
Three LEDs: green, red and white
Three 220 ohm resistors
Jumper wires

A PIR (passive infrared) sensor notices movement by watching for changes in the infrared heat in front of it. A relay is a switch that a small signal from the Uno closes, which lets one circuit control another without the two sharing a wire. The relay part page shows the pins.

The wiring

Mokxi's built-in Fog machine trigger project uses exactly this wiring, so you can open it to compare against your own.

Part and pin	Connects to	Note
PIR VCC	5V	Power.
PIR GND	GND	Ground.
PIR OUT	Uno pin 2	Goes HIGH when it sees motion.
Relay VCC	5V	Power for the module.
Relay GND	GND	Ground.
Relay IN	Uno pin 7	HIGH pulls the relay in.
Relay COM	5V rail	Common contact.
Relay NO	220 ohm resistor, then white LED, then GND	Stands in for the machine's remote input.
Green LED (ready)	Uno pin 4 through 220 ohms, to GND	On when ready.
Red LED (cooling)	Uno pin 3 through 220 ohms, to GND	On while cooling down.

NO means "normally open": the switch is open until the relay is driven, and then it closes. When pin 7 goes HIGH, COM connects to NO, and the white LED lights.

The complete sketch

const int PIR_PIN = 2;
const int RELAY_PIN = 7;
const int READY_LED = 4;
const int COOL_LED = 3;

const unsigned long BURST_MS = 2500;
const unsigned long COOLDOWN_MS = 20000;

enum State { READY, FOGGING, COOLING };

State state = READY;
unsigned long stateStart = 0;
int bursts = 0;

void enter(State next) {
  state = next;
  stateStart = millis();

  digitalWrite(READY_LED, state == READY ? HIGH : LOW);
  digitalWrite(COOL_LED, state == COOLING ? HIGH : LOW);
  digitalWrite(RELAY_PIN, state == FOGGING ? HIGH : LOW);
}

void setup() {
  Serial.begin(9600);
  pinMode(PIR_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(READY_LED, OUTPUT);
  pinMode(COOL_LED, OUTPUT);
  enter(READY);
  Serial.println("Ready for motion");
}

void loop() {
  unsigned long elapsed = millis() - stateStart;

  if (state == READY && digitalRead(PIR_PIN) == HIGH) {
    bursts++;
    enter(FOGGING);
    Serial.print("Motion. Burst number ");
    Serial.println(bursts);
  } else if (state == FOGGING && elapsed >= BURST_MS) {
    enter(COOLING);
    Serial.println("Burst done. Cooling down.");
  } else if (state == COOLING && elapsed >= COOLDOWN_MS) {
    enter(READY);
    Serial.println("Ready for motion");
  }
}

I compiled this sketch for the Uno with Mokxi's own build path. It is my own version of the same idea as the built-in project, so the wiring above matches both.

How it works, line by line

The sketch is a small state machine. A state machine is a program that is always in exactly one named state, and that moves to another state when something happens. Ours has three states.

READY. The green LED is on. The relay is off. We wait for the PIR.
FOGGING. The relay is on, so the white LED lights. After BURST_MS (2.5 seconds), we move on.
COOLING. The red LED is on and the relay is off. After COOLDOWN_MS (20 seconds), we go back to READY.

Now the code.

The four const int lines name the pins.
BURST_MS and COOLDOWN_MS are the two timings. Changing them changes the prop. unsigned long is the type that holds millis().
enum State { READY, FOGGING, COOLING }; lists the three states as names, so the code reads like a sentence.
enter(next) is the one function that changes state. It records the new state, restarts the clock with millis(), and sets all three outputs to match. Setting everything in one place means the LEDs and relay can never disagree about the state.
In loop(), elapsed is how long we have been in the current state. We use millis() rather than delay(), so the sketch keeps checking the sensor and never freezes.
The if and two else if lines are the three moves: motion in READY, the burst ending in FOGGING, and the cooldown ending in COOLING.

Run it

Press Run. Click the PIR's dome to start something moving in front of it. The green LED goes out, the white LED lights for the burst, and the red LED stays on through the cooldown. The serial monitor prints each step.

The PIR has its own timing. In Mokxi it holds its output high for a hold time after the movement stops, then ignores motion for a block time. Because our cooldown is longer than both, the prop never fires twice from one wave.

Try next

Make the burst shorter for a tabletop prop, or longer for a bigger space.
Add a pushbutton on pin 8 as a manual "fog now" that still obeys the cooldown. Use INPUT_PULLUP and check for LOW.
Print how many seconds of cooldown remain once a second.
Use the PIR's properties to change the hold time and see how the sketch reacts.
Read how the sensor works in the PIR motion sensor tutorial and see more builds on the Halloween props page.

Try it on Mokxi

Open the Fog machine trigger project to run the finished build, then find the PIR and the other parts in the parts list.

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