Digital piano on an Arduino Uno

// Digital piano: eight keys and a piezo, one octave from middle C.
//
// Wiring:
//   keys     a pushbutton from each of pins 2 to 9 to GND (C D E F G A B C)
//   piezo    pin 10 -> piezo -> GND
//
// Every key is a switch to ground read with INPUT_PULLUP, so pressed is LOW
// and no resistors are needed. tone() plays a square wave from a timer, so
// the sketch keeps reading the keys while a note sounds.
//
// Hold a key and the note holds; press another and it takes over, the way a
// one-voice synth does. The serial monitor names each note.
//
// The piano remembers the last 32 notes you played. Press the lowest and the
// highest key together and it plays them back, with your own timing.

const uint8_t PIEZO_PIN = 10;
const uint8_t KEYS = 8;
const uint8_t KEY_PIN[KEYS] = {2, 3, 4, 5, 6, 7, 8, 9};
// C4 to C5, in hertz
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 MEMORY = 32;
uint8_t played[MEMORY];
uint16_t gapBefore[MEMORY];  // milliseconds since the note before, capped
uint16_t heldFor[MEMORY];
uint8_t count = 0;

int8_t sounding = -1;  // the key whose note is playing, or -1
uint32_t noteStart = 0;
uint32_t lastNoteEnd = 0;

static int8_t keyDown()
{
  // The highest key held wins, like a one-voice synth.
  for (int8_t k = KEYS - 1; k >= 0; k--) {
    if (digitalRead(KEY_PIN[k]) == LOW) {
      return k;
    }
  }
  return -1;
}

static void remember(int8_t key, uint32_t start, uint32_t end)
{
  if (count == MEMORY) {
    for (uint8_t i = 1; i < MEMORY; i++) {
      played[i - 1] = played[i];
      gapBefore[i - 1] = gapBefore[i];
      heldFor[i - 1] = heldFor[i];
    }
    count--;
  }
  uint32_t gap = count == 0 ? 0 : start - lastNoteEnd;
  played[count] = (uint8_t)key;
  gapBefore[count] = (uint16_t)(gap > 2000 ? 2000 : gap);
  heldFor[count] = (uint16_t)(end - start > 2000 ? 2000 : end - start);
  count++;
  lastNoteEnd = end;
}

static void playBack()
{
  noTone(PIEZO_PIN);
  Serial.print("Playing back ");
  Serial.print(count);
  Serial.println(" notes");
  // wait for both keys to come up first
  while (digitalRead(KEY_PIN[0]) == LOW || digitalRead(KEY_PIN[KEYS - 1]) == LOW) {
    delay(5);
  }
  delay(300);
  for (uint8_t i = 0; i < count; i++) {
    delay(gapBefore[i]);
    tone(PIEZO_PIN, NOTE_HZ[played[i]]);
    delay(heldFor[i]);
    noTone(PIEZO_PIN);
  }
  Serial.println("Done. Play something new.");
  count = 0;
  sounding = -1;
}

void setup()
{
  Serial.begin(9600);
  for (uint8_t k = 0; k < KEYS; k++) {
    pinMode(KEY_PIN[k], INPUT_PULLUP);
  }
  noTone(PIEZO_PIN);
  delay(20);
  Serial.println("Piano ready: eight keys, C4 to C5");
}

void loop()
{
  if (digitalRead(KEY_PIN[0]) == LOW && digitalRead(KEY_PIN[KEYS - 1]) == LOW) {
    if (sounding >= 0) {
      remember(sounding, noteStart, millis());
    }
    playBack();
    return;
  }

  int8_t key = keyDown();
  if (key != sounding) {
    uint32_t now = millis();
    if (sounding >= 0) {
      remember(sounding, noteStart, now);
    }
    if (key >= 0) {
      tone(PIEZO_PIN, NOTE_HZ[key]);
      Serial.println(NOTE_NAME[key]);
      noteStart = now;
    } else {
      noTone(PIEZO_PIN);
    }
    sounding = key;
  }
  delay(5);  // a key bounces for a few milliseconds; this rides it out
}