Function bodies 879 total

class EncoderNavigation : public INavigation
{
public:
  EncoderNavigation(AXP192* axp) : _axp(axp) {}

  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; }

    // AXP M5 button = left
    if (_axp->GetBtnPress()) _emitLeft = true;
    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 (_emi

  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; }

    // AXP M5 button = left
    if (_axp->GetBtnPress()) _emitLeft = true;
    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 (_emitRight) { _emitRight = false; updateState(DIR_RIGHT); return; }

    // Encoder
    const bool rotLeft  = encoder.getEncoderValue() <= -2;
    const bool rotR

class NavigationImpl : public INavigation
{
public:
  NavigationImpl(AXP192* axp) : _axp(axp) {}
  void begin() override {}

  void update() override
  {
    const bool btnUp = _axp->GetBtnPress();
    const bool btnDown = (digitalRead(BTN_B) == LOW);
    const bool btnSel = (digitalRead(BTN_A) == LOW);

    if (btnSel) updateState(DIR_PRESS);
    else if (btnUp) updateState(DIR_UP);
    else if (btnDown) updateState(DIR_DOWN);
    else updateState(DIR_NONE);
  }
private:
  AXP192* _axp;
};

  void update() override
  {
    const bool btnUp = _axp->GetBtnPress();
    const bool btnDown = (digitalRead(BTN_B) == LOW);
    const bool btnSel = (digitalRead(BTN_A) == LOW);

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

class PowerImpl : public IPower
{
public:
  PowerImpl(AXP192* axp) : _axp(axp) {}
  void begin() override
  {
    _axp->begin();
  }
  uint8_t getBatteryPercentage() override
  {
    const float b = _axp->GetBatVoltage();
    const uint8_t percent = ((b - 3.0) / 1.2) * 100;
    return (percent < 0) ? 1 : (percent >= 100) ? 100 : percent;

  }

  void powerOff() override
  {
    _axp->PowerOff();
  }

  bool isCharging() override
  {
    return _axp->GetBatCurrent() > 20;
  }
private:
  AXP192* _axp;
};

  void begin() override
  {
    _axp->begin();
  }

  uint8_t getBatteryPercentage() override
  {
    const float b = _axp->GetBatVoltage();
    const uint8_t percent = ((b - 3.0) / 1.2) * 100;
    return (percent < 0) ? 1 : (percent >= 100) ? 100 : percent;

  }

  void powerOff() override
  {
    _axp->PowerOff();
  }

  bool isCharging() override
  {
    return _axp->GetBatCurrent() > 20;
  }

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 {
    // buzzer has no meaningful volume control — piezo max is 50% duty (128).
    // keep _duty at max; silence is handled by noTone() / duty=0 in _playTone.
    (void)vol;
    _duty = 128;
  }

  void beep() override {
    if (!Config.get(APP_CONFIG_NAV_SOUND, APP_CONFIG_NAV_SOUND_DEFAULT).toInt()) return;
    if (_taskHandle) return;  // already playing — skip rapid beeps
    playRandomTone();
  }

  void playRandomTone(int semitoneShift

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 {
    // buzzer has no meaningful volume control — piezo max is 50% duty (128).
    // keep _duty at max; silence is handled by noTone() / duty=0 in _playTone.
    (void)vol;
    _duty = 128;
  }

  void beep() override {
    if (!Config.get(APP_CONFIG_NAV_SOUND, APP_CONFIG_NAV_SOUND_DEFAULT).toInt()) return;
    if (_taskHandle) return;  // already playing — skip rapid beeps
    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)(440.0 * pow(2.0, (double)(midi - 69) / 12.0));
    tone(freq, durationMs);
  }

  void playWin() override {
    if (_taskHandle) return;
    _seq[0] = {523, 120, 50};
    _seq[1] = {659, 120, 50};
    _seq[2] = {784, 200, 0};
    _seqLen = 3;
    xTaskCreate(_seqTask, "spkseq", 1024, this, 2, &_taskHandle);
  }

  void playLose() override {
    if (_taskHandle) return;
    _seq[0] = {392, 120, 50};
    _seq[1] = {330, 120, 50};
    _seq[2] = {262, 200, 0};
    _seqLen = 3;
    xTaskCreate(_seqTask, "spkseq", 1024, this, 2, &_taskHandle);
  }

  void playCorrectAnswer() override {
    if (_taskHandle) return;
    _seq[0] = {523, 180, 100};
    _seq[1] = {784, 120, 0};
    _seqLen = 2;
    xTaskCreate(_seqTask, "spkseq", 1024, this, 2, &_taskHandle);
  }

  void playWrongAnswer() override {
    if (_taskHandle) return;
    _seq[0] = {1109, 150, 100};
    _seq[1] = {1109, 150, 0};
    _seqLen = 2;
    xTaskCreate(_seqTask, "spkseq", 1024, this, 2, &_taskHandle);
  }

  void _stopTask() {
    if (_taskHandle) {
      vTaskDelete(_taskHandle);
      _taskHandle = nullptr;
      ledcWrite(_ch, 0);
    }
  }

  void _playTone(uint16_t freq) {
    if (freq == 0 || _duty == 0) { ledcWrite(_ch, 0); return; }
    ledcSetup(_ch, freq, 8);
    ledcWrite(_ch, _duty);
  }

  static void _toneTask(void* arg) {
    auto* self = static_cast<SpeakerBuzzer*>(arg);
    self->_playTone(self->_freq);
    vTaskDelay(pdMS_TO_TICKS(self->_duration));
    ledcWrite(_ch, 0);
    self->_taskHandle = nullptr;
    vTaskDelete(nullptr);
  }

  static void _seqTask(void* arg) {
    auto* self = static_cast<SpeakerBuzzer*>(arg);
    for (uint8_t n = 0; n < self->_seqLen; n++) {
      const Note& note = self->_seq[n];
      self->_playTone(note.freq);
      vTaskDelay(pdMS_TO_TICKS(note.durationMs));
      ledcWrite(_ch, 0);
      if (note.delayMs > 0) vTaskDelay(pdMS_TO_TICKS(note.delayMs));
    }
    self->_taskHandle = nullptr;
    vTaskDelete(nullptr);
  }

void AXP192::begin(void) {
    Wire1.setClock(400000);
    // Set LDO2 & LDO3(TFT_LED & TFT) 3.0V
    Write1Byte(0x28, 0xcc);

    // Set ADC to All Enable
    Write1Byte(0x82, 0xff);

    // Bat charge voltage to 4.2, Current 100MA
    Write1Byte(0x33, 0xc0);

    // Enable Bat,ACIN,VBUS,APS adc
    Write1Byte(0x82, 0xff);

    // Enable Ext, LDO2, LDO3, DCDC1
    Write1Byte(0x12, Read8bit(0x12) | 0x4D);

    // 128ms power on, 4s power off
    Write1Byte(0x36, 0x0C);

    // Set RTC voltage to 3.3V
    Write1Byte(0x91, 0xF0);

    // Set GPIO0 to LDO
    Write1Byte(0x90, 0x02);

    // Disable vbus hold limit
    Write1Byte(0x30, 0x80);

    // Set temperature protection
    Write1Byte(0x39, 0xfc);

    // Enable RTC BAT charge
    Write1Byte(0x35, 0xa2);

    // Enable bat detection
    Write1Byte(0x32, 0x46);

    // ScreenBreath(80);
}

void AXP192::Write1Byte(uint8_t Addr, uint8_t Data) {
    Wire1.beginTransmission(0x34);
    Wire1.write(Addr);
    Wire1.write(Data);
    Wire1.endTransmission();
}

uint8_t AXP192::Read8bit(uint8_t Addr) {
    Wire1.beginTransmission(0x34);
    Wire1.write(Addr);
    Wire1.endTransmission();
    Wire1.requestFrom(0x34, 1);
    return Wire1.read();
}

uint16_t AXP192::Read12Bit(uint8_t Addr) {
    uint16_t Data = 0;
    uint8_t buf[2];
    ReadBuff(Addr, 2, buf);
    Data = ((buf[0] << 4) + buf[1]);  //
    return Data;
}

uint16_t AXP192::Read13Bit(uint8_t Addr) {
    uint16_t Data = 0;
    uint8_t buf[2];
    ReadBuff(Addr, 2, buf);
    Data = ((buf[0] << 5) + buf[1]);  //
    return Data;
}

uint16_t AXP192::Read16bit(uint8_t Addr) {
    uint16_t ReData = 0;
    Wire1.beginTransmission(0x34);
    Wire1.write(Addr);
    Wire1.endTransmission();
    Wire1.requestFrom(0x34, 2);
    for (int i = 0; i < 2; i++) {
        ReData <<= 8;
        ReData |= Wire1.read();
    }
    return ReData;
}

uint32_t AXP192::Read24bit(uint8_t Addr) {
    uint32_t ReData = 0;
    Wire1.beginTransmission(0x34);
    Wire1.write(Addr);
    Wire1.endTransmission();
    Wire1.requestFrom(0x34, 3);
    for (int i = 0; i < 3; i++) {
        ReData <<= 8;
        ReData |= Wire1.read();
    }
    return ReData;
}

uint32_t AXP192::Read32bit(uint8_t Addr) {
    uint32_t ReData = 0;
    Wire1.beginTransmission(0x34);
    Wire1.write(Addr);
    Wire1.endTransmission();
    Wire1.requestFrom(0x34, 4);
    for (int i = 0; i < 4; i++) {
        ReData <<= 8;
        ReData |= Wire1.read();
    }
    return ReData;
}

void AXP192::ReadBuff(uint8_t Addr, uint8_t Size, uint8_t *Buff) {
    Wire1.beginTransmission(0x34);
    Wire1.write(Addr);
    Wire1.endTransmission();
    Wire1.requestFrom(0x34, (int)Size);
    for (int i = 0; i < Size; i++) {
        *(Buff + i) = Wire1.read();
    }
}

void AXP192::ScreenBreath(int brightness) {
    if (brightness > 100 || brightness < 0) return;
    int vol     = map(brightness, 0, 100, 2500, 3200);
    vol         = (vol < 1800) ? 0 : (vol - 1800) / 100;
    uint8_t buf = Read8bit(0x28);
    Write1Byte(0x28, ((buf & 0x0f) | ((uint16_t)vol << 4)));
}

void AXP192::ScreenSwitch(bool state) {
    uint8_t brightness;
    if (state == false) {
        brightness = 0;
    } else if (state == true) {
        brightness = 12;
    }
    uint8_t buf = Read8bit(0x28);
    Write1Byte(0x28, ((buf & 0x0f) | (brightness << 4)));
}

bool AXP192::GetBatState() {
    if (Read8bit(0x01) | 0x20)
        return true;
    else
        return false;
}

void AXP192::EnableCoulombcounter(void) {
    Write1Byte(0xB8, 0x80);
}

void AXP192::DisableCoulombcounter(void) {
    Write1Byte(0xB8, 0x00);
}

void AXP192::StopCoulombcounter(void) {
    Write1Byte(0xB8, 0xC0);
}

void AXP192::ClearCoulombcounter(void) {
    Write1Byte(0xB8, 0xA0);
}

uint32_t AXP192::GetCoulombchargeData(void) {
    return Read32bit(0xB0);
}

uint32_t AXP192::GetCoulombdischargeData(void) {
    return Read32bit(0xB4);
}

float AXP192::GetCoulombData(void) {
    uint32_t coin  = 0;
    uint32_t coout = 0;

    coin  = GetCoulombchargeData();
    coout = GetCoulombdischargeData();

    // c = 65536 * current_LSB * (coin - coout) / 3600 / ADC rate
    // Adc rate can be read from 84H ,change this variable if you change the ADC
    // reate
    float ccc = 65536 * 0.5 * (int32_t)(coin - coout) / 3600.0 / 25.0;

    return ccc;
}

uint16_t AXP192::GetVbatData(void) {
    uint16_t vbat = 0;
    uint8_t buf[2];
    ReadBuff(0x78, 2, buf);
    vbat = ((buf[0] << 4) + buf[1]);  // V
    return vbat;
}

uint16_t AXP192::GetVinData(void) {
    uint16_t vin = 0;
    uint8_t buf[2];
    ReadBuff(0x56, 2, buf);
    vin = ((buf[0] << 4) + buf[1]);  // V
    return vin;
}

uint16_t AXP192::GetIinData(void) {
    uint16_t iin = 0;
    uint8_t buf[2];
    ReadBuff(0x58, 2, buf);
    iin = ((buf[0] << 4) + buf[1]);
    return iin;
}

uint16_t AXP192::GetVusbinData(void) {
    uint16_t vin = 0;
    uint8_t buf[2];
    ReadBuff(0x5a, 2, buf);
    vin = ((buf[0] << 4) + buf[1]);  // V
    return vin;
}

uint16_t AXP192::GetIusbinData(void) {
    uint16_t iin = 0;
    uint8_t buf[2];
    ReadBuff(0x5C, 2, buf);
    iin = ((buf[0] << 4) + buf[1]);
    return iin;
}

uint16_t AXP192::GetIchargeData(void) {
    uint16_t icharge = 0;
    uint8_t buf[2];
    ReadBuff(0x7A, 2, buf);
    icharge = (buf[0] << 5) + buf[1];
    return icharge;
}