Find the emergency broadcast on an Arduino Uno

// Find the emergency broadcast: a tuning knob, a TM1637, a traffic light and a
// piezo on an Uno.
//
//   potentiometer   wiper -> A0, ends to 5 V and GND
//   TM1637          CLK -> pin 6, DIO -> pin 7
//   traffic light   red -> pin 2, yellow -> pin 3, green -> pin 4
//   piezo           pin 10 and GND
//
// Somewhere between 88.0 and 108.0 MHz one station is still on the air. Its
// frequency is picked at random each time the sketch starts. Turn the knob:
// the display shows where you are tuned and the piezo hisses with static. The
// closer you get, the less static, the traffic light goes from red (cold)
// through yellow (warm) to green, and on the station itself the static stops
// and the broadcast beeps through. The Serial Monitor prints the signal as it
// changes, and the message once you are locked on.
//
// # Hot and cold: searching with a number that peaks
//
// The sketch never tells you where the station is. It only gives you the
// signal strength, which is 100 on the station's frequency and falls away in a
// straight line to 0 at 1.5 MHz either side. Finding the peak of something you
// can only measure is called hill climbing, and it is how a real radio
// is tuned by ear, and how a robot finds a heat source. Turn toward more.
//
// # A knob that does not sit still
//
// An analog reading wobbles by a count or two even when nobody touches the
// knob, and a tuner that jitters between 95.3 and 95.4 is annoying. The
// reading goes through an exponential moving average (a quarter of the new
// value, three quarters of the old one) and the frequency is computed from
// that, so the display settles. The average also needs a little time to catch
// up when the knob moves; that is the price of smoothness.
//
// # Static is random notes, not a sound file
//
// A piezo plays one note at a time, so static is faked: every 40 ms there is a
// chance, bigger when the signal is weak, of a short note at a random pitch.
// The chance is (100 - signal) percent, so at 100 there is never any static.

#include <TM1637Display.h>

const uint8_t POT = A0;
const uint8_t RED_LED = 2;
const uint8_t YELLOW_LED = 3;
const uint8_t GREEN_LED = 4;
const uint8_t PIEZO = 10;

const int BAND_LOW = 880;   // 88.0 MHz, in tenths of a MHz
const int BAND_HIGH = 1080; // 108.0 MHz
const int REACH = 15;       // the signal fades out 1.5 MHz either side
const int LOCK_AT = 85;     // percent

TM1637Display display(6, 7);

int target;             // the hidden station, in tenths of a MHz
float knob = 0;         // the smoothed reading
bool firstRead = true;
int shownFreq = -1;
int lastBucket = -1;
int lightColor = -1;
bool locked = false;
unsigned long lockedAt = 0;
bool messageSent = false;
unsigned long lastTick = 0;
unsigned long lastBeep = 0;

int signalFor(int freq) {
  int away = abs(freq - target);
  if (away >= REACH) return 0;
  return 100 - away * 100 / REACH;
}

// Written only when the colour changes, so the lamps are not rewritten 25
// times a second for nothing.
void setLight(int percent) {
  int color = percent < 30 ? 0 : (percent < LOCK_AT ? 1 : 2);
  if (color == lightColor) return;
  lightColor = color;
  digitalWrite(RED_LED, color == 0);
  digitalWrite(YELLOW_LED, color == 1);
  digitalWrite(GREEN_LED, color == 2);
}

void printTuned(int freq) {
  Serial.print(freq / 10);
  Serial.print('.');
  Serial.print(freq % 10);
}

void setup() {
  Serial.begin(115200);
  pinMode(RED_LED, OUTPUT);
  pinMode(YELLOW_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(PIEZO, OUTPUT);
  display.setBrightness(0x0f);
  // Nothing is wired to A1, so it reads noise: a different station each Run.
  randomSeed(analogRead(A1));
  target = random(BAND_LOW + 20, BAND_HIGH - 20);
  Serial.println("radio on: find the emergency broadcast");
}

void loop() {
  unsigned long now = millis();
  if (now - lastTick < 40) return;
  lastTick = now;

  int raw = analogRead(POT);
  if (firstRead) {
    knob = raw;
    firstRead = false;
  } else {
    knob += (raw - knob) / 4.0;
  }
  int freq = BAND_LOW + (int)(knob * (BAND_HIGH - BAND_LOW) / 1023.0 + 0.5);
  int percent = signalFor(freq);

  if (freq != shownFreq) {
    shownFreq = freq;
    display.showNumberDecEx(freq, 0x20, false);
  }
  setLight(percent);

  // report each time the signal moves into another tenth of the dial
  int bucket = percent / 10;
  if (bucket != lastBucket) {
    lastBucket = bucket;
    Serial.print("tuned to ");
    printTuned(freq);
    Serial.print(" MHz, signal ");
    Serial.print(percent);
    Serial.println("%");
  }

  bool nowLocked = percent >= LOCK_AT;
  if (nowLocked && !locked) {
    locked = true;
    lockedAt = now;
    messageSent = false;
    Serial.print("LOCKED on ");
    printTuned(freq);
    Serial.println(" MHz: emergency broadcast");
  } else if (!nowLocked) {
    locked = false;
  }

  if (locked) {
    // the broadcast: a two-note signal, no static
    if (now - lastBeep >= 400) {
      lastBeep = now;
      tone(PIEZO, ((now / 400) & 1) ? 1318 : 988, 160);
    }
    if (!messageSent && now - lockedAt >= 1500) {
      messageSent = true;
      Serial.println("message: SHELTER AT GRID 7, WATER AND MEDICINE, COME IN FROM THE EAST");
    }
  } else if ((int)random(100) < 100 - percent) {
    tone(PIEZO, random(200, 3000), 30);
  }
}