Looper on an Arduino Uno

// Looper: play four pads, record a rhythm, and hear it come round again.
//
// Wiring:
//   pads      pins 2 to 5, each to GND (C E G C)
//   record    pin 6 to GND: starts and stops recording
//   clear     pin 7 to GND: forgets the loop
//   quantize  pin 12 to GND: snaps recorded taps to the nearest eighth note
//   rec LED   pin 8 -> 220 ohms -> red LED -> GND
//   beat LED  pin 9 -> 220 ohms -> green LED -> GND (blinks on each quarter of the loop)
//   piezo     pin 10 -> piezo -> GND
//
// The loop is four seconds long and always going round, like a looper pedal. The
// green LED blinks four times each time round, so you have a beat to play along
// to. Press record, tap the pads in time, press record again to stop. The taps are
// stored and played back every time the loop comes round. Press record again to
// add more taps on top (overdub).
//
// What is stored is only a list: for each tap, which pad and how many
// milliseconds after the start of the loop it happened. Playing it back is
// watching the clock and starting a note when the time passes a tap's mark.
// Because the clock wraps back to zero at the end of the loop, the sketch checks
// both for a tap between the last time it looked and now, and for one that falls
// across the wrap.
//
// Quantizing rounds each tap to the nearest eighth of the loop (500 ms). It
// makes a loose rhythm tight, and a deliberately loose one too tight.
//
// One piezo makes one note at a time. If you play a pad while the loop is
// sounding a note, yours wins. That is the limit of a single voice.
//
// Things to try. Record a kick-like pattern on the low pad, then add a melody.
// Record with quantize off, then clear and record again with it on.

const uint8_t PADS = 4;
const uint8_t PAD_PIN[PADS] = {2, 3, 4, 5};
const uint16_t PAD_HZ[PADS] = {262, 330, 392, 523};
const uint8_t REC_PIN = 6;
const uint8_t CLEAR_PIN = 7;
const uint8_t QUANT_PIN = 12;
const uint8_t REC_LED = 8;
const uint8_t BEAT_LED = 9;
const uint8_t PIEZO_PIN = 10;

const uint16_t LOOP_MS = 4000;
const uint16_t GRID_MS = 500;   // an eighth of the loop
const uint16_t NOTE_MS = 160;   // how long a played-back tap sounds
const uint8_t MAX_TAPS = 32;

struct Tap {
  uint16_t at;  // milliseconds from the start of the loop
  uint8_t pad;
};
Tap taps[MAX_TAPS];
uint8_t count = 0;

uint32_t loopStart = 0;
uint16_t lastPos = 0;
bool recording = false;
bool quantize = false;

int8_t heldPad = -1;       // the pad being held now
uint32_t playUntil = 0;    // when the loop's own note ends
bool loopSounding = false;

// button edges
bool wasDown[PADS + 3];
uint32_t changedAt[PADS + 3];

static bool pressed(uint8_t slot, uint8_t pin, bool *released = nullptr)
{
  bool down = digitalRead(pin) == LOW;
  uint32_t now = millis();
  if (down != wasDown[slot] && now - changedAt[slot] > 20) {
    wasDown[slot] = down;
    changedAt[slot] = now;
    if (released) {
      *released = !down;
    }
    return down;
  }
  if (released) {
    *released = false;
  }
  return false;
}

static void record(uint8_t pad, uint16_t pos)
{
  if (quantize) {
    pos = ((pos + GRID_MS / 2) / GRID_MS * GRID_MS) % LOOP_MS;
  }
  if (count == MAX_TAPS) {
    Serial.println("Loop is full");
    return;
  }
  taps[count].at = pos;
  taps[count].pad = pad;
  count++;
  Serial.print("Rec pad ");
  Serial.print(pad + 1);
  Serial.print(" at ");
  Serial.print(pos);
  Serial.println(" ms");
}

void setup()
{
  Serial.begin(9600);
  for (uint8_t i = 0; i < PADS; i++) {
    pinMode(PAD_PIN[i], INPUT_PULLUP);
  }
  pinMode(REC_PIN, INPUT_PULLUP);
  pinMode(CLEAR_PIN, INPUT_PULLUP);
  pinMode(QUANT_PIN, INPUT_PULLUP);
  pinMode(REC_LED, OUTPUT);
  pinMode(BEAT_LED, OUTPUT);
  pinMode(PIEZO_PIN, OUTPUT);
  loopStart = millis();
  Serial.println("Looper ready: 4 pads, 4 second loop");
}

void loop()
{
  uint32_t now = millis();
  uint16_t pos = (now - loopStart) % LOOP_MS;

  // the beat light: on for the first 80 ms of each quarter of the loop
  digitalWrite(BEAT_LED, (pos % 1000) < 80);

  // the pads
  for (uint8_t i = 0; i < PADS; i++) {
    bool released;
    if (pressed(i, PAD_PIN[i], &released)) {
      heldPad = i;
      tone(PIEZO_PIN, PAD_HZ[i]);
      loopSounding = false;
      if (recording) {
        record(i, pos);
      }
    } else if (released && heldPad == i) {
      heldPad = -1;
      noTone(PIEZO_PIN);
    }
  }

  if (pressed(PADS, REC_PIN)) {
    recording = !recording;
    digitalWrite(REC_LED, recording);
    Serial.println(recording ? "Recording on" : "Recording off");
    if (!recording) {
      Serial.print("Loop has ");
      Serial.print(count);
      Serial.println(" taps");
    }
  }
  if (pressed(PADS + 1, CLEAR_PIN)) {
    count = 0;
    Serial.println("Loop cleared");
  }
  if (pressed(PADS + 2, QUANT_PIN)) {
    quantize = !quantize;
    Serial.println(quantize ? "Quantize on" : "Quantize off");
  }

  // playback: any tap whose mark was passed since the last look
  for (uint8_t i = 0; i < count; i++) {
    uint16_t at = taps[i].at;
    bool crossed = pos >= lastPos ? (at > lastPos && at <= pos) : (at > lastPos || at <= pos);
    if (crossed) {
      if (heldPad < 0) {
        tone(PIEZO_PIN, PAD_HZ[taps[i].pad]);
        loopSounding = true;
        playUntil = now + NOTE_MS;
      }
      Serial.print("Play pad ");
      Serial.print(taps[i].pad + 1);
      Serial.print(" at ");
      Serial.print(at);
      Serial.println(" ms");
    }
  }
  if (loopSounding && now >= playUntil) {
    noTone(PIEZO_PIN);
    loopSounding = false;
  }
  lastPos = pos;
}