rgb.cpp

#include <Arduino.h>
#include "esp32-hal-rgb-led.h"

#include "animation.h"
#include "network/wifi_connect.h"
#include "pins.h"
#include "hardware/rgb.h"
#include "serial_log.h"
#include "settings/settings.h"

#include <cstring>

namespace {

constexpr uint8_t RGB_ANIM_WHITE = 255;
constexpr uint8_t RGB_ANIM_RED = 255;
constexpr uint32_t RGB_TRANSITION_MS = 1000;

// Boot-failure blink codes. The gap is 10x the pause between blinks within a
// train, so the cycle boundary stays unmistakable as more codes are added: even
// a long count reads as one group followed by an obvious silence.
constexpr uint32_t RGB_CODE_BLINK_MS = 300;
constexpr uint32_t RGB_CODE_GAP_MS = 3000;

constexpr uint8_t RGB_PULSE_MIN = 26;   // ~10% of 255
constexpr uint8_t RGB_PULSE_MAX = 255;  // 100%
constexpr uint32_t RGB_PULSE_PHASE_MS = 500;
constexpr uint32_t RGB_PULSE_CYCLE_MS = RGB_PULSE_PHASE_MS * 3;

constexpr uint8_t RGB_PROVISIONING_B = 64;

uint8_t g_startR = 0;
uint8_t g_startG = 0;
uint8_t g_startB = 0;
uint8_t g_targetR = 0;
uint8_t g_targetG = 0;
uint8_t g_targetB = 0;
uint8_t g_currentR = 0;
uint8_t g_currentG = 0;
uint8_t g_currentB = 0;
uint32_t g_transitionStartMs = 0;
bool g_transitionActive = false;
bool g_twoPhaseTransition = false;
bool g_pulseActive = false;
uint32_t g_pulseStartMs = 0;
bool g_setupLedHold = false;

uint8_t lerpChannel(uint8_t from, uint8_t to, float t) {
  return static_cast<uint8_t>(from + (to - from) * t);
}

float easeInOut(float t) {
  return t * t * (3.0f - 2.0f * t);
}

bool isOff(uint8_t r, uint8_t g, uint8_t b) {
  return r == 0 && g == 0 && b == 0;
}

bool sameColor(uint8_t r1, uint8_t g1, uint8_t b1, uint8_t r2, uint8_t g2, uint8_t b2) {
  return r1 == r2 && g1 == g2 && b1 == b2;
}

rgb_led_color_order_t ledColorOrderFromName(const char* order) {
  if (order == nullptr) {
    return LED_COLOR_ORDER_GRB;
  }

  if (strcmp(order, "RGB") == 0) {
    return LED_COLOR_ORDER_RGB;
  }

  if (strcmp(order, "RBG") == 0) {
    return LED_COLOR_ORDER_RBG;
  }

  if (strcmp(order, "GRB") == 0) {
    return LED_COLOR_ORDER_GRB;
  }

  if (strcmp(order, "GBR") == 0) {
    return LED_COLOR_ORDER_GBR;
  }

  if (strcmp(order, "BRG") == 0) {
    return LED_COLOR_ORDER_BRG;
  }

  if (strcmp(order, "BGR") == 0) {
    return LED_COLOR_ORDER_BGR;
  }

  return LED_COLOR_ORDER_GRB;
}

rgb_led_color_order_t ledColorOrderFromSettings() {
  return ledColorOrderFromName(settingsRgbOrder());
}

void writeRgb(uint8_t r, uint8_t g, uint8_t b) {
  rgbLedWriteOrdered(RGB_LED_PIN, ledColorOrderFromSettings(), r, g, b);
  g_currentR = r;
  g_currentG = g;
  g_currentB = b;
}

void resolveAnimationTarget(AnimationId id, uint8_t& r, uint8_t& g, uint8_t& b) {
  switch (id) {
    case AnimationId::Typing:
    case AnimationId::Reading:
    case AnimationId::Thinking:
    case AnimationId::Talking:
    case AnimationId::Welcome:
    case AnimationId::Ring:
    case AnimationId::Wakeup:
      r = RGB_ANIM_WHITE;
      g = RGB_ANIM_WHITE;
      b = RGB_ANIM_WHITE;
      break;
    case AnimationId::Attention:
    case AnimationId::Error:
    case AnimationId::Dead:
    case AnimationId::Abort:
      r = RGB_ANIM_RED;
      g = 0;
      b = 0;
      break;
    case AnimationId::None:
    case AnimationId::Sleep:
    default:
      r = 0;
      g = 0;
      b = 0;
      break;
  }
}

bool isPulseAnimation(AnimationId id) {
  return id == AnimationId::Attention
    || id == AnimationId::Error
    || id == AnimationId::Dead;
}

bool sameTarget(uint8_t r, uint8_t g, uint8_t b) {
  return r == g_targetR && g == g_targetG && b == g_targetB;
}

void applyPulse(uint32_t nowMs) {
  const uint32_t elapsed =
    (nowMs >= g_pulseStartMs) ? ((nowMs - g_pulseStartMs) % RGB_PULSE_CYCLE_MS) : 0;

  uint8_t level = RGB_PULSE_MAX;
  if (elapsed < RGB_PULSE_PHASE_MS) {
    const float t =
      static_cast<float>(elapsed) / static_cast<float>(RGB_PULSE_PHASE_MS);
    level = lerpChannel(RGB_PULSE_MIN, RGB_PULSE_MAX, t);
  } else if (elapsed < RGB_PULSE_PHASE_MS * 2) {
    level = RGB_PULSE_MAX;
  } else {
    const float t = static_cast<float>(elapsed - RGB_PULSE_PHASE_MS * 2) /
      static_cast<float>(RGB_PULSE_PHASE_MS);
    level = lerpChannel(RGB_PULSE_MAX, RGB_PULSE_MIN, t);
  }

  writeRgb(level, 0, 0);
}

void applyTransition(uint32_t nowMs) {
  if (!g_transitionActive) {
    return;
  }

  const uint32_t elapsed =
    (nowMs >= g_transitionStartMs) ? (nowMs - g_transitionStartMs) : 0;
  if (elapsed >= RGB_TRANSITION_MS) {
    writeRgb(g_targetR, g_targetG, g_targetB);
    g_transitionActive = false;
    g_twoPhaseTransition = false;
    return;
  }

  if (g_twoPhaseTransition) {
    const uint32_t halfMs = RGB_TRANSITION_MS / 2;
    if (elapsed < halfMs) {
      const float t = easeInOut(static_cast<float>(elapsed) / static_cast<float>(halfMs));
      writeRgb(
        lerpChannel(g_startR, 0, t),
        lerpChannel(g_startG, 0, t),
        lerpChannel(g_startB, 0, t)
      );
      return;
    }

    const float t = easeInOut(
      static_cast<float>(elapsed - halfMs) / static_cast<float>(halfMs)
    );
    writeRgb(
      lerpChannel(0, g_targetR, t),
      lerpChannel(0, g_targetG, t),
      lerpChannel(0, g_targetB, t)
    );
    return;
  }

  const float t = easeInOut(
    static_cast<float>(elapsed) / static_cast<float>(RGB_TRANSITION_MS)
  );
  writeRgb(
    lerpChannel(g_startR, g_targetR, t),
    lerpChannel(g_startG, g_targetG, t),
    lerpChannel(g_startB, g_targetB, t)
  );
}

}  // namespace

void setRgb(uint8_t r, uint8_t g, uint8_t b) {
  writeRgb(r, g, b);
  g_startR = r;
  g_startG = g;
  g_startB = b;
  g_targetR = r;
  g_targetG = g;
  g_targetB = b;
  g_transitionActive = false;
  g_twoPhaseTransition = false;
  g_pulseActive = false;
}

void rgbSetupHoldWireByte(uint8_t byteIndex) {
  g_setupLedHold = true;

  const uint8_t r = byteIndex == 0 ? 255 : 0;
  const uint8_t g = byteIndex == 1 ? 255 : 0;
  const uint8_t b = byteIndex == 2 ? 255 : 0;
  rgbLedWriteOrdered(RGB_LED_PIN, LED_COLOR_ORDER_RGB, r, g, b);
}

void rgbSetupHoldLogical(uint8_t r, uint8_t g, uint8_t b, const char* order) {
  g_setupLedHold = true;

  const char* use = settingsRgbOrder();

  if (order != nullptr && settingsValidateRgbOrder(order)) {
    use = order;
  }

  rgbLedWriteOrdered(RGB_LED_PIN, ledColorOrderFromName(use), r, g, b);
}

void rgbSetupRelease() {
  g_setupLedHold = false;

  if (wifiProvisioningMode()) {
    setRgb(0, 0, RGB_PROVISIONING_B);
  }
}

void setRgbForAnimation(AnimationId id, uint32_t nowMs) {
  if (isPulseAnimation(id)) {
    if (g_pulseActive) {
      return;
    }
    g_pulseActive = true;
    g_pulseStartMs = nowMs;
    g_transitionActive = false;
    g_twoPhaseTransition = false;
    g_targetR = RGB_ANIM_RED;
    g_targetG = 0;
    g_targetB = 0;
    applyPulse(nowMs);
    return;
  }

  const bool wasPulsing = g_pulseActive;
  g_pulseActive = false;

  uint8_t r = 0;
  uint8_t g = 0;
  uint8_t b = 0;
  resolveAnimationTarget(id, r, g, b);

  if (!wasPulsing && sameTarget(r, g, b) && !g_transitionActive) {
    return;
  }

  g_startR = g_currentR;
  g_startG = g_currentG;
  g_startB = g_currentB;
  g_targetR = r;
  g_targetG = g;
  g_targetB = b;

  const bool startOff = isOff(g_startR, g_startG, g_startB);
  const bool targetOff = isOff(g_targetR, g_targetG, g_targetB);
  g_twoPhaseTransition =
    !startOff &&
    !targetOff &&
    !sameColor(g_startR, g_startG, g_startB, g_targetR, g_targetG, g_targetB);

  g_transitionStartMs = nowMs;
  g_transitionActive = true;
  applyTransition(nowMs);
}

void updateRgb(uint32_t nowMs) {
  static bool wasProvisioning = false;

  if (wifiProvisioningMode()) {
    if (g_setupLedHold) {
      wasProvisioning = true;
      return;
    }

    if (g_currentR != 0 || g_currentG != 0 || g_currentB != RGB_PROVISIONING_B) {
      setRgb(0, 0, RGB_PROVISIONING_B);
    }
    wasProvisioning = true;
    return;
  }

  if (wasProvisioning) {
    wasProvisioning = false;
    setRgbForAnimation(getAnimation(), nowMs);
  }

  if (g_pulseActive) {
    applyPulse(nowMs);
    return;
  }

  applyTransition(nowMs);
}

void haltWithRgbCode(uint8_t blinks) {
  while (true) {
    for (uint8_t i = 0; i < blinks; i++) {
      setRgb(64, 0, 0);
      delay(RGB_CODE_BLINK_MS);
      setRgb(0, 0, 0);
      delay(RGB_CODE_BLINK_MS);
    }

    delay(RGB_CODE_GAP_MS);
  }
}

void runRgbTest() {
  serialLogPrintln("RGB test");

  setRgb(64, 0, 0);
  delay(300);

  setRgb(0, 64, 0);
  delay(300);

  setRgb(0, 0, 64);
  delay(300);

  setRgb(32, 32, 32);
  delay(300);

  setRgb(0, 0, 0);

  serialLogPrintln("RGB OK");
}