Arpeggiator on an Arduino Uno

// Arpeggiator: hold a chord and hear it played one note at a time.
//
// Wiring:
//   keys    pins 2 to 9, each to GND (C D E F G A B C)
//   mode    pin 11 to GND: up, down, up and down, random
//   latch   pin 12 to GND: keep playing after you let go of the keys
//   tempo   potentiometer wiper -> A0, ends to 5 V and GND
//   piezo   pin 10 -> piezo -> GND
//
// An arpeggio is a chord played as a run of notes instead of all at once. The
// keys you hold are the chord; each step of the clock plays the next note of it.
// Hold C, E and G and "up" plays C E G C E G, "down" plays G E C, "up and down"
// plays C E G E C E G..., and "random" picks any held note each step.
//
// The clock is a pair of times, the next step and the end of the note, so the
// keys are read all the time and the tempo can change in the middle of a
// phrase. Each step is a sixteenth note and the note sounds for 70% of it,
// which leaves a tiny gap so repeated notes are heard as separate notes.
//
// The latch button turns the held keys into a toggle: while latch is on, the
// chord stays when you let go, and the next key you press starts a new chord.
//
// Things to try. Hold three keys and change the mode. Turn the knob while it
// plays. Latch a chord and keep your hands free.

const uint8_t KEYS = 8;
const uint8_t KEY_PIN[KEYS] = {2, 3, 4, 5, 6, 7, 8, 9};
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 MODE_PIN = 11;
const uint8_t LATCH_PIN = 12;

enum Mode : uint8_t { UP, DOWN, UPDOWN, RANDOM, MODES };
const char *const MODE_NAME[MODES] = {"up", "down", "up and down", "random"};

uint8_t mode = UP;
bool latched = false;
uint8_t chord = 0;       // bit k is key k
uint8_t lastKeys = 0;    // the keys down on the last pass, for new-chord detection
int8_t current = -1;     // the key played last
int8_t direction = 1;    // for up and down
uint32_t nextStep = 0;
uint32_t noteOff = 0;
bool sounding = false;

// button edges
bool modeWas = false, latchWas = false;
uint32_t modeAt = 0, latchAt = 0;

static uint8_t keysDown()
{
  uint8_t down = 0;
  for (uint8_t k = 0; k < KEYS; k++) {
    if (digitalRead(KEY_PIN[k]) == LOW) {
      down |= 1 << k;
    }
  }
  return down;
}

static bool pressed(uint8_t pin, bool &was, uint32_t &at)
{
  bool down = digitalRead(pin) == LOW;
  uint32_t now = millis();
  if (down != was && now - at > 20) {
    was = down;
    at = now;
    return down;
  }
  return false;
}

// The next held key above (dir = 1) or below (dir = -1) `from`, or -1.
static int8_t neighbor(int8_t from, int8_t dir)
{
  for (int8_t k = from + dir; k >= 0 && k < KEYS; k += dir) {
    if (chord & (1 << k)) {
      return k;
    }
  }
  return -1;
}

static int8_t lowest()
{
  for (int8_t k = 0; k < KEYS; k++) {
    if (chord & (1 << k)) {
      return k;
    }
  }
  return -1;
}

static int8_t highest()
{
  for (int8_t k = KEYS - 1; k >= 0; k--) {
    if (chord & (1 << k)) {
      return k;
    }
  }
  return -1;
}

// Which key to play next, given the mode and the key played last.
static int8_t pick()
{
  if (chord == 0) {
    return -1;
  }
  int8_t next;
  switch (mode) {
    case UP:
      next = current < 0 ? lowest() : neighbor(current, 1);
      return next < 0 ? lowest() : next;
    case DOWN:
      next = current < 0 ? highest() : neighbor(current, -1);
      return next < 0 ? highest() : next;
    case UPDOWN:
      if (current < 0) {
        direction = 1;
        return lowest();
      }
      next = neighbor(current, direction);
      if (next < 0) {
        // turn round at the end, without playing the end note twice
        direction = -direction;
        next = neighbor(current, direction);
        if (next < 0) {
          next = current;  // a chord of one note
        }
      }
      return next;
    default: {
      uint8_t count = 0;
      for (uint8_t k = 0; k < KEYS; k++) {
        count += (chord >> k) & 1;
      }
      uint8_t n = random(0, count);
      for (uint8_t k = 0; k < KEYS; k++) {
        if ((chord >> k) & 1) {
          if (n == 0) {
            return k;
          }
          n--;
        }
      }
      return lowest();
    }
  }
}

void setup()
{
  Serial.begin(9600);
  for (uint8_t k = 0; k < KEYS; k++) {
    pinMode(KEY_PIN[k], INPUT_PULLUP);
  }
  pinMode(MODE_PIN, INPUT_PULLUP);
  pinMode(LATCH_PIN, INPUT_PULLUP);
  pinMode(PIEZO_PIN, OUTPUT);
  randomSeed(analogRead(A1));
  Serial.println("Arpeggiator ready: mode up");
}

void loop()
{
  uint32_t now = millis();
  uint8_t down = keysDown();

  if (pressed(MODE_PIN, modeWas, modeAt)) {
    mode = (mode + 1) % MODES;
    direction = 1;
    current = -1;  // each mode starts from its own end of the chord
    Serial.print("Mode ");
    Serial.println(MODE_NAME[mode]);
  }
  if (pressed(LATCH_PIN, latchWas, latchAt)) {
    latched = !latched;
    Serial.println(latched ? "Latch on" : "Latch off");
    if (!latched) {
      chord = down;
    }
  }

  if (latched) {
    // a key pressed after everything was let go starts a new chord
    if (down != 0 && lastKeys == 0) {
      chord = 0;
    }
    chord |= down;
  } else {
    chord = down;
  }
  lastKeys = down;

  // sixteenth notes: a quarter of a beat, 100 to 300 BPM
  uint16_t bpm = 100 + (uint16_t)((analogRead(A0) * 200UL) / 1023);
  uint32_t stepMs = 15000UL / bpm;

  if (sounding && now >= noteOff) {
    noTone(PIEZO_PIN);
    sounding = false;
  }
  if (now >= nextStep) {
    nextStep += stepMs;
    if (nextStep < now) {
      nextStep = now + stepMs;  // we fell behind (nothing was held): start fresh
    }
    int8_t key = pick();
    if (key >= 0) {
      current = key;
      tone(PIEZO_PIN, NOTE_HZ[key]);
      sounding = true;
      noteOff = now + stepMs * 7 / 10;
      Serial.print("Arp ");
      Serial.print(NOTE_NAME[key]);
      Serial.print(" ");
      Serial.print(bpm);
      Serial.println(" BPM");
    } else {
      current = -1;
      direction = 1;
    }
  }
}