4x4x4 LED cube on an Arduino Uno

// LED cube: a 4x4x4 cube of 64 LEDs, multiplexed one layer at a time.
//
//   pins 11, 13, 10   DS, SHCP and STCP of the first 74HC595 (columns 0-7)
//   pins 8, 12, 9     DS, SHCP and STCP of the second (columns 8-15)
//   A0-A3          the four layer transistors' bases, through 1 k each
//   pin 7          the button, other side to GND (internal pull-up)
//
// # Sixteen columns, four layers
//
// Every LED in a vertical column shares its anode, and every LED in a layer
// shares its cathode. Two 74HC595s, each on three pins of its own, drive
// the sixteen columns through 220 ohm each. Four NPN transistors switch the layers to ground.
// Light column 5 and switch on layer 2 and exactly one LED glows.
//
// # Multiplexing
//
// Only one layer is ever on. The sketch shows layer 0 for 2 ms, then layer
// 1, then 2, then 3, and starts again: 125 times a second, far faster than
// your eye can follow, so all four look lit at once. That is how 64 LEDs
// run from 20 pins.
//
// # The frame
//
// The picture is four 16-bit numbers, one per layer, bit n for column n.
// The animations only ever change those numbers; refresh() keeps showing
// whatever they hold. The button skips to the next animation, and they also
// change on their own every eight seconds.

// Data, shift clock and latch for each chip.
const int DATA[2] = {11, 8};
const int CLOCK[2] = {13, 12};
const int LATCH[2] = {10, 9};
const int LAYERS[4] = {A0, A1, A2, A3};
const int BUTTON = 7;

const char *const NAMES[] = {"rain", "plane sweep", "spiral", "random"};
const int ANIMATIONS = 4;

uint16_t frame[4];
int layer = 0;
int animation = 0;
int stepCount = 0;
unsigned long refreshAt = 0;
unsigned long stepAt = 0;
unsigned long changedAt = 0;
bool wasDown = false;
unsigned long pressedAt = 0;

// Column n is at x = n % 4, y = n / 4, as seen from above.
uint16_t cell(int x, int y) { return (uint16_t)1 << (y * 4 + x); }

// One byte into each chip, then both latches together, so the sixteen
// columns change at the same moment.
void shift16(uint16_t columns) {
  for (int chip = 0; chip < 2; chip++) {
    digitalWrite(LATCH[chip], LOW);
    shiftOut(DATA[chip], CLOCK[chip], MSBFIRST, chip == 0 ? columns & 0xFF : columns >> 8);
  }
  for (int chip = 0; chip < 2; chip++) digitalWrite(LATCH[chip], HIGH);
}

// Show the next layer: all layers off, new columns, then this layer on.
// Turning the old layer off first stops a faint ghost of its pattern
// appearing on the new one while the bits shift in.
void refresh() {
  digitalWrite(LAYERS[layer], LOW);
  layer = (layer + 1) % 4;
  shift16(frame[layer]);
  digitalWrite(LAYERS[layer], HIGH);
}

void clearFrame() {
  for (int z = 0; z < 4; z++) frame[z] = 0;
}

// Rain: drops start at the top layer and fall one layer a step.
void rain() {
  for (int z = 0; z < 3; z++) frame[z] = frame[z + 1];
  frame[3] = 0;
  for (int i = 0; i < 2; i++) frame[3] |= (uint16_t)1 << random(16);
}

// Plane sweep: a full wall of light moves through the cube, front to back,
// then a floor moves bottom to top.
void sweep() {
  clearFrame();
  int pos = stepCount % 8;
  if (pos < 4) {
    uint16_t row = 0;
    for (int x = 0; x < 4; x++) row |= cell(x, pos);
    for (int z = 0; z < 4; z++) frame[z] = row;
  } else {
    frame[pos - 4] = 0xFFFF;
  }
}

// Spiral: one column walks the outer ring of twelve, a layer higher each
// lap, with a tail of three behind it.
const uint8_t RING[12] = {0, 1, 2, 3, 7, 11, 15, 14, 13, 12, 8, 4};
void spiral() {
  clearFrame();
  for (int t = 0; t < 4; t++) {
    int s = stepCount - t;
    if (s < 0) continue;
    int z = (s / 12) % 4;
    frame[z] |= (uint16_t)1 << RING[s % 12];
  }
}

// Random: every LED has a one in four chance of being lit, new each step.
void sparkle() {
  for (int z = 0; z < 4; z++) {
    frame[z] = (uint16_t)(random(65536) & random(65536));
  }
}

void next() {
  animation = (animation + 1) % ANIMATIONS;
  stepCount = 0;
  changedAt = millis();
  clearFrame();
  Serial.print("animation: ");
  Serial.println(NAMES[animation]);
}

void setup() {
  for (int chip = 0; chip < 2; chip++) {
    pinMode(DATA[chip], OUTPUT);
    pinMode(CLOCK[chip], OUTPUT);
    pinMode(LATCH[chip], OUTPUT);
  }
  pinMode(BUTTON, INPUT_PULLUP);
  for (int z = 0; z < 4; z++) {
    pinMode(LAYERS[z], OUTPUT);
    digitalWrite(LAYERS[z], LOW);
  }
  Serial.begin(115200);
  randomSeed(analogRead(A5));
  Serial.println("LED cube ready");
  Serial.print("animation: ");
  Serial.println(NAMES[animation]);
}

void loop() {
  unsigned long now = millis();

  if (now - refreshAt >= 2) {
    refreshAt = now;
    refresh();
  }

  // A press counts once: contacts bounce, so ignore another for 250 ms.
  bool down = digitalRead(BUTTON) == LOW;
  if (down && !wasDown && now - pressedAt > 250) {
    pressedAt = now;
    next();
  }
  wasDown = down;
  if (now - changedAt > 8000) next();

  if (now - stepAt >= 120) {
    stepAt = now;
    stepCount++;
    if (animation == 0) rain();
    if (animation == 1) sweep();
    if (animation == 2) spiral();
    if (animation == 3) sparkle();
  }
}