Drum machine on an Arduino Uno

// Drum machine: eight steps, three drums, one piezo.
//
// Wiring:
//   step buttons  pins 2 to 9, each to GND (steps 1 to 8)
//   drum button   pin 12 to GND: picks which drum the step buttons edit
//   tempo knob    potentiometer wiper -> A0, ends to 5 V and GND
//   piezo         pin 10 -> piezo -> GND
//   pixels        8 WS2812Bs, DIN <- 330 ohms <- pin 11
//
// A drum machine is a loop of steps. Each step is one eighth note: if its
// button is on for a drum, that drum plays when the beat gets there. The
// pixels show the drum you are editing, and a white dot runs along them with
// the beat.
//
// Steady tempo. The sketch never waits with delay(). It keeps the time the next
// step is due and adds one step length to it each time, so a step that runs a
// little late does not push the rest of the song late with it. The knob
// changes the step length, and the new tempo starts on the very next step.
//
// One piezo can only make one pitch at a time, so each drum is a pitch that
// moves while it sounds, the way the real ones do:
//   kick   a low note that falls in steps (210 Hz down to 58 Hz)
//   snare  a burst of random pitches, which is what noise is
//   hat    a very short burst of random high pitches
// If two drums land on one step, the kick wins, then the snare.
//
// Things to try. Turn the knob. Press the drum button, then add steps. Change
// the starting pattern in KICK, SNARE and HAT: each bit is one step.

#include <Adafruit_NeoPixel.h>

const uint8_t STEPS = 8;
const uint8_t STEP_PIN[STEPS] = {2, 3, 4, 5, 6, 7, 8, 9};
const uint8_t PIEZO_PIN = 10;
const uint8_t PIXEL_PIN = 11;
const uint8_t DRUM_PIN = 12;

enum Drum : uint8_t { KICK, SNARE, HAT, DRUMS };
const char *const DRUM_NAME[DRUMS] = {"kick", "snare", "hat"};

// bit 0 is step 1. Kick on 1 and 5, snare on 3 and 7, hat on the offbeats.
uint8_t pattern[DRUMS] = {0b00010001, 0b01000100, 0b10101010};

Adafruit_NeoPixel pixels(STEPS, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

uint8_t editing = KICK;
uint8_t step = 0;      // the step to play next
uint8_t playhead = 0;  // the step that played last
uint32_t nextStep = 0;
uint16_t bpm = 120;

// the drum that is sounding now, when it started, and the noise slot it is in
int8_t voice = -1;
uint32_t voiceStart = 0;
uint8_t slot = 255;
uint16_t lastHz = 0;
uint16_t noiseHz = 0;

// button edges: the last reading of each button and when it last changed
bool wasDown[STEPS + 1];
uint32_t changedAt[STEPS + 1];

static void startVoice(int8_t drum)
{
  voice = drum;
  voiceStart = millis();
  slot = 255;
}

static void stopVoice()
{
  voice = -1;
  lastHz = 0;
  noTone(PIEZO_PIN);
}

// A new random pitch every `slotMs`: that is what makes it sound like noise.
static uint16_t noise(uint32_t age, uint8_t slotMs, uint16_t low, uint16_t spread)
{
  uint8_t now = age / slotMs;
  if (now != slot) {
    slot = now;
    noiseHz = low + random(0, spread);
  }
  return noiseHz;
}

// The kick is a few notes in a row, each lower than the last. Each one has to
// last longer than half a wave of its own pitch, or the pin never gets to
// swing: tone() starts the timer over every time it is called.
const uint16_t KICK_HZ[] = {210, 150, 110, 80, 58};
const uint8_t KICK_MS[] = {14, 18, 24, 30, 40};
const uint8_t KICK_STAGES = sizeof(KICK_HZ) / sizeof(KICK_HZ[0]);

static void sing(uint16_t hz)
{
  // only on a change: calling tone() every pass would restart the wave
  if (hz != lastHz) {
    lastHz = hz;
    tone(PIEZO_PIN, hz);
  }
}

// Called every pass through loop(): moves the pitch of the drum that is
// sounding, and switches it off when its time is up.
static void updateVoice()
{
  if (voice < 0) {
    return;
  }
  uint32_t age = millis() - voiceStart;
  if (voice == KICK) {
    uint32_t until = 0;
    for (uint8_t s = 0; s < KICK_STAGES; s++) {
      until += KICK_MS[s];
      if (age < until) {
        sing(KICK_HZ[s]);
        return;
      }
    }
    stopVoice();
  } else if (voice == SNARE) {
    if (age >= 90) {
      stopVoice();
      return;
    }
    sing(noise(age, 6, 180, 1400));
  } else {
    if (age >= 30) {
      stopVoice();
      return;
    }
    sing(noise(age, 3, 3000, 2000));
  }
}

static void drawPixels()
{
  static const uint8_t COLOR[DRUMS][3] = {{200, 20, 20}, {220, 140, 0}, {0, 150, 190}};
  for (uint8_t i = 0; i < STEPS; i++) {
    if (i == playhead) {
      pixels.setPixelColor(i, 255, 255, 255);
    } else if (pattern[editing] & (1 << i)) {
      pixels.setPixelColor(i, COLOR[editing][0] / 3, COLOR[editing][1] / 3, COLOR[editing][2] / 3);
    } else {
      pixels.setPixelColor(i, 0, 0, 0);
    }
  }
  pixels.show();
}

static void playStep()
{
  playhead = step;
  int8_t hit = -1;
  for (uint8_t d = 0; d < DRUMS; d++) {
    if (pattern[d] & (1 << step)) {
      hit = d;
      break;
    }
  }
  Serial.print("Step ");
  Serial.print(step + 1);
  Serial.print(" ");
  Serial.print(hit < 0 ? "-" : DRUM_NAME[hit]);
  Serial.print("  ");
  Serial.print(bpm);
  Serial.println(" BPM");
  if (hit >= 0) {
    startVoice(hit);
  }
  drawPixels();
}

// True once for each press of button `index` (0 to 7 are the steps, 8 is the
// drum button), with 20 ms of debounce.
static bool pressed(uint8_t index, uint8_t pin)
{
  bool down = digitalRead(pin) == LOW;
  uint32_t now = millis();
  if (down != wasDown[index] && now - changedAt[index] > 20) {
    wasDown[index] = down;
    changedAt[index] = now;
    return down;
  }
  return false;
}

void setup()
{
  Serial.begin(9600);
  for (uint8_t i = 0; i < STEPS; i++) {
    pinMode(STEP_PIN[i], INPUT_PULLUP);
  }
  pinMode(DRUM_PIN, INPUT_PULLUP);
  pinMode(PIEZO_PIN, OUTPUT);
  pixels.begin();
  pixels.setBrightness(120);
  randomSeed(analogRead(A1));
  Serial.println("Drum machine ready: 8 steps, kick snare hat");
  nextStep = millis() + 250;
}

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

  // the knob: 60 to 180 beats per minute
  bpm = 60 + (uint16_t)((analogRead(A0) * 120UL) / 1023);

  if (now >= nextStep) {
    // One step is an eighth note: half a beat.
    nextStep += 30000UL / bpm;
    playStep();
    step = (step + 1) % STEPS;
  }

  updateVoice();

  for (uint8_t i = 0; i < STEPS; i++) {
    if (pressed(i, STEP_PIN[i])) {
      pattern[editing] ^= (1 << i);
      Serial.print(DRUM_NAME[editing]);
      Serial.print(" step ");
      Serial.print(i + 1);
      Serial.println((pattern[editing] & (1 << i)) ? " on" : " off");
      drawPixels();
    }
  }
  if (pressed(STEPS, DRUM_PIN)) {
    editing = (editing + 1) % DRUMS;
    Serial.print("Editing ");
    Serial.println(DRUM_NAME[editing]);
    drawPixels();
  }
}