Tuner on an Arduino Uno

// Tuner: measure a pitch, name the note, say flat or sharp.
//
// Wiring:
//   signal       the instrument's output (here a signal generator) -> pin 2, ground to GND
//   flat LED     pin 5 -> 220 ohms -> blue LED -> GND
//   in tune LED  pin 6 -> 220 ohms -> green LED -> GND
//   sharp LED    pin 7 -> 220 ohms -> red LED -> GND
//   reference    pin 3 to GND: plays the note it is tuning to
//   piezo        pin 10 -> piezo -> GND
//
// Pitch is how many times a second the sound repeats. A tuner counts that. Pin 2
// can raise an interrupt on every rising edge of the signal, and the interrupt
// routine writes down the time of the first edge and of the latest one, and how
// many there have been. Every quarter of a second the sketch turns those into a
// frequency:
//
//   frequency = (edges - 1) / (time of last edge - time of first edge)
//
// Dividing by the time between the first and last edge, not by the length of the
// window, is what makes it accurate: the error is one clock tick of 4
// microseconds in a quarter of a second.
//
// Then the note. Notes are spaced by ratios, not by steps: each semitone is the
// 12th root of 2 higher than the one below it, and A4 is 440 Hz. So
//
//   semitones from A4 = 12 * log2(frequency / 440)
//
// (A small chip does not want a floating-point logarithm, so the sketch finds the
// nearest note by comparing against a table of fourteen frequencies instead.)
//
// The nearest whole number of semitones is the note, and what is left over,
// times 100, is how many cents out you are (a cent is a hundredth of a semitone,
// and under about 5 cents most ears cannot tell). The sharp and flat lights
// come on past 10 cents.
//
// Things to try. Change the generator's frequency to 440, 330 and 82.4 (the low
// string of a guitar). Try 450 and 430. Press the reference button while a note
// is on to hear the pitch you are aiming for.

const uint8_t SIGNAL_PIN = 2;
const uint8_t REF_PIN = 3;
const uint8_t FLAT_LED = 5;
const uint8_t TUNE_LED = 6;
const uint8_t SHARP_LED = 7;
const uint8_t PIEZO_PIN = 10;

const char *const NAMES[12] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};

volatile uint32_t firstEdge = 0;
volatile uint32_t lastEdge = 0;
volatile uint16_t edges = 0;

void onEdge()
{
  uint32_t now = micros();
  if (edges == 0) {
    firstEdge = now;
  }
  lastEdge = now;
  edges++;
}

uint32_t windowStart = 0;
bool refWas = false;
int refMidi = -1;

static void lights(bool flat, bool tune, bool sharp)
{
  digitalWrite(FLAT_LED, flat);
  digitalWrite(TUNE_LED, tune);
  digitalWrite(SHARP_LED, sharp);
}

// The notes from B3 to C5, in hundredths of a hertz. Every octave up doubles
// the frequency and every octave down halves it, so these fourteen numbers are
// all the table there is. Index 1 is C4 (MIDI note 60).
const uint32_t NOTE_HUNDREDTHS[14] = {24694, 26163, 27718, 29366, 31113, 32963, 34923,
                                      36999, 39200, 41530, 44000, 46616, 49388, 52325};

// Frequency of a MIDI note number in whole hertz: 69 is A4 = 440 Hz.
static uint16_t midiToHz(int midi)
{
  uint32_t hundredths = NOTE_HUNDREDTHS[1 + (midi - 60 + 120) % 12];
  int octaves = (midi - 60 + 120) / 12 - 10;  // whole octaves away from octave 4
  while (octaves > 0) {
    hundredths *= 2;
    octaves--;
  }
  while (octaves < 0) {
    hundredths /= 2;
    octaves++;
  }
  return (uint16_t)((hundredths + 50) / 100);
}

// How far `f` is from `target`, in cents. Cents are 1200 * log2(f / target); for
// frequencies this close together that is very nearly 3462 * (f - t) / (f + t),
// which needs no logarithm, only integer arithmetic.
static int32_t centsBetween(uint32_t f, uint32_t target)
{
  return (int32_t)3462 * ((int32_t)f - (int32_t)target) / (int32_t)(f + target);
}

void setup()
{
  Serial.begin(9600);
  pinMode(SIGNAL_PIN, INPUT);
  pinMode(REF_PIN, INPUT_PULLUP);
  pinMode(FLAT_LED, OUTPUT);
  pinMode(TUNE_LED, OUTPUT);
  pinMode(SHARP_LED, OUTPUT);
  pinMode(PIEZO_PIN, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(SIGNAL_PIN), onEdge, RISING);
  windowStart = millis();
  Serial.println("Tuner ready");
}

void loop()
{
  // the reference button plays the note being tuned to, while it is held
  bool refDown = digitalRead(REF_PIN) == LOW;
  if (refDown && !refWas && refMidi >= 0) {
    tone(PIEZO_PIN, midiToHz(refMidi));
  } else if (!refDown && refWas) {
    noTone(PIEZO_PIN);
  }
  refWas = refDown;

  if (millis() - windowStart < 250) {
    return;
  }
  windowStart += 250;

  noInterrupts();
  uint16_t n = edges;
  uint32_t first = firstEdge;
  uint32_t last = lastEdge;
  edges = 0;
  interrupts();

  if (n < 4 || last == first) {
    lights(false, false, false);
    if (refMidi != -1) {
      Serial.println("No signal");
    }
    refMidi = -1;
    return;
  }

  // frequency in hundredths of a hertz, in two steps so nothing overflows
  uint32_t dt = last - first;
  uint32_t scaled = (uint32_t)(n - 1) * 10000UL;
  uint32_t hundredths = (scaled / dt) * 10000UL + ((scaled % dt) * 10000UL) / dt;

  // fold the pitch into the octave the table covers, remembering how far we moved
  int octaves = 0;
  uint32_t g = hundredths;
  while (g > 52000) {
    g /= 2;
    octaves++;
  }
  while (g < 24000) {
    g *= 2;
    octaves--;
  }

  // the nearest of the fourteen notes
  uint8_t best = 0;
  int32_t bestCents = centsBetween(g, NOTE_HUNDREDTHS[0]);
  for (uint8_t i = 1; i < 14; i++) {
    int32_t c = centsBetween(g, NOTE_HUNDREDTHS[i]);
    if (abs(c) < abs(bestCents)) {
      best = i;
      bestCents = c;
    }
  }
  int midi = 59 + best + 12 * octaves;  // index 1 is C4, MIDI 60
  refMidi = midi;
  int cents = (int)bestCents;

  lights(cents < -10, cents >= -10 && cents <= 10, cents > 10);

  Serial.print(NAMES[midi % 12]);
  Serial.print(midi / 12 - 1);
  Serial.print(" ");
  Serial.print(hundredths / 100);
  Serial.print(".");
  Serial.print((hundredths % 100) / 10);
  Serial.print(" Hz  ");
  Serial.print(cents >= 0 ? "+" : "");
  Serial.print(cents);
  Serial.print(" cents  ");
  Serial.println(cents < -10 ? "flat" : (cents > 10 ? "sharp" : "in tune"));
}