Rescue beacon on an Arduino Uno

// Rescue beacon: a white LED that flashes SOS after dark, on an Uno.
//
//   A0      the middle of a divider: 5 V, an LDR, A0, 10k, GND
//   pin 6   the beacon LED, through 220 ohm to GND
//   pin 2   TEST button to GND (forces the beacon on, press again to release)
//
// In daylight the beacon sleeps, because a rescue signal nobody can see is a
// waste of battery. When the light drops it starts: three short flashes, three
// long, three short, a pause, and again. The TEST button turns it on whatever
// the light is, so you can see that it works.
//
// # A pattern is data
//
// Morse is not a program, it is a table. PATTERN lists how long each part of
// SOS lasts, in units of 200 ms, alternating ON, OFF, ON, OFF: the first
// number is a short flash, the second the gap after it, and so on. S is
// "1,1,1,1,1,3" (flash, gap, flash, gap, flash, and a longer gap that ends
// the letter), O is the same with 3s for the flashes. To send something else
// you change the table and not a line of code.
//
// # A player that never waits
//
// The sketch keeps one number, `step`, which is where in the table it is, and
// the time at which that step ends. loop() asks whether the time has come,
// and if it has, goes to the next step and flips the LED. Between those
// moments it is free to read the light sensor and the button, so the beacon
// can be switched off the instant it gets light, even half way through a
// flash. A version with delay() would have to finish the whole SOS first.
//
// # Light and dark with a gap between them
//
// Dusk is not a moment, and a cloud passing over the sensor should not start
// the beacon. Two thresholds, one for going dark and a higher one for coming
// back to light, keep it from flickering in between; the same idea as a
// thermostat's gap.

const uint8_t SENSOR = A0;
const uint8_t BEACON = 6;
const uint8_t TEST = 2;

const int DARK = 250;     // below this the beacon wakes (0 to 1023)
const int LIGHT = 500;    // above this it goes back to sleep
const unsigned long UNIT_MS = 200;
const unsigned long REST_MS = 5000;

// ON, OFF, ON, OFF ... in units: S (. . .), O (- - -), S (. . .)
const uint8_t PATTERN[] = {1, 1, 1, 1, 1, 3, 3, 1, 3, 1, 3, 3, 1, 1, 1, 1, 1, 7};
const uint8_t STEPS = sizeof(PATTERN);

bool night = false;
bool forced = false;
bool active = false;      // the beacon is running (dark, or forced)
uint8_t step = 0;
unsigned long stepEnd = 0;
bool resting = false;
unsigned long sent = 0;
bool lastReading = HIGH;
bool pressedState = HIGH;  // the button's debounced state
unsigned long changedAt = 0;

void stopBeacon() {
  active = false;
  resting = false;
  step = 0;
  digitalWrite(BEACON, LOW);
}

void startBeacon(unsigned long now) {
  active = true;
  resting = false;
  step = 0;
  stepEnd = now + PATTERN[0] * UNIT_MS;
  digitalWrite(BEACON, HIGH);
}

void setup() {
  Serial.begin(115200);
  pinMode(BEACON, OUTPUT);
  pinMode(TEST, INPUT_PULLUP);
  Serial.println("rescue beacon ready");
}

void loop() {
  unsigned long now = millis();

  // light and dark, with a gap
  int light = analogRead(SENSOR);
  if (!night && light < DARK) {
    night = true;
    Serial.println("dark: beacon on");
  } else if (night && light > LIGHT) {
    night = false;
    Serial.println("daylight: beacon asleep to save the battery");
  }

  // the test button toggles an override. A reading counts once it has held
  // for 40 ms, which rides out the chatter of the contacts on the way down
  // and on the way back up.
  bool reading = digitalRead(TEST);
  if (reading != lastReading) {
    lastReading = reading;
    changedAt = now;
  }
  if (reading != pressedState && now - changedAt > 40) {
    pressedState = reading;
    if (pressedState == LOW) {
      forced = !forced;
      Serial.println(forced ? "test: beacon forced on" : "test: released");
    }
  }

  bool want = night || forced;
  if (want && !active) startBeacon(now);
  if (!want && active) stopBeacon();

  if (active && now >= stepEnd) {
    if (resting) {
      startBeacon(now);
    } else {
      step++;
      if (step >= STEPS) {
        sent++;
        Serial.print("SOS #");
        Serial.print(sent);
        Serial.println(" sent");
        resting = true;
        digitalWrite(BEACON, LOW);
        stepEnd = now + REST_MS;
      } else {
        digitalWrite(BEACON, (step % 2 == 0) ? HIGH : LOW);
        stepEnd = now + PATTERN[step] * UNIT_MS;
      }
    }
  }
}