Hatching chick on an Arduino Uno

// Hatching chick: an egg on an 8x8 LED matrix wobbles, cracks and hatches
// into a chick that blinks and peeps. Tap the button to help it along.
//
//   MAX7219   8x8 matrix module: DIN -> pin 11, CLK -> pin 13, CS -> pin 10,
//             VCC -> 5 V, GND -> GND
//   button    pin 2 -> button -> GND        (INPUT_PULLUP): a tap on the shell
//   piezo     pin 8 -> piezo -> GND
//
// A spring build for Easter, or for any classroom that has watched real eggs
// in an incubator. The story goes in stages: the egg rests, wobbles, shows one
// crack, then two, then three, and then the top of the shell opens and the
// chick looks out. Each stage waits a random few seconds, so it never plays
// out quite the same way twice, and a press of the button moves straight on
// to the next stage.
//
// The pictures are eight bytes each, one per row. A crack is drawn by
// clearing a few dots of the egg, and a wobble by shifting every row one
// place left or right, so the whole animation is three small tables.
//
// Things to try. Press the button to tap the shell. Draw a different hatchling
// in CHICK. Make the chick peep a tune.

#include <LedControl.h>

const int BUTTON_PIN = 2;
const int PIEZO_PIN = 8;

LedControl matrix(11, 13, 10, 1);   // DIN, CLK, CS, one module

const uint8_t EGG[8] = {0b00011000, 0b00111100, 0b01111110, 0b01111110,
                        0b01111110, 0b01111110, 0b00111100, 0b00000000};
// The dots each crack clears from the egg.
const uint8_t CRACKS[3][8] = {
  {0, 0, 0, 0b00010000, 0, 0, 0, 0},
  {0, 0, 0b00001000, 0b00010100, 0, 0, 0, 0},
  {0, 0, 0b00101000, 0b01010100, 0b00000010, 0, 0, 0},
};
const uint8_t CHICK[8] = {0b00011000, 0b00111100, 0b00101110, 0b00111100,
                          0b01011010, 0b01111110, 0b00111100, 0b00000000};

int stage = 0;          // 0 resting, 1 wobbling, 2 to 4 cracks, 5 hatched
unsigned long nextStage = 0;
int hatched = 0;

void draw(const uint8_t rows[8], int shift, int cracks) {
  for (int r = 0; r < 8; r++) {
    uint8_t row = rows[r];
    for (int c = 0; c < cracks; c++) row &= ~CRACKS[c][r];
    if (shift > 0) row >>= 1;
    if (shift < 0) row <<= 1;
    matrix.setRow(0, r, row);
  }
}

void peep() {
  for (int f = 2000; f < 3200; f += 200) {
    tone(PIEZO_PIN, f, 15);
    delay(15);
  }
}

void advance() {
  stage++;
  if (stage > 5) {
    stage = 0;
    Serial.println("A new egg");
  } else if (stage == 1) {
    Serial.println("The egg is wobbling");
  } else if (stage <= 4) {
    Serial.print("Crack ");
    Serial.println(stage - 1);
    tone(PIEZO_PIN, 300, 30);
  } else {
    hatched++;
    Serial.print("Peep! Chick ");
    Serial.print(hatched);
    Serial.println(" has hatched");
    peep();
  }
  nextStage = millis() + (stage == 5 ? 6000 : random(1500, 3500));
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  matrix.shutdown(0, false);
  matrix.setIntensity(0, 6);
  matrix.clearDisplay(0);
  randomSeed(analogRead(A0));
  nextStage = millis() + 2000;
  Serial.println("An egg, keeping warm");
}

void loop() {
  unsigned long now = millis();
  if (digitalRead(BUTTON_PIN) == LOW) {
    advance();
    while (digitalRead(BUTTON_PIN) == LOW) delay(10);
  } else if (now >= nextStage) {
    advance();
  }

  if (stage == 5) {
    // The chick blinks every so often and peeps now and then.
    bool blink = (now / 150) % 20 == 0;
    uint8_t rows[8];
    for (int r = 0; r < 8; r++) rows[r] = CHICK[r];
    if (blink) rows[2] |= 0b00010000;
    draw(rows, 0, 0);
    if (random(0, 400) == 0) peep();
  } else {
    // From the first wobble on, the egg rocks a little now and then.
    int shift = 0;
    if (stage >= 1 && (now / 200) % 5 == 0) shift = (now / 1000) % 2 ? 1 : -1;
    draw(EGG, shift, stage >= 2 ? stage - 1 : 0);
  }
  delay(20);
}