Function bodies 879 total

uint16_t AXP192::GetIdischargeData(void) {
    uint16_t idischarge = 0;
    uint8_t buf[2];
    ReadBuff(0x7C, 2, buf);
    idischarge = (buf[0] << 5) + buf[1];
    return idischarge;
}

uint16_t AXP192::GetTempData(void) {
    uint16_t temp = 0;
    uint8_t buf[2];
    ReadBuff(0x5e, 2, buf);
    temp = ((buf[0] << 4) + buf[1]);
    return temp;
}

uint32_t AXP192::GetPowerbatData(void) {
    uint32_t power = 0;
    uint8_t buf[3];
    ReadBuff(0x70, 2, buf);
    power = (buf[0] << 16) + (buf[1] << 8) + buf[2];
    return power;
}

uint16_t AXP192::GetVapsData(void) {
    uint16_t vaps = 0;
    uint8_t buf[2];
    ReadBuff(0x7e, 2, buf);
    vaps = ((buf[0] << 4) + buf[1]);
    return vaps;
}

void AXP192::SetSleep(void) {
    Write1Byte(0x31, Read8bit(0x31) | (1 << 3));
    Write1Byte(0x90, 0x00);                   // GPIO0 voltage 0
    Write1Byte(0x12, 0x09);                   // CDC1, LDO3
    Write1Byte(0x12, Read8bit(0x12) & 0xA1);  // Disable all outputs but DCDC1
}

void AXP192::WakeUpDisplayAfterLightSleep(void) {
    // LDO2 is LCD Backlight
    // LDO3 is LCD Power
    // Enable Ext, LDO3, LDO2, DCDC1
    Write1Byte(0x12, Read8bit(0x12) | 0x4D);
}

uint8_t AXP192::GetWarningLeve(void) {
    Wire1.beginTransmission(0x34);
    Wire1.write(0x47);
    Wire1.endTransmission();
    Wire1.requestFrom(0x34, 1);
    uint8_t buf = Wire1.read();
    return (buf & 0x01);
}

void AXP192::DeepSleep(uint64_t time_in_us) {
    SetSleep();

    if (time_in_us > 0) {
        esp_sleep_enable_timer_wakeup(time_in_us);
    } else {
        esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
    }
    (time_in_us == 0) ? esp_deep_sleep_start() : esp_deep_sleep(time_in_us);
}

void AXP192::LightSleep(uint64_t time_in_us) {
    SetSleep();

    if (time_in_us > 0) {
        esp_sleep_enable_timer_wakeup(time_in_us);
    } else {
        esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
    }
    esp_light_sleep_start();
    WakeUpDisplayAfterLightSleep();
}

uint8_t AXP192::GetBtnPress() {
    uint8_t state = Read8bit(0x46);
    if (state) {
        Write1Byte(0x46, 0x03);
    }
    return state;
}

uint8_t AXP192::GetWarningLevel(void) {
    return Read8bit(0x47) & 0x01;
}

float AXP192::GetBatVoltage() {
    float ADCLSB    = 1.1 / 1000.0;
    uint16_t ReData = Read12Bit(0x78);
    return ReData * ADCLSB;
}

float AXP192::GetBatCurrent() {
    float ADCLSB        = 0.5;
    uint16_t CurrentIn  = Read13Bit(0x7A);
    uint16_t CurrentOut = Read13Bit(0x7C);
    return (CurrentIn - CurrentOut) * ADCLSB;
}

float AXP192::GetVinVoltage() {
    float ADCLSB    = 1.7 / 1000.0;
    uint16_t ReData = Read12Bit(0x56);
    return ReData * ADCLSB;
}

float AXP192::GetVinCurrent() {
    float ADCLSB    = 0.625;
    uint16_t ReData = Read12Bit(0x58);
    return ReData * ADCLSB;
}

float AXP192::GetVBusVoltage() {
    float ADCLSB    = 1.7 / 1000.0;
    uint16_t ReData = Read12Bit(0x5A);
    return ReData * ADCLSB;
}

float AXP192::GetVBusCurrent() {
    float ADCLSB    = 0.375;
    uint16_t ReData = Read12Bit(0x5C);
    return ReData * ADCLSB;
}

float AXP192::GetTempInAXP192() {
    float ADCLSB             = 0.1;
    const float OFFSET_DEG_C = -144.7;
    uint16_t ReData          = Read12Bit(0x5E);
    return OFFSET_DEG_C + ReData * ADCLSB;
}

float AXP192::GetBatPower() {
    float VoltageLSB = 1.1;
    float CurrentLCS = 0.5;
    uint32_t ReData  = Read24bit(0x70);
    return VoltageLSB * CurrentLCS * ReData / 1000.0;
}

float AXP192::GetBatChargeCurrent() {
    float ADCLSB    = 0.5;
    uint16_t ReData = Read12Bit(0x7A);
    return ReData * ADCLSB;
}

float AXP192::GetAPSVoltage() {
    float ADCLSB    = 1.4 / 1000.0;
    uint16_t ReData = Read12Bit(0x7E);
    return ReData * ADCLSB;
}

float AXP192::GetBatCoulombInput() {
    uint32_t ReData = Read32bit(0xB0);
    return ReData * 65536 * 0.5 / 3600 / 25.0;
}

float AXP192::GetBatCoulombOut() {
    uint32_t ReData = Read32bit(0xB4);
    return ReData * 65536 * 0.5 / 3600 / 25.0;
}

void AXP192::SetCoulombClear() {
    Write1Byte(0xB8, 0x20);
}

void AXP192::SetLDO2(bool State) {
    uint8_t buf = Read8bit(0x12);
    if (State == true)
        buf = (1 << 2) | buf;
    else
        buf = ~(1 << 2) & buf;
    Write1Byte(0x12, buf);
}

void AXP192::PowerOff() {
    Write1Byte(0x32, Read8bit(0x32) | 0x80);  // MSB for Power Off
}

void AXP192::SetPeripherialsPower(uint8_t state) {
    if (!state)
        Write1Byte(0x10, Read8bit(0x10) & 0XFB);
    else if (state)
        Write1Byte(0x10, Read8bit(0x10) | 0X04);
    // uint8_t data;
    // Set EXTEN to enable 5v boost
}

class AXP192 {
   public:
    AXP192();
    void begin(void);
    void ScreenBreath(int brightness);
    void ScreenSwitch(bool state);

    bool GetBatState();

    void EnableCoulombcounter(void);
    void DisableCoulombcounter(void);
    void StopCoulombcounter(void);
    void ClearCoulombcounter(void);
    uint32_t GetCoulombchargeData(void);
    uint32_t GetCoulombdischargeData(void);
    float GetCoulombData(void);

    uint16_t GetVbatData(void) __attribute__((deprecated));
    uint16_t GetIchargeData(void) __attribute__((deprecated));
    uint16_t GetIdischargeData(void) __attribute__((deprecated));
    uint16_t GetTempData(void) __attribute__((deprecated));
    uint32_t GetPowerbatData(void) __attribute__((deprecated));
    uint16_t GetVinData(void) __attribute__((deprecated));
    uint16_t GetIinData(void) __attribute__((deprecated));
    uint16_t GetVusbinData(void) __attribute__((deprecated));
    uint16_t GetIusbinData(void) __attribute__((deprecated));
    uint16_t GetVa

Device* Device::createInstance() {
  pinMode(BTN_UP, INPUT);
  pinMode(BTN_A,  INPUT);
  pinMode(BTN_B,  INPUT);

  // Power hold — keep device alive when USB disconnected
  pinMode(PWR_HOLD_PIN, OUTPUT);
  digitalWrite(PWR_HOLD_PIN, HIGH);

  // Internal I2C for BM8563 RTC
  Wire1.begin(INTERNAL_SDA, INTERNAL_SCL);

  // PWM backlight
  display.initBacklight();

  storageLFS.begin();

  return new Device(display, power, &navigation, nullptr,
                    nullptr, &storageLFS, nullptr, &speaker);
}

void Device::applyNavMode() {
  String mode = Config.get(APP_CONFIG_NAV_MODE, APP_CONFIG_NAV_MODE_DEFAULT);
  if (mode == "encoder") {
    switchNavigation(&encoderNavigation);
  } else {
    switchNavigation(&navigation);
  }
}

void Device::boardHook() {
  // 3s hold on BTN_A resets nav mode to default
  static unsigned long _btnAHeld = 0;
  if (digitalRead(BTN_A) == LOW) {
    if (_btnAHeld == 0) _btnAHeld = millis();
    else if (millis() - _btnAHeld >= 3000) {
      Config.set(APP_CONFIG_NAV_MODE, APP_CONFIG_NAV_MODE_DEFAULT);
      Config.save(Storage);
      applyNavMode();
      _btnAHeld = 0;
    }
  } else {
    _btnAHeld = 0;
  }
}

class DisplayImpl : public IDisplay
{
public:
  void initBacklight()
  {
    ledcSetup(LCD_BL_CH, 1000, 8);
    ledcAttachPin(LCD_BL, LCD_BL_CH);
    ledcWrite(LCD_BL_CH, 255);
  }

  void setBrightness(uint8_t pct) override
  {
    if (pct > 100) pct = 100;
    if (pct == 0) {
      ledcWrite(LCD_BL_CH, 0);
    } else {
      uint8_t duty = BL_MIN_DUTY + ((255 - BL_MIN_DUTY) * pct / 100);
      ledcWrite(LCD_BL_CH, duty);
    }
  }
};

public:
  void initBacklight()
  {
    ledcSetup(LCD_BL_CH, 1000, 8);
    ledcAttachPin(LCD_BL, LCD_BL_CH);
    ledcWrite(LCD_BL_CH, 255);
  }

  void setBrightness(uint8_t pct) override
  {
    if (pct > 100) pct = 100;
    if (pct == 0) {
      ledcWrite(LCD_BL_CH, 0);
    } else {
      uint8_t duty = BL_MIN_DUTY + ((255 - BL_MIN_DUTY) * pct / 100);
      ledcWrite(LCD_BL_CH, duty);
    }
  }

class EncoderNavigation : public INavigation
{
public:
  void begin() override
  {
    encoder.begin();
  }

  void update() override
  {
    // BTN_A short press (< 3 s) = back; 3 s hold is handled in Device::boardHook()
    bool btnA = (digitalRead(BTN_A) == LOW);
    if (btnA && !_btnAWasLow) {
      _btnAStart  = millis();
      _btnAWasLow = true;
    } else if (!btnA && _btnAWasLow) {
      if (millis() - _btnAStart < 3000) _emitBack = true;
      _btnAWasLow = false;
    }
    if (_emitBack) { _emitBack = false; updateState(DIR_BACK); return; }

    // BTN_UP release = left
    bool btnUp = (digitalRead(BTN_UP) == LOW);
    if (btnUp && !_btnUpWasLow) {
      _btnUpWasLow = true;
    } else if (!btnUp && _btnUpWasLow) {
      _emitLeft    = true;
      _btnUpWasLow = false;
    }
    if (_emitLeft) { _emitLeft = false; updateState(DIR_LEFT); return; }

    // BTN_B release = right
    bool btnB = (digitalRead(BTN_B) == LOW);
    if (btnB && !_btnBWasLow) {
      _btnBWasLow = t

public:
  void begin() override
  {
    encoder.begin();
  }

  void update() override
  {
    // BTN_A short press (< 3 s) = back; 3 s hold is handled in Device::boardHook()
    bool btnA = (digitalRead(BTN_A) == LOW);
    if (btnA && !_btnAWasLow) {
      _btnAStart  = millis();
      _btnAWasLow = true;
    } else if (!btnA && _btnAWasLow) {
      if (millis() - _btnAStart < 3000) _emitBack = true;
      _btnAWasLow = false;
    }
    if (_emitBack) { _emitBack = false; updateState(DIR_BACK); return; }

    // BTN_UP release = left
    bool btnUp = (digitalRead(BTN_UP) == LOW);
    if (btnUp && !_btnUpWasLow) {
      _btnUpWasLow = true;
    } else if (!btnUp && _btnUpWasLow) {
      _emitLeft    = true;
      _btnUpWasLow = false;
    }
    if (_emitLeft) { _emitLeft = false; updateState(DIR_LEFT); return; }

    // BTN_B release = right
    bool btnB = (digitalRead(BTN_B) == LOW);
    if (btnB && !_btnBWasLow) {
      _btnBWasLow = true;
    } else if (!btnB && _btnBWasLow) {
      _emitRight  = true;
      _btnBWasLow = false;
    }
    if

class NavigationImpl : public INavigation
{
public:
  void begin() override {}

  void update() override
  {
    const bool btnUp  = (digitalRead(BTN_UP) == LOW);
    const bool btnSel = (digitalRead(BTN_A)  == LOW);
    const bool btnDn  = (digitalRead(BTN_B)  == LOW);

    if (btnSel) updateState(DIR_PRESS);
    else if (btnUp) updateState(DIR_UP);
    else if (btnDn) updateState(DIR_DOWN);
    else updateState(DIR_NONE);
  }
};

  void update() override
  {
    const bool btnUp  = (digitalRead(BTN_UP) == LOW);
    const bool btnSel = (digitalRead(BTN_A)  == LOW);
    const bool btnDn  = (digitalRead(BTN_B)  == LOW);

    if (btnSel) updateState(DIR_PRESS);
    else if (btnUp) updateState(DIR_UP);
    else if (btnDn) updateState(DIR_DOWN);
    else updateState(DIR_NONE);
  }

class PowerImpl : public IPower
{
public:
  void begin() override
  {
    // Keep device alive when USB disconnected
    pinMode(PWR_HOLD_PIN, OUTPUT);
    digitalWrite(PWR_HOLD_PIN, HIGH);

    // Battery ADC
    pinMode(BAT_ADC_PIN, INPUT);
    analogReadMilliVolts(BAT_ADC_PIN);  // warm up ADC calibration
  }

  uint8_t getBatteryPercentage() override
  {
    float mv = (float)analogReadMilliVolts(BAT_ADC_PIN) * 2.0f; // voltage divider x2
    float pct = (mv - 3300.0f) / (4150.0f - 3300.0f) * 100.0f;
    if (pct < 0.0f)   pct = 0.0f;
    if (pct > 100.0f) pct = 100.0f;
    return (uint8_t)pct;
  }

  void powerOff() override
  {
    digitalWrite(PWR_HOLD_PIN, LOW);
    esp_sleep_enable_ext0_wakeup((gpio_num_t)BTN_UP, LOW);
    esp_deep_sleep_start();
  }

  bool isCharging() override
  {
    // No charger IC detection on Plus 2
    return false;
  }
};

public:
  void begin() override
  {
    // Keep device alive when USB disconnected
    pinMode(PWR_HOLD_PIN, OUTPUT);
    digitalWrite(PWR_HOLD_PIN, HIGH);

    // Battery ADC
    pinMode(BAT_ADC_PIN, INPUT);
    analogReadMilliVolts(BAT_ADC_PIN);  // warm up ADC calibration
  }

  uint8_t getBatteryPercentage() override
  {
    float mv = (float)analogReadMilliVolts(BAT_ADC_PIN) * 2.0f; // voltage divider x2
    float pct = (mv - 3300.0f) / (4150.0f - 3300.0f) * 100.0f;
    if (pct < 0.0f)   pct = 0.0f;
    if (pct > 100.0f) pct = 100.0f;
    return (uint8_t)pct;
  }

  void powerOff() override
  {
    digitalWrite(PWR_HOLD_PIN, LOW);
    esp_sleep_enable_ext0_wakeup((gpio_num_t)BTN_UP, LOW);
    esp_deep_sleep_start();
  }

  bool isCharging() override
  {
    // No charger IC detection on Plus 2
    return false;
  }

class SpeakerBuzzer : public ISpeaker {
public:
  void begin() override {
    ledcSetup(_ch, 1000, 8);
    ledcAttachPin(SPK_PIN, _ch);
    ledcWrite(_ch, 0);
    setVolume(Config.get(APP_CONFIG_VOLUME, APP_CONFIG_VOLUME_DEFAULT).toInt());
  }

  void tone(uint16_t freq, uint32_t durationMs) override {
    _stopTask();
    _freq     = freq;
    _duration = durationMs;
    xTaskCreate(_toneTask, "spkbzz", 1024, this, 2, &_taskHandle);
  }

  void noTone() override {
    _stopTask();
    ledcWrite(_ch, 0);
  }

  void setVolume(uint8_t vol) override {
    (void)vol;
    _duty = 128;
  }

  void beep() override {
    if (!Config.get(APP_CONFIG_NAV_SOUND, APP_CONFIG_NAV_SOUND_DEFAULT).toInt()) return;
    if (_taskHandle) return;
    playRandomTone();
  }

  void playRandomTone(int semitoneShift = 0, uint32_t durationMs = 150) override {
    static constexpr int scale[] = {60, 62, 64, 65, 67, 69, 71};
    int      midi = scale[random(0, 7)] + semitoneShift;
    uint16_t freq = (uint16_t)(

public:
  void begin() override {
    ledcSetup(_ch, 1000, 8);
    ledcAttachPin(SPK_PIN, _ch);
    ledcWrite(_ch, 0);
    setVolume(Config.get(APP_CONFIG_VOLUME, APP_CONFIG_VOLUME_DEFAULT).toInt());
  }

  void tone(uint16_t freq, uint32_t durationMs) override {
    _stopTask();
    _freq     = freq;
    _duration = durationMs;
    xTaskCreate(_toneTask, "spkbzz", 1024, this, 2, &_taskHandle);
  }

  void noTone() override {
    _stopTask();
    ledcWrite(_ch, 0);
  }

  void setVolume(uint8_t vol) override {
    (void)vol;
    _duty = 128;
  }

  void beep() override {
    if (!Config.get(APP_CONFIG_NAV_SOUND, APP_CONFIG_NAV_SOUND_DEFAULT).toInt()) return;
    if (_taskHandle) return;
    playRandomTone();
  }