Grid sequencer on an Arduino Uno

// Grid sequencer: draw an eight-note melody on an 8x8 LED matrix.
//
// Wiring:
//   matrix    MAX7219: DIN -> pin 5, CLK -> pin 11, CS -> pin 10, VCC -> 5 V, GND
//   up, down  pins 2 and 3 to GND: raise or lower the selected step's note
//   next      pin 4 to GND: select the next step
//   rest      pin 12 to GND: turns the selected step into a rest and back
//   tempo     potentiometer wiper -> A0, ends to 5 V and GND
//   piezo     pin 9 -> piezo -> GND
//
// The matrix is a graph. Each of the eight columns is one step of the melody, and
// the row of the dot in that column is the pitch: low notes at the bottom, high
// ones at the top. The top row is a playhead: one dot that walks along as the
// steps play. The melody is stored in an array of eight numbers, one row number
// for each column (or REST).
//
// To edit, press up or down: the selected step's dot moves up or down and plays
// its note so you can hear it. The selected step blinks. Press next to move to the
// following step. The rest button turns the selected step into silence and back.
//
// The notes are the major pentatonic scale, C D E G A C D, which sounds good in
// any order: it has no notes that clash.
//
// Things to try. Make a rising run, then a falling one. Put rests in. Slow it down.

#include <LedControl.h>

const uint8_t UP_PIN = 2, DOWN_PIN = 3, NEXT_PIN = 4, REST_PIN = 12;
const uint8_t PIEZO_PIN = 9;
LedControl matrix(5, 11, 10, 1);  // DIN, CLK, CS, one module

const uint8_t STEPS = 8;
const uint8_t REST = 255;
const uint8_t TOP_NOTE = 6;  // rows 0 to 6 are notes, row 7 is the playhead
const uint16_t NOTE_HZ[7] = {262, 294, 330, 392, 440, 523, 587};
const char *const NOTE_NAME[7] = {"C4", "D4", "E4", "G4", "A4", "C5", "D5"};

// one row number per column: the melody
uint8_t melody[STEPS] = {0, 2, 4, 3, 5, 4, 2, 1};
uint8_t remembered[STEPS] = {0, 2, 4, 3, 5, 4, 2, 1};

uint8_t cursor = 0;
uint8_t step = 0;
uint32_t nextStep = 0;
uint32_t noteOffAt = 0;
bool sounding = false;
uint32_t previewUntil = 0;


bool upWas = false, downWas = false, nextWas = false, restWas = false;
uint32_t upAt = 0, downAt = 0, nextAt = 0, restAt = 0;

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;
}

// Send the picture one row at a time: eight transfers, not sixty-four, so
// drawing takes well under a millisecond and never makes a step late.
static void draw(bool blinkOn)
{
  for (uint8_t row = 0; row < 8; row++) {
    uint8_t bits = 0;
    for (uint8_t col = 0; col < STEPS; col++) {
      bool on = false;
      if (row == 7) {
        on = col == step;  // the playhead
      } else if (melody[col] == row) {
        on = col != cursor || blinkOn;
      }
      if (on) {
        bits |= 1 << (7 - col);  // column 0 is the left-hand end
      }
    }
    matrix.setRow(0, 7 - row, bits);  // music row 0 is the bottom of the picture
  }
}

static void preview(uint8_t note)
{
  if (note != REST) {
    tone(PIEZO_PIN, NOTE_HZ[note]);
    previewUntil = millis() + 140;
  }
}

void setup()
{
  Serial.begin(9600);
  pinMode(UP_PIN, INPUT_PULLUP);
  pinMode(DOWN_PIN, INPUT_PULLUP);
  pinMode(NEXT_PIN, INPUT_PULLUP);
  pinMode(REST_PIN, INPUT_PULLUP);
  pinMode(PIEZO_PIN, OUTPUT);
  matrix.shutdown(0, false);
  matrix.setIntensity(0, 6);
  matrix.clearDisplay(0);
  nextStep = millis() + 300;
  draw(true);
  Serial.println("Grid sequencer ready: 8 steps");
}

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

  // up and down change the pitch of the selected step
  int8_t dir = 0;
  if (pressed(UP_PIN, upWas, upAt)) {
    dir = 1;
  } else if (pressed(DOWN_PIN, downWas, downAt)) {
    dir = -1;
  }
  if (dir != 0) {
    int8_t note = melody[cursor] == REST ? 3 : melody[cursor] + dir;
    if (note < 0) {
      note = 0;
    }
    if (note > TOP_NOTE) {
      note = TOP_NOTE;
    }
    melody[cursor] = note;
    remembered[cursor] = note;
    Serial.print("Step ");
    Serial.print(cursor + 1);
    Serial.print(" set to ");
    Serial.println(NOTE_NAME[note]);
    preview(note);
  }
  if (pressed(NEXT_PIN, nextWas, nextAt)) {
    cursor = (cursor + 1) % STEPS;
    Serial.print("Selected step ");
    Serial.println(cursor + 1);
  }
  if (pressed(REST_PIN, restWas, restAt)) {
    melody[cursor] = melody[cursor] == REST ? remembered[cursor] : REST;
    Serial.print("Step ");
    Serial.print(cursor + 1);
    Serial.println(melody[cursor] == REST ? " is a rest" : " is a note again");
  }

  // the clock: eighth notes, 80 to 200 BPM from the knob
  if (now >= nextStep) {
    uint16_t bpm = 80 + (uint16_t)((analogRead(A0) * 120UL) / 1023);
    nextStep += 30000UL / bpm;
    if (nextStep < now) {
      nextStep = now + 30000UL / bpm;
    }
    step = (step + 1) % STEPS;
    uint8_t note = melody[step];
    if (note == REST) {
      Serial.print("Step ");
      Serial.print(step + 1);
      Serial.println(" rest");
    } else {
      if (previewUntil == 0 || now >= previewUntil) {
        tone(PIEZO_PIN, NOTE_HZ[note]);
        sounding = true;
        noteOffAt = now + 30000UL / bpm * 8 / 10;
      }
      Serial.print("Step ");
      Serial.print(step + 1);
      Serial.print(" ");
      Serial.print(NOTE_NAME[note]);
      Serial.print(" ");
      Serial.print(NOTE_HZ[note]);
      Serial.print(" Hz ");
      Serial.print(bpm);
      Serial.println(" BPM");
    }
  }
  if (sounding && now >= noteOffAt) {
    noTone(PIEZO_PIN);
    sounding = false;
  }
  if (previewUntil != 0 && now >= previewUntil) {
    previewUntil = 0;
    if (!sounding) {
      noTone(PIEZO_PIN);
    }
  }

  // the picture: the selected step blinks
  static uint32_t lastDraw = 0;
  static bool blink = true;
  if (now - lastDraw >= 120) {
    lastDraw = now;
    blink = !blink;
    draw(blink);
  }
}