Laser sword on an Arduino Uno

// Laser sword: a light saber style blade you can swing.
//
//   pin 2   the activation button, other side to GND (internal pull-up)
//   pin 3   the DFPlayer's BUSY line, LOW while a sound plays
//   pin 6   the blade: 24 WS2812 LEDs, through 330 ohm on the data line
//   pin 10  DFPlayer TX   pin 11 -> 1 k -> DFPlayer RX
//   A4, A5  the MPU6050 (SDA, SCL)
//   A0      the battery pack, through a 10 k / 10 k divider
//   7, 8, 9 the charge gauge: green, yellow, red
//
// Click the button to ignite the blade, click again to retract it. Hold it
// for a second while the blade is lit to pick the next color; the sword
// remembers it in EEPROM. Drag the MPU6050 to swing, flick it hard to clash.
//
// # The sound font
//
// The microSD card holds five files, in this order, the way most hobby
// saber cards are laid out:
//
//   0001 ignite   0002 hum   0003 swing   0004 clash   0005 retract
//
// The hum loops whenever nothing else is playing. A swing or a clash plays
// over it, and when BUSY goes high again the hum comes back.
//
// # Swing and clash
//
// A gyroscope measures how fast the hilt turns, so a swing is simply a turn
// rate above SWING_DPS. A clash is the blade stopping dead against something,
// which an accelerometer sees as a sudden jump: the change between two
// readings, summed over the three axes, above CLASH_JUMP.

#include <Wire.h>
#include <EEPROM.h>
#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>
#include <Adafruit_NeoPixel.h>

const int BUTTON = 2;
const int BUSY = 3;
const int BLADE_PIN = 6;
const int GAUGE_GREEN = 7;
const int GAUGE_YELLOW = 8;
const int GAUGE_RED = 9;
const int BATTERY = A0;

const int LEDS = 24;
const int MPU = 0x68;

// Turn rate for a swing, in degrees a second, and the accelerometer jump
// for a clash, in counts at +/-2 g (16384 counts is 1 g, so this is
// about three quarters of a g, arriving between two readings).
const long SWING_DPS = 150;
const long CLASH_JUMP = 12000;

// The pack is two Li-ion cells: 6.0 V empty, 8.4 V full. Halved by the
// divider that is 3.0 V to 4.2 V, which the ADC reads as about 614 to 860.
const int ADC_EMPTY = 614;
const int ADC_FULL = 860;

enum { SND_IGNITE = 1, SND_HUM, SND_SWING, SND_CLASH, SND_RETRACT };

const uint8_t COLORS[][3] = {
  {0, 90, 255},   // blue
  {0, 255, 40},   // green
  {255, 0, 0},    // red
  {170, 0, 255},  // purple
  {255, 120, 0},  // amber
  {255, 255, 255} // white
};
const char *const NAMES[] = {"blue", "green", "red", "purple", "amber", "white"};
const int COLOR_COUNT = 6;

Adafruit_NeoPixel blade(LEDS, BLADE_PIN, NEO_GRB + NEO_KHZ800);
SoftwareSerial link(10, 11);
DFRobotDFPlayerMini player;

bool lit = false;
int color = 0;
int battery = 100;
bool playerOk = false;

// The button: when it went down, and whether this press already did something.
bool wasDown = false;
unsigned long downAt = 0;
bool held = false;

int16_t lastA[3];
unsigned long readAt = 0;
unsigned long effectUntil = 0;
bool clashing = false;
unsigned long batteryAt = 0;
unsigned long humAt = 0;
unsigned long frameAt = 0;

long mag(long v) { return v < 0 ? -v : v; }

void mpuWrite(uint8_t reg, uint8_t value) {
  Wire.beginTransmission(MPU);
  Wire.write(reg);
  Wire.write(value);
  Wire.endTransmission();
}

// Accelerometer and gyroscope in one burst: fourteen bytes from 0x3B,
// high byte first, with the temperature in the middle.
bool mpuRead(int16_t a[3], int16_t g[3]) {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);
  if (Wire.endTransmission(false) != 0) return false;
  if (Wire.requestFrom(MPU, 14) != 14) return false;
  for (int i = 0; i < 3; i++) a[i] = (Wire.read() << 8) | Wire.read();
  Wire.read();
  Wire.read();
  for (int i = 0; i < 3; i++) g[i] = (Wire.read() << 8) | Wire.read();
  return true;
}

void play(int file) {
  if (playerOk) player.play(file);
}

// Paint the blade in the current color at `level` of full brightness, up to
// `length` LEDs from the hilt.
void paint(int length, int level) {
  const uint8_t *c = COLORS[color];
  for (int i = 0; i < LEDS; i++) {
    if (i < length) {
      blade.setPixelColor(i, c[0] * level / 255, c[1] * level / 255, c[2] * level / 255);
    } else {
      blade.setPixelColor(i, 0);
    }
  }
  blade.show();
}

void ignite() {
  if (battery < 5) {
    Serial.println("battery too low");
    return;
  }
  Serial.print("ignite ");
  Serial.println(NAMES[color]);
  play(SND_IGNITE);
  for (int n = 1; n <= LEDS; n++) {
    paint(n, 255);
    delay(12);
  }
  lit = true;
  effectUntil = millis() + 300;
}

void retract() {
  Serial.println("retract");
  play(SND_RETRACT);
  for (int n = LEDS - 1; n >= 0; n--) {
    paint(n, 255);
    delay(16);
  }
  lit = false;
}

void nextColor() {
  color = (color + 1) % COLOR_COUNT;
  EEPROM.update(0, color);
  Serial.print("color ");
  Serial.println(NAMES[color]);
  // Sweep the new color up the blade, one LED at a time.
  const uint8_t *c = COLORS[color];
  for (int i = 0; i < LEDS; i++) {
    blade.setPixelColor(i, c[0], c[1], c[2]);
    blade.show();
    delay(8);
  }
}

void readBattery() {
  long sum = 0;
  for (int i = 0; i < 4; i++) sum += analogRead(BATTERY);
  int level = map(sum / 4, ADC_EMPTY, ADC_FULL, 0, 100);
  battery = constrain(level, 0, 100);
  // The gauge: green above 60 percent, yellow above 25, red below that,
  // and a blinking red under 15 percent, which is when to charge it.
  bool blink = (millis() / 250) % 2;
  digitalWrite(GAUGE_GREEN, battery > 60);
  digitalWrite(GAUGE_YELLOW, battery > 25 && battery <= 60);
  digitalWrite(GAUGE_RED, battery <= 25 && (battery >= 15 || blink));
}

void setup() {
  pinMode(BUTTON, INPUT_PULLUP);
  pinMode(BUSY, INPUT);
  pinMode(GAUGE_GREEN, OUTPUT);
  pinMode(GAUGE_YELLOW, OUTPUT);
  pinMode(GAUGE_RED, OUTPUT);
  Serial.begin(115200);

  blade.begin();
  blade.show();

  Wire.begin();
  mpuWrite(0x6B, 0x00); // wake it: it powers up asleep
  mpuWrite(0x1B, 0x10); // gyroscope at +/-1000 degrees a second
  mpuWrite(0x1C, 0x00); // accelerometer at +/-2 g

  link.begin(9600);
  // Acknowledgments off: a sword cannot stop and wait for the sound board
  // to say "got it" in the middle of a swing.
  playerOk = player.begin(link, false);
  if (playerOk) player.volume(24);

  uint8_t saved = EEPROM.read(0);
  if (saved < COLOR_COUNT) color = saved;

  int16_t g[3];
  mpuRead(lastA, g);
  readBattery();
  Serial.print("Laser sword ready. Battery ");
  Serial.print(battery);
  Serial.println("%");
  if (!playerOk) Serial.println("no sound card");
}

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

  // The button: a click toggles the blade, a one second hold changes color.
  bool down = digitalRead(BUTTON) == LOW;
  if (down && !wasDown) {
    downAt = now;
    held = false;
  }
  if (down && !held && lit && now - downAt > 1000) {
    held = true;
    nextColor();
  }
  if (!down && wasDown && !held && now - downAt > 30) {
    if (lit) {
      retract();
    } else {
      ignite();
    }
  }
  wasDown = down;

  if (now - batteryAt > 200) {
    batteryAt = now;
    readBattery();
  }

  if (!lit) return;

  // Read the motion every 20 ms.
  if (now - readAt >= 20) {
    readAt = now;
    int16_t a[3], g[3];
    if (mpuRead(a, g)) {
      long jump = 0;
      for (int i = 0; i < 3; i++) jump += mag((long)a[i] - lastA[i]);
      long turn = mag(g[0]) + mag(g[1]) + mag(g[2]);
      for (int i = 0; i < 3; i++) lastA[i] = a[i];
      // 32.8 counts a degree a second at +/-1000.
      long dps = turn * 10 / 328;
      if (jump > CLASH_JUMP && now > effectUntil) {
        Serial.println("clash");
        play(SND_CLASH);
        clashing = true;
        effectUntil = now + 300;
      } else if (dps > SWING_DPS && now > effectUntil) {
        Serial.println("swing");
        play(SND_SWING);
        clashing = false;
        effectUntil = now + 400;
      }
    }
  }

  // Back to the hum whenever nothing else is playing. BUSY takes a moment
  // to fall after a command, so ask again at most every quarter second.
  if (playerOk && now > effectUntil && now - humAt > 250 && digitalRead(BUSY) == HIGH) {
    humAt = now;
    player.loop(SND_HUM);
  }

  // The blade, fifty frames a second: a white flash for a clash, full
  // brightness for a swing, and otherwise a slow shimmer, the way a real one
  // never looks quite still.
  if (now - frameAt < 20) return;
  frameAt = now;
  if (clashing && now + 200 < effectUntil) {
    blade.fill(blade.Color(255, 255, 255));
    blade.show();
  } else if (now < effectUntil) {
    paint(LEDS, 255);
  } else {
    clashing = false;
    paint(LEDS, 200 + random(40));
  }
}