Lion dance head on an Arduino Uno

// Lion dance head: a lion that wakes up, blinks its big eyes and dances to a
// drum beat, and goes wild when you feed it the greens.
//
//   eyes      pins 5 and 6 -> 220 ohms -> LED -> GND, one each
//   eyelids   servo PWM -> pin 9, VCC -> 5 V, GND -> GND
//   drum      pin 8 -> piezo -> GND
//   tempo     potentiometer wiper -> A0, ends to 5 V and GND
//   greens    pin 2 -> button -> GND        (INPUT_PULLUP)
//
// Lion dances bring good luck at Lunar New Year, to the beat of a drum,
// cymbals and a gong. Before a new lion dances for the first time, its eyes
// are dotted to wake it, so this one starts with its eyes shut and opens them
// slowly.
//
// The drum plays an eight-step pattern: a low boom on the strong beats and a
// higher tap on the others. The eyes flash on every boom and the eyelids
// blink now and then. The knob sets the tempo.
//
// The button is the greens. In the custom called cai qing, plucking the
// greens, the lion reaches for lettuce hung up high, often with a red
// envelope tied to it. Press it and the drum rolls, the eyes flash fast, and
// then the lion settles back into its dance.
//
// Things to try. Turn the knob. Press the button. Write your own rhythm into
// PATTERN: 2 is a boom, 1 a tap, 0 a rest.

#include <Servo.h>

const int EYE_L = 5, EYE_R = 6;
const int LID_PIN = 9;
const int DRUM_PIN = 8;
const int GREENS_PIN = 2;
const int OPEN = 20, SHUT = 100;

const uint8_t PATTERN[8] = {2, 0, 1, 1, 2, 0, 1, 0};
Servo lids;

int step = 0;
unsigned long nextStep = 0;
unsigned long nextBlink = 3000;

void eyes(int level) {
  analogWrite(EYE_L, level);
  analogWrite(EYE_R, level);
}

void wake() {
  // Eyes shut, then opening slowly as they light.
  for (int a = SHUT; a >= OPEN; a -= 2) {
    lids.write(a);
    eyes(map(a, SHUT, OPEN, 0, 120));
    delay(30);
  }
  Serial.println("The lion is awake");
}

void greens() {
  Serial.println("Cai qing: the lion plucks the greens!");
  for (int i = 0; i < 24; i++) {
    tone(DRUM_PIN, i % 2 ? 150 : 110, 40);
    eyes(i % 2 ? 255 : 30);
    lids.write(i % 4 < 2 ? OPEN : OPEN + 30);
    delay(60);
  }
  eyes(120);
  lids.write(OPEN);
  Serial.println("Back to the dance");
}

void setup() {
  Serial.begin(9600);
  pinMode(EYE_L, OUTPUT);
  pinMode(EYE_R, OUTPUT);
  pinMode(GREENS_PIN, INPUT_PULLUP);
  lids.attach(LID_PIN);
  lids.write(SHUT);
  wake();
}

void loop() {
  unsigned long now = millis();
  if (digitalRead(GREENS_PIN) == LOW) {
    greens();
    while (digitalRead(GREENS_PIN) == LOW) delay(10);
    return;
  }

  if (now >= nextStep) {
    // 80 to 200 beats a minute, two steps to a beat.
    int bpm = map(analogRead(A0), 0, 1023, 80, 200);
    nextStep = now + 30000UL / bpm;
    uint8_t hit = PATTERN[step];
    if (hit == 2) {
      tone(DRUM_PIN, 110, 70);
      eyes(255);
    } else if (hit == 1) {
      tone(DRUM_PIN, 220, 30);
      eyes(160);
    } else {
      eyes(90);
    }
    if (step == 0) {
      Serial.print("Drum at ");
      Serial.print(bpm);
      Serial.println(" beats a minute");
    }
    step = (step + 1) % 8;
  }

  // A blink every few seconds: shut and open again.
  if (now >= nextBlink) {
    lids.write(SHUT);
    delay(150);
    lids.write(OPEN);
    nextBlink = now + random(2500, 6000);
  }
}