Arc reactor and faceplate on an Arduino Uno

// Arc reactor: an arc reactor style chest light and a helmet faceplate.
//
//   pin 6   the reactor: a 16 LED WS2812 ring, through 330 ohm on the data line
//   pin 9   the faceplate servo's signal
//   pin 2   the gauntlet button, other side to GND (internal pull-up)
//   pin 4   the TTP223 touch pad on the helmet (HIGH while touched)
//   pin 5   the left eye, through 220 ohm
//   pin 3   the right eye, through 220 ohm
//
// Touch the pad or press the button to open the faceplate; do it again to
// close it. The eyes fade out before the plate lifts and flicker back on
// after it closes, and the reactor breathes the whole time.
//
// # Breathing
//
// A steady light looks like a lamp. A light that slowly swells and fades looks
// alive. The sketch walks a phase from 0 to 255 and back, and turns it into a
// brightness between GLOW_LOW and full with a gentle curve, so the light
// lingers at the top and bottom the way breathing does.
//
// # Moving a servo gently
//
// servo.write(110) would slam the plate open as fast as the motor can go. The
// sketch moves it two degrees every 15 ms instead, so it glides, and keeps
// the reactor breathing in between steps.

#include <Adafruit_NeoPixel.h>
#include <Servo.h>

const int RING_PIN = 6;
const int SERVO_PIN = 9;
const int BUTTON = 2;
const int TOUCH = 4;
const int EYE_LEFT = 5;
const int EYE_RIGHT = 3;

const int LEDS = 16;
const int CLOSED = 10;   // faceplate angles, in degrees
const int OPEN = 110;
const int GLOW_LOW = 50; // the dimmest the reactor breathes down to

Adafruit_NeoPixel ring(LEDS, RING_PIN, NEO_GRB + NEO_KHZ800);
Servo plate;

int angle = CLOSED;
int target = CLOSED;
int eyes = 0;          // eye brightness now, 0 to 255
int eyesTarget = 255;
int phase = 0;
int phaseStep = 3;

bool lastButton = false;
bool lastTouch = false;
unsigned long buttonAt = 0;
unsigned long frameAt = 0;
unsigned long servoAt = 0;
unsigned long flickerUntil = 0;

// The reactor's color at `level`: a cool blue-white, the classic glow.
void glow(int level) {
  ring.fill(ring.Color(level * 40 / 255, level * 180 / 255, level));
  ring.show();
}

void setEyes(int level) {
  analogWrite(EYE_LEFT, level);
  analogWrite(EYE_RIGHT, level);
}

void toggle(const char *why) {
  if (target == CLOSED) {
    target = OPEN;
    eyesTarget = 0;
    Serial.print("faceplate open (");
  } else {
    target = CLOSED;
    Serial.print("faceplate closed (");
  }
  Serial.print(why);
  Serial.println(")");
}

void setup() {
  pinMode(BUTTON, INPUT_PULLUP);
  pinMode(TOUCH, INPUT);
  pinMode(EYE_LEFT, OUTPUT);
  pinMode(EYE_RIGHT, OUTPUT);
  Serial.begin(115200);

  plate.attach(SERVO_PIN);
  plate.write(CLOSED);

  ring.begin();
  ring.setBrightness(200);
  // Power up: one LED at a time around the ring, then the whole core.
  for (int i = 0; i < LEDS; i++) {
    ring.setPixelColor(i, ring.Color(30, 140, 200));
    ring.show();
    delay(40);
  }
  Serial.println("Arc reactor online");
}

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

  // Inputs: the button on a falling edge, debounced; the touch pad on a
  // rising edge (the TTP223 does its own debouncing).
  bool button = digitalRead(BUTTON) == LOW;
  if (button && !lastButton && now - buttonAt > 200) {
    buttonAt = now;
    toggle("button");
  }
  lastButton = button;
  bool touch = digitalRead(TOUCH) == HIGH;
  if (touch && !lastTouch) toggle("touch");
  lastTouch = touch;

  // The faceplate: wait for the eyes to go dark before opening, then glide.
  if (now - servoAt >= 15) {
    servoAt = now;
    bool eyesReady = target == CLOSED || eyes == 0;
    if (angle != target && eyesReady) {
      angle = angle < target ? min(angle + 2, target) : max(angle - 2, target);
      plate.write(angle);
      if (angle == CLOSED) {
        // Closed: the eyes come back with a flicker, like a system booting.
        eyesTarget = 255;
        flickerUntil = now + 400;
      }
    }
    plate.refresh();
  }

  // Thirty-three frames a second for the ring and the eyes.
  if (now - frameAt < 30) return;
  frameAt = now;

  phase += phaseStep;
  if (phase >= 255 || phase <= 0) {
    phaseStep = -phaseStep;
    phase = constrain(phase, 0, 255);
  }
  // A soft curve: square the phase so the glow lingers near the bottom.
  long curve = (long)phase * phase / 255;
  glow(GLOW_LOW + curve * (255 - GLOW_LOW) / 255);

  if (eyes < eyesTarget) eyes = min(255, eyes + 25);
  if (eyes > eyesTarget) eyes = max(0, eyes - 25);
  if (now < flickerUntil) {
    setEyes(random(2) ? eyes : 0);
  } else {
    setEyes(eyes);
  }
}