ADSR synth on an Arduino Uno

// ADSR synth: eight keys, four knobs, a piezo and an LED that draws the envelope.
//
// Wiring:
//   keys      pins 2, 3, 4, 5, 7, 8, 9, 12, each to GND (C D E F G A B C)
//   piezo     pin 10 -> piezo -> GND
//   envelope  pin 6 -> 220 ohms -> LED -> GND
//   knobs     four potentiometers, wipers to A0 A1 A2 A3, ends to 5 V and GND:
//             attack, decay, sustain, release
//
// When a key goes down, the sound does not jump to full volume and stop dead
// when you let go. It follows an envelope with four parts:
//
//   attack   how long it takes to rise from silence to the peak
//   decay    how long it takes to fall from the peak to the sustain level
//   sustain  the level it holds while the key stays down
//   release  how long it takes to fade out after the key comes up
//
// A piezo can only play at one volume, so the LED shows the envelope as
// brightness (PWM on pin 6) and the piezo plays the note while the envelope is
// above a small threshold. Turn sustain all the way down and every note dies
// away by itself, like a plucked string. Turn it up and the note holds, like an
// organ. Turn release up and the note rings on after you let go.
//
// The envelope is a little state machine. Every pass through loop() adds or
// subtracts a small step from the level, scaled by how many milliseconds have
// passed since the last pass, so the times stay right however fast loop() runs.
//
// Things to try. Attack at the minimum and sustain at zero: a pluck. Attack at
// the maximum: a pad that swells in. Press a second key while the first is still
// held and watch the envelope restart.

const uint8_t KEYS = 8;
const uint8_t KEY_PIN[KEYS] = {2, 3, 4, 5, 7, 8, 9, 12};
const uint16_t NOTE_HZ[KEYS] = {262, 294, 330, 349, 392, 440, 494, 523};
const char *const NOTE_NAME[KEYS] = {"C4", "D4", "E4", "F4", "G4", "A4", "B4", "C5"};
const uint8_t PIEZO_PIN = 10;
const uint8_t LED_PIN = 6;

// the note stops sounding once the envelope falls below this (of 1000)
const float AUDIBLE = 40;

enum Stage : uint8_t { IDLE, ATTACK, DECAY, SUSTAIN, RELEASE };
const char *const STAGE_NAME[] = {"idle", "attack", "decay", "sustain", "release"};

Stage stage = IDLE;
float level = 0;  // 0 to 1000
int8_t held = -1;
uint32_t lastMs = 0;
bool sounding = false;

// the four settings, read from the knobs
float attackMs, decayMs, sustainLevel, releaseMs;

static void readKnobs()
{
  attackMs = 5 + analogRead(A0) * (595.0f / 1023);        // 5 to 600 ms
  decayMs = 20 + analogRead(A1) * (580.0f / 1023);        // 20 to 600 ms
  sustainLevel = analogRead(A2) * (1000.0f / 1023);       // 0 to 1000
  releaseMs = 20 + analogRead(A3) * (1480.0f / 1023);     // 20 to 1500 ms
}

static void enter(Stage next)
{
  stage = next;
  Serial.print(STAGE_NAME[next]);
  Serial.print(" ");
  Serial.println((int)level);
}

// The key that is down, or -1. The highest key wins.
static int8_t keyRaw()
{
  for (int8_t k = KEYS - 1; k >= 0; k--) {
    if (digitalRead(KEY_PIN[k]) == LOW) {
      return k;
    }
  }
  return -1;
}

// A switch bounces: for a few milliseconds after a press it flickers open and
// shut. A reading only counts once it has held still for DEBOUNCE_MS, or one
// press would restart the envelope several times.
const uint8_t DEBOUNCE_MS = 15;
int8_t candidate = -1;
uint32_t candidateSince = 0;
int8_t stableKey = -1;

static int8_t keyDown()
{
  int8_t raw = keyRaw();
  uint32_t now = millis();
  if (raw != candidate) {
    candidate = raw;
    candidateSince = now;
  } else if (now - candidateSince >= DEBOUNCE_MS) {
    stableKey = raw;
  }
  return stableKey;
}

static void stepEnvelope(float dt)
{
  switch (stage) {
    case ATTACK:
      level += 1000.0f * dt / attackMs;
      if (level >= 1000) {
        level = 1000;
        enter(DECAY);
      }
      break;
    case DECAY:
      level -= (1000.0f - sustainLevel) * dt / decayMs;
      if (level <= sustainLevel) {
        level = sustainLevel;
        enter(SUSTAIN);
      }
      break;
    case SUSTAIN:
      level = sustainLevel;
      break;
    case RELEASE:
      level -= 1000.0f * dt / releaseMs;
      if (level <= 0) {
        level = 0;
        enter(IDLE);
      }
      break;
    default:
      break;
  }
}

void setup()
{
  Serial.begin(9600);
  for (uint8_t k = 0; k < KEYS; k++) {
    pinMode(KEY_PIN[k], INPUT_PULLUP);
  }
  pinMode(PIEZO_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  readKnobs();
  lastMs = millis();
  Serial.println("ADSR synth ready");
}

void loop()
{
  uint32_t now = millis();
  float dt = (float)(now - lastMs);
  lastMs = now;

  readKnobs();

  int8_t key = keyDown();
  if (key != held) {
    if (key >= 0) {
      // a new key: the envelope starts again from where it is
      Serial.print("Note ");
      Serial.print(NOTE_NAME[key]);
      Serial.print(" ");
      Serial.print(NOTE_HZ[key]);
      Serial.println(" Hz");
      held = key;
      enter(ATTACK);
      tone(PIEZO_PIN, NOTE_HZ[key]);
      sounding = true;
    } else {
      held = -1;
      enter(RELEASE);
    }
  }

  stepEnvelope(dt);

  // the LED draws the envelope; the piezo plays while it is high enough to hear
  analogWrite(LED_PIN, (int)(level * 255.0f / 1000.0f));
  if (sounding && level < AUDIBLE && held < 0) {
    noTone(PIEZO_PIN);
    sounding = false;
  } else if (sounding && level < AUDIBLE && stage == DECAY) {
    // decayed away to nothing while the key is still down: a pluck
    noTone(PIEZO_PIN);
    sounding = false;
  } else if (!sounding && held >= 0 && level >= AUDIBLE) {
    tone(PIEZO_PIN, NOTE_HZ[held]);
    sounding = true;
  }
}