devttl/xiaozhi-esp32
1
0
Fork 0
forked from xiaozhi/xiaozhi-esp32
Code Pull Requests Activity
Files
01a12b325f35667a72daea482ff49809ce297bc2
xiaozhi-esp32/main/boards/esp-spot/esp_spot_board.cc
laride 908c9d5708 feat: add esp-spot c5 (#1462) 
* feat: add esp-spot c5

* fix: fix table custom filename
2025-11-20 15:52:49 +08:00

438 lines
15 KiB
C++
Raw Blame History

#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"
#include "wifi_station.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();
ResetWifiConfiguration();
});
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 SetPowerSaveMode(bool enabled) override {
if (sleep_timer_) {
sleep_timer_->SetEnabled(enabled);
}
WifiBoard::SetPowerSaveMode(enabled);
}
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);
View Git Blame Copy Permalink