muziekdoos/FW/leo_muziekdoos_esp32/src/power.cpp

#include "power.h"

bool powerbutton_released = true;

uint32_t PowerLastKeepAlive = 0;
uint32_t PowerOtaLongPressTime = 0;
uint32_t powerstate_timer = 0;

POWERSTATES powerstate = off;
POWERSTATES lastState = off;

Button buttonPower(PWR_BTN, 250UL, 1U, 0);
extern OtaProcess_class ota;

Button* getPowerButton()
{
  return &buttonPower;
}

void initPowerOn(void)
{
  pinMode(PWR_HOLD, OUTPUT);
  powerstate = poweringOn;
  buttonPower.begin();
}

POWERSTATES getPowerState(void)
{
  return powerstate;
}

void PowerKeepAlive(void)
{
  PowerLastKeepAlive = millis();
}

void powerOn(void)
{
  digitalWrite(PWR_HOLD, HIGH);
  delay(200);
}

void powerOff(void)
{
  log_w("poweringDown!");
  digitalWrite(DAC_SDMODE, LOW);
  digitalWrite(PWR_HOLD, LOW);
  delay(1000);
  // ESP.restart();
}

// handle power asynchronious
void handlePowerState(void)
{
  bool buttonread = buttonPower.read(); // update powerbutton
  switch (powerstate)
  {
  case off:
  {
    if (buttonread)
    {
      powerstate = poweringOn;
    }
    powerOff();
    SetLedColor(CRGB::Red);
    log_w("Powered-off");
  }
  break;
  case poweringOn:
  {
    if (buttonPower.pressedFor(POWERBUTTONDELAY))
    {
      powerstate = poweringOn2;
      SetLedColor(CRGB::Green, true);

      log_i("poweron 3/3 => Go");
    }
    else if (buttonPower.pressedFor(POWERBUTTONDELAY / 2))
    {
      log_i("poweron 2/3");
      SetLedColor(CRGB::WhiteSmoke);
    }
    else if (buttonPower.pressedFor(200))
    {
      log_i("poweron 1/3");
      SetLedColor(CRGB::GhostWhite);
    }

    if (buttonPower.releasedFor(200))
    {
      powerstate = off;
    }
  }
  break;
  case poweringOn2:
  {
    powerOn();
    if (buttonPower.releasedFor(200))
    {
      powerstate = powerinit;
      if (CheckBattery())
      {
        log_w("poweringOn: Lowbat");
        SetLedColor(CRGB::Red, true);

        // powerstate = lowBatt;
      }
    }
    else
    {
      log_i("Release for poweron, hold for %d to OTA", (POWERBUTTONOTADELAY - buttonPower.getPressedFor()));
    }
    if (buttonPower.pressedFor(POWERBUTTONOTADELAY))
    {
      powerstate = overTheAir;
    }
  }
  break;
  case powerinit:
  {
    // init all
    log_i("powerinit");
    SetLedColor(CRGB::Green);
    //initConfig();
    powerstate = on;
  }
  break;
  case on:
  {
    if (buttonPower.pressedFor(100))
    {
      lastState = on;
      powerstate = POWERSTATES::poweringOff;
      break;
    }
    if (getLowBatt())
    {
      log_w("on: Lowbat");
      powerstate_timer = millis();
      powerstate = POWERSTATES::lowBatt;
      SetLedColor(CRGB::Red, true);
      break;
    }
    if(millis() - PowerLastKeepAlive > TIMEOUT_POWER)
    {
      powerstate_timer = millis();
      powerstate = POWERSTATES::timeOut;
    }
  }
  break;
  case poweringOff:
  {
    if (buttonPower.pressedFor(POWERBUTTONDELAY))
    {
      powerstate = poweringOff2;
      setAudioState(false);
      SetLedColor(CRGB::Red, true);

      log_w("poweringoff: 3/3 ==> powerOff");
    }
    else
    {
      powerstate = lastState;
      SetLedColor(CRGB::Green);
    }
  }
  break;
  case poweringOff2:
  {
    if (buttonPower.releasedFor(200))
    {
      powerstate = off;
      SetLedColor(CRGB::Red, true);
    }
  }
  break;
  case timeOut:
  {
    log_w("timeout");
    SetLedColor(CRGB::Yellow, true);
    if(millis() - powerstate_timer > POWEROFFOFFDELAY)
    {
      powerstate = off;
    }
  }
  break;
  case lowBatt:
  {
    if(!getLowBatt())
    {
      powerstate = on;
      SetLedColor(CRGB::Green);
    }
    else
    {
      SetLedColor(CRGB::Red, true);
    }

    // add delay
    if(millis() - powerstate_timer > POWEROFFOFFDELAY)
    {
      powerstate = off;
    }
  }
  break;
  case overTheAir:
  {
    powerOn();
    if (buttonPower.releasedFor(200))
    {
      powerstate = overTheAir2;
      otaEnable();
      SetLedColor(CRGB::Blue);
    }
    else
    {
      SetLedColor(CRGB::Blue, true);
      log_i("ota state active, release powerbutton");
    }
  }
  break;
  case overTheAir2:
  {
    if (buttonPower.pressedFor(200))
    {
      log_i("ota poweroff");
      lastState = overTheAir2;
      powerstate = poweringOff;
    }
    if (getOtaState() != otaInitDone)
    {
      SetLedColor(CRGB::Orange, true);
    }
    else
    {
      SetLedColor(CRGB::Orange);
    }
    if (getOtaState() == OTASTATES::otaBusy)
    {
      SetLedColor(CRGB::Purple, true);
      log_i("ota state active, ota busy ==> On");
    }
    if (getOtaState() == OTASTATES::otaDone)
    {
      log_i("ota state active, ota Done ==> On");

      powerstate = POWERSTATES::off;
      SetLedColor(CRGB::Green, true);
    }
    if (getOtaState() == OTASTATES::otaError)
    {
      powerstate = POWERSTATES::off;
      SetLedColor(CRGB::Red, true);
    }
  }
  break;
  }
}

/* public functions */

void initPower(void)
{
  log_i("Power: init");
  initPowerOn();
  initBattery();
  log_i("Power: init: done");
}

void handlePower(void)
{
  handlePowerState();
}