#include <driver/gpio.h>
|
#include <driver/i2c_master.h>
|
#include <esp_adc/adc_cali.h>
|
#include <esp_adc/adc_cali_scheme.h>
|
#include <esp_adc/adc_oneshot.h>
|
#include <esp_err.h>
|
#include <esp_log.h>
|
#include <esp_timer.h>
|
|
#include "esp_idf_version.h"
|
#include "led/circular_strip.h"
|
#include "sdkconfig.h"
|
|
#include "application.h"
|
#include "button.h"
|
#include "codecs/es8311_audio_codec.h"
|
#include "config.h"
|
#include "sleep_timer.h"
|
#include "wifi_board.h"
|
|
#ifdef IMU_INT_GPIO
|
#include <esp_sleep.h>
|
|
#include "bmi270_api.h"
|
#include "i2c_bus.h"
|
#endif // IMU_INT_GPIO
|
|
#ifdef CONFIG_IDF_TARGET_ESP32S3
|
#define TAG "esp_spot_s3"
|
#elif defined(CONFIG_IDF_TARGET_ESP32C5)
|
#define TAG "esp_spot_c5"
|
#else // target
|
#error "Unsupported target"
|
#endif // target
|
|
#ifdef IMU_INT_GPIO
|
namespace Bmi270Imu {
|
|
static bmi270_handle_t bmi_handle_ = nullptr;
|
|
esp_err_t Initialize(i2c_bus_handle_t i2c_bus, uint8_t addr = BMI270_I2C_ADDRESS) {
|
if (bmi_handle_) {
|
return ESP_OK;
|
}
|
|
if (!i2c_bus) {
|
ESP_LOGE(TAG, "Invalid I2C bus for BMI270");
|
return ESP_ERR_INVALID_ARG;
|
}
|
|
esp_err_t ret = bmi270_sensor_create(i2c_bus, &bmi_handle_, bmi270_config_file,
|
BMI2_GYRO_CROSS_SENS_ENABLE | BMI2_CRT_RTOSK_ENABLE);
|
if (ret != ESP_OK || !bmi_handle_) {
|
ESP_LOGE(TAG, "BMI270 create failed: %s", esp_err_to_name(ret));
|
return ret == ESP_OK ? ESP_FAIL : ret;
|
}
|
ESP_LOGI(TAG, "BMI270 initialized");
|
return ESP_OK;
|
}
|
|
// Only used for deep sleep wakeup with wrist gesture interrupt
|
esp_err_t EnableImuIntForWakeup() {
|
if (!bmi_handle_) {
|
return ESP_ERR_INVALID_STATE;
|
}
|
|
const uint8_t sens_list[] = {BMI2_ACCEL, BMI2_WRIST_GESTURE};
|
int8_t rslt = bmi270_sensor_enable(sens_list, 2, bmi_handle_);
|
if (rslt != BMI2_OK) {
|
ESP_LOGE(TAG, "Failed to enable BMI270 sensors: %d", rslt);
|
return ESP_FAIL;
|
}
|
|
struct bmi2_sens_config config = {.type = BMI2_WRIST_GESTURE};
|
rslt = bmi270_get_sensor_config(&config, 1, bmi_handle_);
|
if (rslt != BMI2_OK) {
|
ESP_LOGE(TAG, "Failed to get wrist gesture config: %d", rslt);
|
return ESP_FAIL;
|
}
|
config.cfg.wrist_gest.wearable_arm = BMI2_ARM_RIGHT;
|
rslt = bmi270_set_sensor_config(&config, 1, bmi_handle_);
|
if (rslt != BMI2_OK) {
|
ESP_LOGE(TAG, "Failed to set wrist gesture config: %d", rslt);
|
return ESP_FAIL;
|
}
|
|
struct bmi2_int_pin_config pin_config = {};
|
pin_config.pin_type = BMI2_INT1;
|
pin_config.pin_cfg[0].input_en = BMI2_INT_INPUT_DISABLE;
|
pin_config.pin_cfg[0].lvl = BMI2_INT_ACTIVE_HIGH;
|
pin_config.pin_cfg[0].od = BMI2_INT_PUSH_PULL;
|
pin_config.pin_cfg[0].output_en = BMI2_INT_OUTPUT_ENABLE;
|
pin_config.int_latch = BMI2_INT_NON_LATCH;
|
rslt = bmi2_set_int_pin_config(&pin_config, bmi_handle_);
|
if (rslt != BMI2_OK) {
|
ESP_LOGE(TAG, "Failed to set BMI270 INT pin: %d", rslt);
|
return ESP_FAIL;
|
}
|
|
struct bmi2_sens_int_config int_config = {.type = BMI2_WRIST_GESTURE, .hw_int_pin = BMI2_INT1};
|
rslt = bmi270_map_feat_int(&int_config, 1, bmi_handle_);
|
if (rslt != BMI2_OK) {
|
ESP_LOGE(TAG, "Failed to map BMI270 interrupt: %d", rslt);
|
return ESP_FAIL;
|
}
|
|
return ESP_OK;
|
}
|
|
} // namespace Bmi270Imu
|
|
#endif // IMU_INT_GPIO
|
|
class EspSpot : public WifiBoard {
|
private:
|
i2c_master_bus_handle_t i2c_bus_ = nullptr;
|
Button boot_button_;
|
Button key_button_;
|
adc_oneshot_unit_handle_t adc1_handle_;
|
adc_cali_handle_t adc1_cali_handle_;
|
bool adc_calibration_lock_ = false;
|
bool key_long_pressed_ = false;
|
int64_t last_key_press_time = 0;
|
SleepTimer* sleep_timer_ = nullptr;
|
#ifdef IMU_INT_GPIO
|
i2c_bus_handle_t shared_i2c_bus_handle_ = nullptr;
|
static constexpr int kDeepSleepTimeoutSeconds = 10 * 60; // 10 minutes
|
bool imu_ready_ = false;
|
#endif
|
|
#ifdef IMU_INT_GPIO
|
void InitializeI2c() {
|
// Initialize I2C peripheral
|
i2c_config_t i2c_bus_cfg = {
|
.mode = I2C_MODE_MASTER,
|
.sda_io_num = AUDIO_CODEC_I2C_SDA_PIN,
|
.scl_io_num = AUDIO_CODEC_I2C_SCL_PIN,
|
.sda_pullup_en = true,
|
.scl_pullup_en = true,
|
.master =
|
{
|
.clk_speed = I2C_MASTER_FREQ_HZ,
|
},
|
.clk_flags = 0,
|
};
|
shared_i2c_bus_handle_ = i2c_bus_create(I2C_NUM_0, &i2c_bus_cfg);
|
if (!shared_i2c_bus_handle_) {
|
ESP_LOGE(TAG, "Failed to create shared I2C bus");
|
ESP_ERROR_CHECK(ESP_FAIL);
|
}
|
|
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0) && !CONFIG_I2C_BUS_BACKWARD_CONFIG
|
i2c_bus_ = i2c_bus_get_internal_bus_handle(shared_i2c_bus_handle_);
|
#else
|
#error "ESP-Spot board requires i2c_bus_get_internal_bus_handle() support"
|
#endif
|
if (!i2c_bus_) {
|
ESP_LOGE(TAG, "Failed to obtain master bus handle");
|
ESP_ERROR_CHECK(ESP_FAIL);
|
}
|
|
esp_err_t imu_ret = Bmi270Imu::Initialize(shared_i2c_bus_handle_);
|
if (imu_ret != ESP_OK) {
|
ESP_LOGW(TAG, "BMI270 initialization failed, deep sleep disabled (%s)", esp_err_to_name(imu_ret));
|
} else {
|
imu_ready_ = true;
|
}
|
}
|
#else
|
void InitializeI2c() {
|
i2c_master_bus_config_t i2c_bus_cfg = {
|
.i2c_port = I2C_NUM_0,
|
.sda_io_num = AUDIO_CODEC_I2C_SDA_PIN,
|
.scl_io_num = AUDIO_CODEC_I2C_SCL_PIN,
|
.clk_source = I2C_CLK_SRC_DEFAULT,
|
.glitch_ignore_cnt = 7,
|
.intr_priority = 0,
|
.trans_queue_depth = 0,
|
.flags =
|
{
|
.enable_internal_pullup = 1,
|
},
|
};
|
ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &i2c_bus_));
|
}
|
#endif // IMU_INT_GPIO
|
|
void InitializeADC() {
|
adc_oneshot_unit_init_cfg_t init_config1 = {.unit_id = ADC_UNIT_1};
|
ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle_));
|
|
adc_oneshot_chan_cfg_t chan_config = {
|
.atten = ADC_ATTEN,
|
.bitwidth = ADC_WIDTH,
|
};
|
ESP_ERROR_CHECK(adc_oneshot_config_channel(adc1_handle_, VBAT_ADC_CHANNEL, &chan_config));
|
|
#ifdef ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
|
adc_cali_handle_t handle = nullptr;
|
esp_err_t ret = ESP_FAIL;
|
|
adc_cali_curve_fitting_config_t cali_config = {
|
.unit_id = ADC_UNIT_1,
|
.atten = ADC_ATTEN,
|
.bitwidth = ADC_WIDTH,
|
};
|
ret = adc_cali_create_scheme_curve_fitting(&cali_config, &handle);
|
if (ret == ESP_OK) {
|
adc_calibration_lock_ = true;
|
adc1_cali_handle_ = handle;
|
ESP_LOGI(TAG, "ADC Curve Fitting calibration succeeded");
|
}
|
#endif // ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
|
}
|
|
void InitializeButtons() {
|
boot_button_.OnClick([this]() {
|
HandleUserActivity();
|
EnterWifiConfigMode();
|
});
|
|
key_button_.OnClick([this]() {
|
HandleUserActivity();
|
auto& app = Application::GetInstance();
|
app.ToggleChatState();
|
key_long_pressed_ = false;
|
});
|
|
key_button_.OnLongPress([this]() {
|
HandleUserActivity();
|
int64_t now = esp_timer_get_time();
|
auto* led = static_cast<CircularStrip*>(this->GetLed());
|
|
if (key_long_pressed_) {
|
if ((now - last_key_press_time) < LONG_PRESS_TIMEOUT_US) {
|
ESP_LOGW(TAG, "Key button long pressed the second time within 5s, shutting down...");
|
led->SetSingleColor(0, {0, 0, 0});
|
|
gpio_hold_dis(MCU_VCC_CTL);
|
gpio_set_level(MCU_VCC_CTL, 0);
|
|
} else {
|
last_key_press_time = now;
|
BlinkGreenFor5s();
|
}
|
key_long_pressed_ = true;
|
} else {
|
ESP_LOGW(TAG, "Key button first long press! Waiting second within 5s to shutdown...");
|
last_key_press_time = now;
|
key_long_pressed_ = true;
|
|
BlinkGreenFor5s();
|
}
|
});
|
}
|
|
void InitializePowerCtl() {
|
InitializeGPIO();
|
|
gpio_set_level(MCU_VCC_CTL, 1);
|
gpio_hold_en(MCU_VCC_CTL);
|
|
gpio_set_level(PERP_VCC_CTL, 1);
|
gpio_hold_en(PERP_VCC_CTL);
|
}
|
|
void InitializeGPIO() {
|
gpio_config_t io_pa = {.pin_bit_mask = (1ULL << AUDIO_CODEC_PA_PIN),
|
.mode = GPIO_MODE_OUTPUT,
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
.intr_type = GPIO_INTR_DISABLE};
|
gpio_config(&io_pa);
|
gpio_set_level(AUDIO_CODEC_PA_PIN, 0);
|
|
gpio_config_t io_conf_1 = {.pin_bit_mask = (1ULL << MCU_VCC_CTL),
|
.mode = GPIO_MODE_OUTPUT,
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
.intr_type = GPIO_INTR_DISABLE};
|
gpio_config(&io_conf_1);
|
|
gpio_config_t io_conf_2 = {.pin_bit_mask = (1ULL << PERP_VCC_CTL),
|
.mode = GPIO_MODE_OUTPUT,
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
.intr_type = GPIO_INTR_DISABLE};
|
gpio_config(&io_conf_2);
|
|
#ifdef IMU_INT_GPIO
|
gpio_config_t io_conf_imu_int = {
|
.pin_bit_mask = (1ULL << IMU_INT_GPIO),
|
.mode = GPIO_MODE_INPUT,
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
.pull_down_en = GPIO_PULLDOWN_ENABLE,
|
.intr_type = GPIO_INTR_NEGEDGE,
|
};
|
gpio_config(&io_conf_imu_int);
|
gpio_install_isr_service(0);
|
#endif // IMU_INT_GPIO
|
}
|
|
void HandleUserActivity() {
|
if (sleep_timer_) {
|
sleep_timer_->WakeUp();
|
}
|
}
|
|
#ifdef IMU_INT_GPIO
|
void InitializePowerSaveTimer() {
|
if (!imu_ready_) {
|
ESP_LOGW(TAG, "IMU not ready, skip deep sleep timer");
|
return;
|
}
|
if (sleep_timer_) {
|
return;
|
}
|
sleep_timer_ = new SleepTimer(-1, kDeepSleepTimeoutSeconds);
|
sleep_timer_->OnEnterDeepSleepMode([this]() { EnterDeepSleep(); });
|
sleep_timer_->SetEnabled(true);
|
ESP_LOGI(TAG, "Deep sleep timer enabled, timeout=%ds", kDeepSleepTimeoutSeconds);
|
}
|
|
void EnterDeepSleep() {
|
if (!imu_ready_) {
|
ESP_LOGW(TAG, "Skip deep sleep because IMU is not ready");
|
return;
|
}
|
|
auto* led = static_cast<CircularStrip*>(GetLed());
|
if (led) {
|
led->SetSingleColor(0, {0, 0, 0});
|
}
|
|
if (Bmi270Imu::EnableImuIntForWakeup() != ESP_OK) {
|
ESP_LOGE(TAG, "IMU wakeup configuration failed, abort deep sleep");
|
return;
|
}
|
|
const uint64_t wakeup_mask = (1ULL << KEY_BUTTON_GPIO) | (1ULL << IMU_INT_GPIO);
|
ESP_ERROR_CHECK(esp_sleep_enable_ext1_wakeup(wakeup_mask, ESP_EXT1_WAKEUP_ANY_HIGH));
|
ESP_LOGI(TAG, "Entering deep sleep, waiting for key or wrist gesture");
|
esp_deep_sleep_start();
|
}
|
#endif // IMU_INT_GPIO
|
|
void BlinkGreenFor5s() {
|
auto* led = static_cast<CircularStrip*>(GetLed());
|
if (!led) {
|
return;
|
}
|
|
led->Blink({50, 25, 0}, 100);
|
|
esp_timer_create_args_t timer_args = {.callback =
|
[](void* arg) {
|
auto* self = static_cast<EspSpot*>(arg);
|
auto* led = static_cast<CircularStrip*>(self->GetLed());
|
if (led) {
|
led->SetSingleColor(0, {0, 0, 0});
|
}
|
},
|
.arg = this,
|
.dispatch_method = ESP_TIMER_TASK,
|
.name = "green_blink_timer"};
|
|
esp_timer_handle_t green_blink_timer = nullptr;
|
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &green_blink_timer));
|
ESP_ERROR_CHECK(esp_timer_start_once(green_blink_timer, LONG_PRESS_TIMEOUT_US));
|
}
|
|
public:
|
EspSpot() : boot_button_(BOOT_BUTTON_GPIO), key_button_(KEY_BUTTON_GPIO, true) {
|
InitializePowerCtl();
|
InitializeADC();
|
InitializeI2c();
|
InitializeButtons();
|
#ifdef IMU_INT_GPIO
|
InitializePowerSaveTimer();
|
#endif // IMU_INT_GPIO
|
}
|
|
virtual Led* GetLed() override {
|
static CircularStrip led(LED_GPIO, 1);
|
return &led;
|
}
|
|
virtual AudioCodec* GetAudioCodec() override {
|
static Es8311AudioCodec audio_codec(i2c_bus_, I2C_NUM_0, AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
|
AUDIO_I2S_GPIO_MCLK, AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS,
|
AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN, AUDIO_CODEC_PA_PIN,
|
AUDIO_CODEC_ES8311_ADDR, false);
|
return &audio_codec;
|
}
|
|
virtual void SetPowerSaveLevel(PowerSaveLevel level) override {
|
if (sleep_timer_) {
|
sleep_timer_->SetEnabled(level == PowerSaveLevel::LOW_POWER);
|
}
|
WifiBoard::SetPowerSaveLevel(level);
|
}
|
|
virtual bool GetBatteryLevel(int& level, bool& charging, bool& discharging) override {
|
if (!adc1_handle_) {
|
InitializeADC();
|
}
|
|
int raw_value = 0;
|
int voltage = 0;
|
|
ESP_ERROR_CHECK(adc_oneshot_read(adc1_handle_, VBAT_ADC_CHANNEL, &raw_value));
|
|
if (adc_calibration_lock_) {
|
ESP_ERROR_CHECK(adc_cali_raw_to_voltage(adc1_cali_handle_, raw_value, &voltage));
|
voltage = voltage * 3 / 2; // compensate for voltage divider
|
ESP_LOGI(TAG, "Calibrated voltage: %d mV", voltage);
|
} else {
|
ESP_LOGI(TAG, "Raw ADC value: %d", raw_value);
|
voltage = raw_value;
|
}
|
|
voltage = voltage < EMPTY_BATTERY_VOLTAGE ? EMPTY_BATTERY_VOLTAGE : voltage;
|
voltage = voltage > FULL_BATTERY_VOLTAGE ? FULL_BATTERY_VOLTAGE : voltage;
|
|
// Calculate battery level percentage
|
level = (voltage - EMPTY_BATTERY_VOLTAGE) * 100 / (FULL_BATTERY_VOLTAGE - EMPTY_BATTERY_VOLTAGE);
|
|
// ESP-Spot does not support charging detection, so we use MCU_VCC_CTL to determine charging status
|
charging = gpio_get_level(MCU_VCC_CTL);
|
discharging = !charging;
|
ESP_LOGI(TAG, "Battery Level: %d%%, Charging: %s", level, charging ? "Yes" : "No");
|
return true;
|
}
|
};
|
|
DECLARE_BOARD(EspSpot);
|
