Waveform lab on an Arduino Uno

// Waveform lab: PWM audio. See what a pitch looks like, and hear it.
//
// Wiring:
//   pin 9      -> 1 k ohm -> the scope's channel 1 -> 100 nF to GND   (the filter)
//   wave       pin 2 to GND: picks sine, triangle, sawtooth or square
//   pitch      potentiometer wiper -> A1, ends to 5 V and GND (55 to 400 Hz)
//   piezo      pin 10 -> piezo -> GND: plays the same pitch
//
// A pin is either high or low, so how does a board make a smooth wave? With PWM,
// pulse width modulation: the pin switches on and off very fast, and the fraction
// of the time it spends on (the duty) is the level you want. 25% on averages to
// 1.25 V, 50% on to 2.5 V, 75% on to 3.75 V. A filter does the averaging: the 1 k
// resistor and 100 nF capacitor pass slow changes (the wave, a few hundred times
// a second) and smooth away fast ones (the 62,500 times a second the pin
// switches). That is how a little board plays real sound, without a DAC chip.
//
// Timer 1 makes the fast switching by itself (fast PWM, 8 bit, no prescaler: the
// 16 MHz clock counts 0 to 255 over and over, 62,500 times a second). The sketch
// only sets the duty, OCR1A, once per point of the wave.
//
// The sketch keeps a table of 32 duties for one cycle of each shape:
//
//   sine      the purest tone, one smooth curve
//   triangle  a soft tone, like a flute
//   sawtooth  a bright, buzzy tone, like a bowed string
//   square    a hollow tone, like a clarinet
//
// To play a note it steps through the table at a steady rate of frequency * 32
// points a second, so the whole table goes round `frequency` times a second. The
// piezo plays the same pitch with tone(), which is always a square wave.
//
// Things to try. Watch the scope as you press the wave button. Turn the knob up
// and squeeze more cycles into the scope's window. Change the 100 nF capacitor to
// 1 uF and watch the square wave's corners round off: the filter is slowing the
// wave down too.

const uint8_t WAVE_PIN = 2;
const uint8_t PWM_PIN = 9;     // OC1A: Timer 1's output A
const uint8_t PIEZO_PIN = 10;
const uint8_t POINTS = 32;

enum Wave : uint8_t { SINE, TRIANGLE, SAW, SQUARE, WAVES };
const char *const WAVE_NAME[WAVES] = {"sine", "triangle", "sawtooth", "square"};

// One cycle of a sine, 32 points from 0 to 255.
const uint8_t SINE_TABLE[POINTS] = {
  128, 153, 177, 199, 218, 234, 246, 253,
  255, 253, 246, 234, 218, 199, 177, 153,
  128, 103, 79, 57, 38, 22, 10, 3,
  0, 3, 10, 22, 38, 57, 79, 103,
};

static uint8_t point(uint8_t wave, uint8_t i)
{
  switch (wave) {
    case SINE:
      return SINE_TABLE[i];
    case TRIANGLE:
      // up for 16 points, down for 16
      return i < 16 ? i * 255 / 16 : (32 - i) * 255 / 16;
    case SAW:
      return i * 255 / (POINTS - 1);
    default:
      return i < 16 ? 255 : 0;
  }
}

uint8_t wave = SINE;
uint8_t index = 0;
uint16_t hz = 110;
uint16_t toneHz = 0;
uint32_t nextPoint = 0;
uint32_t lastReport = 0;
uint32_t lastKnob = 0;
bool wasDown = false;
uint32_t changedAt = 0;

void setup()
{
  Serial.begin(9600);
  pinMode(WAVE_PIN, INPUT_PULLUP);
  pinMode(PWM_PIN, OUTPUT);
  pinMode(PIEZO_PIN, OUTPUT);
  // Timer 1: fast PWM, 8 bit (WGM 5), output A cleared on the match, no prescaler
  TCCR1A = (1 << COM1A1) | (1 << WGM10);
  TCCR1B = (1 << WGM12) | (1 << CS10);
  OCR1A = 128;
  Serial.println("Waveform lab ready: sine");
  nextPoint = micros();
}

void loop()
{
  uint32_t ms = millis();

  // the wave button
  bool down = digitalRead(WAVE_PIN) == LOW;
  if (down != wasDown && ms - changedAt > 20) {
    wasDown = down;
    changedAt = ms;
    if (down) {
      wave = (wave + 1) % WAVES;
      Serial.print("Wave ");
      Serial.println(WAVE_NAME[wave]);
    }
  }

  // the pitch knob, 55 to 400 Hz, looked at every 25 ms: an analog reading takes
  // about 0.1 ms and the wave should not wait for it. The piezo is only retuned
  // when the pitch has moved a little, because tone() starts the timer over.
  if (ms - lastKnob >= 25) {
    lastKnob = ms;
    hz = 55 + (uint16_t)((analogRead(A1) * 345UL) / 1023);
    if (hz > toneHz + 3 || hz + 3 < toneHz) {
      toneHz = hz;
      tone(PIEZO_PIN, hz);
    }
  }

  // the next point of the cycle, on time
  uint32_t now = micros();
  if ((int32_t)(now - nextPoint) >= 0) {
    nextPoint += 1000000UL / ((uint32_t)hz * POINTS);
    OCR1A = point(wave, index);
    index = (index + 1) % POINTS;
  }

  if (ms - lastReport >= 1000) {
    lastReport = ms;
    Serial.print(WAVE_NAME[wave]);
    Serial.print(" ");
    Serial.print(hz);
    Serial.println(" Hz");
  }
}