mirror of
https://github.com/ByteWelder/Tactility.git
synced 2026-04-18 09:25:06 +00:00
283 lines
8.7 KiB
C++
283 lines
8.7 KiB
C++
#include "Power.h"
|
|
|
|
#include <tactility/log.h>
|
|
#include <freertos/FreeRTOS.h>
|
|
#include <freertos/task.h>
|
|
#include <driver/ledc.h>
|
|
|
|
using namespace tt::hal::power;
|
|
|
|
constexpr auto* TAG = "PaperS3Power";
|
|
|
|
// M5Stack PaperS3 hardware pin definitions
|
|
constexpr gpio_num_t VBAT_PIN = GPIO_NUM_3; // Battery voltage with 2x divider
|
|
constexpr adc_channel_t VBAT_ADC_CHANNEL = ADC_CHANNEL_2; // GPIO3 = ADC1_CHANNEL_2
|
|
|
|
constexpr gpio_num_t CHARGE_STATUS_PIN = GPIO_NUM_4; // Charge IC status: 0 = charging, 1 = full/no USB
|
|
constexpr gpio_num_t USB_DETECT_PIN = GPIO_NUM_5; // USB detect: 1 = USB connected
|
|
constexpr gpio_num_t POWER_OFF_PIN = GPIO_NUM_44; // Pull high to trigger shutdown
|
|
constexpr gpio_num_t BUZZER_PIN = GPIO_NUM_21;
|
|
|
|
// Battery voltage divider ratio (voltage is divided by 2)
|
|
constexpr float VOLTAGE_DIVIDER_MULTIPLIER = 2.0f;
|
|
|
|
// Battery voltage range for LiPo batteries
|
|
constexpr float MIN_BATTERY_VOLTAGE = 3.3f;
|
|
constexpr float MAX_BATTERY_VOLTAGE = 4.2f;
|
|
|
|
// Power-off signal timing
|
|
constexpr int POWER_OFF_PULSE_COUNT = 5;
|
|
constexpr int POWER_OFF_PULSE_DURATION_MS = 100;
|
|
|
|
constexpr uint32_t BUZZER_DUTY_50_PERCENT = 4096; // 50% of 13-bit (8192)
|
|
|
|
PaperS3Power::PaperS3Power(
|
|
std::unique_ptr<ChargeFromAdcVoltage> chargeFromAdcVoltage,
|
|
gpio_num_t powerOffPin
|
|
)
|
|
: chargeFromAdcVoltage(std::move(chargeFromAdcVoltage)),
|
|
powerOffPin(powerOffPin) {
|
|
LOG_I(TAG, "Initialized M5Stack PaperS3 power management");
|
|
}
|
|
|
|
void PaperS3Power::buzzerLedcInit() {
|
|
if (buzzerInitialized) {
|
|
LOG_I(TAG, "Buzzer already initialized");
|
|
return;
|
|
}
|
|
|
|
ledc_timer_config_t timer_cfg = {
|
|
.speed_mode = LEDC_LOW_SPEED_MODE,
|
|
.duty_resolution = LEDC_TIMER_13_BIT,
|
|
.timer_num = LEDC_TIMER_0,
|
|
.freq_hz = 1000,
|
|
.clk_cfg = LEDC_AUTO_CLK,
|
|
.deconfigure = false
|
|
};
|
|
esp_err_t err = ledc_timer_config(&timer_cfg);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC timer config failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
ledc_channel_config_t channel_cfg = {
|
|
.gpio_num = BUZZER_PIN,
|
|
.speed_mode = LEDC_LOW_SPEED_MODE,
|
|
.channel = LEDC_CHANNEL_0,
|
|
.intr_type = LEDC_INTR_DISABLE,
|
|
.timer_sel = LEDC_TIMER_0,
|
|
.duty = 0,
|
|
.hpoint = 0,
|
|
.sleep_mode = LEDC_SLEEP_MODE_NO_ALIVE_NO_PD,
|
|
.flags = {
|
|
.output_invert = 0
|
|
}
|
|
};
|
|
err = ledc_channel_config(&channel_cfg);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC channel config failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
buzzerInitialized = true;
|
|
}
|
|
|
|
void PaperS3Power::initializePowerOff() {
|
|
if (powerOffInitialized) {
|
|
return;
|
|
}
|
|
|
|
gpio_config_t io_conf = {
|
|
.pin_bit_mask = (1ULL << powerOffPin),
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
};
|
|
|
|
esp_err_t err = gpio_config(&io_conf);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "Failed to configure power-off pin GPIO%d: %s", powerOffPin, esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
gpio_set_level(powerOffPin, 0);
|
|
powerOffInitialized = true;
|
|
LOG_I(TAG, "Power-off control initialized on GPIO%d", powerOffPin);
|
|
|
|
buzzerLedcInit();
|
|
}
|
|
|
|
// TODO: Fix USB Detection
|
|
bool PaperS3Power::isUsbConnected() {
|
|
// USB_DETECT_PIN is configured as input with pull-down by initBoot() in Init.cpp.
|
|
// Level 1 = USB VBUS present (per M5PaperS3 hardware spec).
|
|
bool usbConnected = gpio_get_level(USB_DETECT_PIN) == 1;
|
|
LOG_D(TAG, "USB_STATUS(GPIO%d)=%d", USB_DETECT_PIN, (int)usbConnected);
|
|
return usbConnected;
|
|
}
|
|
|
|
bool PaperS3Power::isCharging() {
|
|
// CHARGE_STATUS_PIN is configured as GPIO_MODE_INPUT by initBoot() in Init.cpp.
|
|
int chargePin = gpio_get_level(CHARGE_STATUS_PIN);
|
|
LOG_D(TAG, "CHG_STATUS(GPIO%d)=%d", CHARGE_STATUS_PIN, chargePin);
|
|
return chargePin == 0;
|
|
}
|
|
|
|
bool PaperS3Power::supportsMetric(MetricType type) const {
|
|
switch (type) {
|
|
using enum MetricType;
|
|
case BatteryVoltage:
|
|
case ChargeLevel:
|
|
case IsCharging:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool PaperS3Power::getMetric(MetricType type, MetricData& data) {
|
|
switch (type) {
|
|
using enum MetricType;
|
|
|
|
case BatteryVoltage:
|
|
return chargeFromAdcVoltage->readBatteryVoltageSampled(data.valueAsUint32);
|
|
|
|
case ChargeLevel: {
|
|
uint32_t voltage = 0;
|
|
if (chargeFromAdcVoltage->readBatteryVoltageSampled(voltage)) {
|
|
data.valueAsUint8 = chargeFromAdcVoltage->estimateChargeLevelFromVoltage(voltage);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
case IsCharging:
|
|
// isUsbConnected() is tracked separately but not used as a gate here:
|
|
// when USB is absent the charge IC's CHG pin is inactive (high), so
|
|
// isCharging() already returns false correctly.
|
|
data.valueAsBool = isCharging();
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void PaperS3Power::toneOn(int frequency, int duration) {
|
|
if (!buzzerInitialized) {
|
|
LOG_I(TAG, "Buzzer not initialized");
|
|
return;
|
|
}
|
|
|
|
if (frequency <= 0) {
|
|
LOG_I(TAG, "Invalid frequency: %d", frequency);
|
|
return;
|
|
}
|
|
|
|
esp_err_t err = ledc_set_freq(LEDC_LOW_SPEED_MODE, LEDC_TIMER_0, frequency);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC set freq failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
err = ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, BUZZER_DUTY_50_PERCENT);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC set duty failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
err = ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC update duty failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
if (duration > 0) {
|
|
vTaskDelay(pdMS_TO_TICKS(duration));
|
|
toneOff();
|
|
}
|
|
}
|
|
|
|
void PaperS3Power::toneOff() {
|
|
if (!buzzerInitialized) {
|
|
LOG_I(TAG, "Buzzer not initialized");
|
|
return;
|
|
}
|
|
|
|
esp_err_t err = ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC set duty failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
|
|
err = ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0);
|
|
if (err != ESP_OK) {
|
|
LOG_E(TAG, "LEDC update duty failed: %s", esp_err_to_name(err));
|
|
return;
|
|
}
|
|
}
|
|
|
|
void PaperS3Power::powerOff() {
|
|
LOG_W(TAG, "Power-off requested");
|
|
// Note: callers are responsible for stopping the display (e.g. EPD refresh) before
|
|
// calling powerOff(). The beep sequence below (~500 ms) provides some lead time,
|
|
// but a full EPD refresh can take up to ~1500 ms. If a refresh is still in flight
|
|
// when GPIO44 cuts power, the current frame will be incomplete; the display will
|
|
// recover correctly on next boot via a full-screen clear.
|
|
|
|
if (!powerOffInitialized) {
|
|
initializePowerOff();
|
|
if (!powerOffInitialized) {
|
|
LOG_E(TAG, "Power-off failed: GPIO not initialized");
|
|
return;
|
|
}
|
|
}
|
|
|
|
//beep on
|
|
toneOn(440, 200);
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
//beep on
|
|
toneOn(440, 200);
|
|
|
|
LOG_W(TAG, "Triggering shutdown via GPIO%d (sending %d pulses)...", powerOffPin, POWER_OFF_PULSE_COUNT);
|
|
|
|
for (int i = 0; i < POWER_OFF_PULSE_COUNT; i++) {
|
|
gpio_set_level(powerOffPin, 1);
|
|
vTaskDelay(pdMS_TO_TICKS(POWER_OFF_PULSE_DURATION_MS));
|
|
gpio_set_level(powerOffPin, 0);
|
|
vTaskDelay(pdMS_TO_TICKS(POWER_OFF_PULSE_DURATION_MS));
|
|
}
|
|
|
|
gpio_set_level(powerOffPin, 1); // Final high state
|
|
|
|
LOG_W(TAG, "Shutdown signal sent. Waiting for power-off...");
|
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
|
LOG_E(TAG, "Device did not power off as expected");
|
|
}
|
|
|
|
std::shared_ptr<PowerDevice> createPower() {
|
|
ChargeFromAdcVoltage::Configuration config = {
|
|
.adcMultiplier = VOLTAGE_DIVIDER_MULTIPLIER,
|
|
.adcRefVoltage = 3.3f,
|
|
.adcChannel = VBAT_ADC_CHANNEL,
|
|
.adcConfig = {
|
|
.unit_id = ADC_UNIT_1,
|
|
.clk_src = ADC_RTC_CLK_SRC_DEFAULT,
|
|
.ulp_mode = ADC_ULP_MODE_DISABLE,
|
|
},
|
|
.adcChannelConfig = {
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
},
|
|
};
|
|
|
|
auto adc = std::make_unique<ChargeFromAdcVoltage>(config, MIN_BATTERY_VOLTAGE, MAX_BATTERY_VOLTAGE);
|
|
if (!adc->isInitialized()) {
|
|
LOG_E(TAG, "ADC initialization failed; power monitoring unavailable");
|
|
return nullptr;
|
|
}
|
|
|
|
return std::make_shared<PaperS3Power>(std::move(adc), POWER_OFF_PIN);
|
|
}
|