Four-way switch logic on an Arduino Uno

// Four-way switch logic: three switches, one lamp, flip any of them.
//
// TEACHING MODEL, NOT HOUSE WIRING. This is a logic model on low-voltage
// stand-ins. It is not a way to wire a building, and nothing here is safe to
// connect to mains or to a real lighting circuit.
//
//   pin 2    switch A, the first end (SPDT slide switch)
//   pin 3    switch B, the intermediate (see below)
//   pin 4    switch C, the second end (SPDT slide switch)
//   pin 13   the lamp: a red LED through 220 ohms to GND
//
// Each switch has its common (pin 2 of the slide switch) on the Uno pin and
// one throw on GND. The pins use INPUT_PULLUP, so a switch slid to the GND
// side reads 0 and a switch slid to the open side reads 1.
//
// HOW THE REAL THING WORKS. A three-way run is two SPDT switches joined by
// two traveler wires. Switch 1 feeds the hot to one traveler, switch 2
// listens on one traveler, and the light is on when they match up. Flipping
// either end changes the match, so the light toggles.
//
// A four-way switch goes in the middle of the travelers. It is a DPDT switch
// wired as a reversing switch: in one position it passes the two travelers
// straight through, in the other it swaps them (it crosses them). Swapping
// the travelers is exactly the same as flipping one end switch: whichever
// traveler was live is now the other one. That is why every extra
// intermediate switch flips the parity of the whole circuit, and why you can
// add as many four-ways as you like between the two three-way ends.
//
// So the lamp is the parity (XOR) of all the switch positions:
//
//   lamp = A xor B xor C
//
// With an even number of switches at 1 the lamp is off; with an odd number it
// is on.
//
// WHAT THE MODEL DOES. The catalog has no DPDT reversing switch (the DPDT
// part is a relay), so the intermediate is modeled as one more slide switch
// read as a logic input, and the crossing of the travelers is done in code by
// the XOR. The sketch does not wire any traveler; it computes what the
// travelers would deliver.
//
// SERIAL (115200). A truth table for three switches prints once at boot, then
// one line every time any switch flips, like: A=1 B=0 C=1 lamp=0

const int SW_A = 2;
const int SW_B = 3;
const int SW_C = 4;
const int LAMP = 13;

const unsigned long DEBOUNCE_MS = 20;

int stateA = 0;
int stateB = 0;
int stateC = 0;
int lastRaw = -1;
unsigned long changedAt = 0;

// The lamp is the parity of the switch positions.
int lampFor(int a, int b, int c) {
  return a ^ b ^ c;
}

int readRaw() {
  // 1 when the switch is slid to its open side (the pull-up reads HIGH).
  int a = digitalRead(SW_A) == HIGH ? 1 : 0;
  int b = digitalRead(SW_B) == HIGH ? 1 : 0;
  int c = digitalRead(SW_C) == HIGH ? 1 : 0;
  return (a << 2) | (b << 1) | c;
}

void printRow(int a, int b, int c) {
  Serial.print("A=");
  Serial.print(a);
  Serial.print(" B=");
  Serial.print(b);
  Serial.print(" C=");
  Serial.print(c);
  Serial.print(" lamp=");
  Serial.println(lampFor(a, b, c));
}

void setup() {
  Serial.begin(115200);
  Serial.println("Mokxi Arduino Uno: four-way switch logic");
  Serial.println("lamp = A xor B xor C");
  Serial.println("truth table:");
  for (int i = 0; i < 8; i++) {
    printRow((i >> 2) & 1, (i >> 1) & 1, i & 1);
  }
  pinMode(SW_A, INPUT_PULLUP);
  pinMode(SW_B, INPUT_PULLUP);
  pinMode(SW_C, INPUT_PULLUP);
  pinMode(LAMP, OUTPUT);
  int raw = readRaw();
  lastRaw = raw;
  stateA = (raw >> 2) & 1;
  stateB = (raw >> 1) & 1;
  stateC = raw & 1;
  digitalWrite(LAMP, lampFor(stateA, stateB, stateC) ? HIGH : LOW);
  Serial.print("now: ");
  printRow(stateA, stateB, stateC);
}

void loop() {
  int raw = readRaw();
  if (raw != lastRaw) {
    lastRaw = raw;
    changedAt = millis();
  }
  // Believe a new position once it has held for a few milliseconds.
  int held = (raw != ((stateA << 2) | (stateB << 1) | stateC)) && (millis() - changedAt >= DEBOUNCE_MS);
  if (held) {
    stateA = (raw >> 2) & 1;
    stateB = (raw >> 1) & 1;
    stateC = raw & 1;
    digitalWrite(LAMP, lampFor(stateA, stateB, stateC) ? HIGH : LOW);
    printRow(stateA, stateB, stateC);
  }
}