#include "power_manager.h"
|
#include "esp_sleep.h"
|
#include "driver/rtc_io.h"
|
#include "esp_log.h"
|
#include "config.h"
|
#include <esp_sleep.h>
|
#include "esp_log.h"
|
#include "settings.h"
|
|
#define TAG "PowerManager"
|
|
static QueueHandle_t gpio_evt_queue = NULL;
|
uint16_t battCnt;//闪灯次数
|
int battLife = 70; //电量
|
|
// 中断服务程序
|
static void IRAM_ATTR batt_mon_isr_handler(void* arg) {
|
uint32_t gpio_num = (uint32_t) arg;
|
xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
|
}
|
|
// 添加任务处理函数
|
static void batt_mon_task(void* arg) {
|
uint32_t io_num;
|
while(1) {
|
if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
|
battCnt++;
|
}
|
}
|
}
|
|
static void calBattLife() {
|
// 计算电量
|
battLife = battCnt;
|
|
if (battLife > 100){
|
battLife = 100;
|
}
|
// ESP_LOGI(TAG, "Battery life:%d", (int)battLife);
|
// 重置计数器
|
battCnt = 0;
|
}
|
|
PowerManager::PowerManager(){
|
m_bt_task_handle = nullptr;
|
bt_link_callback_ = nullptr;
|
}
|
|
void PowerManager::Initialize(){
|
// 初始化5V控制引脚
|
gpio_config_t io_conf_5v = {
|
.pin_bit_mask = 1<<BOOT_5V_PIN,
|
.mode = GPIO_MODE_OUTPUT,
|
.pull_up_en = GPIO_PULLUP_ENABLE,
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
.intr_type = GPIO_INTR_DISABLE,
|
};
|
ESP_ERROR_CHECK(gpio_config(&io_conf_5v));
|
|
// 初始化4G控制引脚
|
gpio_config_t io_conf_4g = {
|
.pin_bit_mask = (1<<BOOT_4G5V_PIN) | (1<<BOOT_4GEN_PIN),
|
.mode = GPIO_MODE_OUTPUT,
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
.pull_down_en = GPIO_PULLDOWN_ENABLE,
|
.intr_type = GPIO_INTR_DISABLE,
|
};
|
ESP_ERROR_CHECK(gpio_config(&io_conf_4g));
|
|
// 电池电量监测引脚配置
|
gpio_config_t io_conf_batt_mon = {
|
.pin_bit_mask = 1ull<<MON_BATT_PIN,
|
.mode = GPIO_MODE_INPUT,
|
.pull_up_en = GPIO_PULLUP_ENABLE,
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
.intr_type = GPIO_INTR_POSEDGE,
|
};
|
ESP_ERROR_CHECK(gpio_config(&io_conf_batt_mon));
|
// 创建电量GPIO事件队列
|
gpio_evt_queue = xQueueCreate(2, sizeof(uint32_t));
|
// 安装电量GPIO ISR服务
|
ESP_ERROR_CHECK(gpio_install_isr_service(0));
|
// 添加中断处理
|
ESP_ERROR_CHECK(gpio_isr_handler_add(MON_BATT_PIN, batt_mon_isr_handler, (void*)MON_BATT_PIN));
|
// 创建监控任务
|
xTaskCreate(&batt_mon_task, "batt_mon_task", 1024, NULL, 10, NULL);
|
|
// 初始化监测引脚
|
gpio_config_t mon_conf = {};
|
mon_conf.pin_bit_mask = 1ULL << MON_USB_PIN;
|
mon_conf.mode = GPIO_MODE_INPUT;
|
mon_conf.pull_up_en = GPIO_PULLUP_DISABLE;
|
mon_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
|
gpio_config(&mon_conf);
|
|
// 创建电池电量检查定时器
|
esp_timer_create_args_t timer_args = {
|
.callback = [](void* arg) {
|
PowerManager* self = static_cast<PowerManager*>(arg);
|
self->CheckBatteryStatus();
|
},
|
.arg = this,
|
.dispatch_method = ESP_TIMER_TASK,
|
.name = "battery_check_timer",
|
.skip_unhandled_events = true,
|
};
|
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &timer_handle_));
|
ESP_ERROR_CHECK(esp_timer_start_periodic(timer_handle_, 1000000));
|
}
|
|
void PowerManager::CheckBatteryStatus(){
|
call_count_++;
|
if(call_count_ >= MON_BATT_CNT) {
|
calBattLife();
|
call_count_ = 0;
|
}
|
|
bool new_charging_status = IsCharging();
|
if (new_charging_status != is_charging_) {
|
is_charging_ = new_charging_status;
|
if (charging_callback_) {
|
charging_callback_(is_charging_);
|
}
|
}
|
|
bool new_discharging_status = IsDischarging();
|
if (new_discharging_status != is_discharging_) {
|
is_discharging_ = new_discharging_status;
|
if (discharging_callback_) {
|
discharging_callback_(is_discharging_);
|
}
|
}
|
}
|
|
bool PowerManager::IsCharging() {
|
return gpio_get_level(MON_USB_PIN) == 1 && !IsChargingDone();
|
}
|
|
bool PowerManager::IsDischarging() {
|
return gpio_get_level(MON_USB_PIN) == 0;
|
}
|
|
bool PowerManager::IsChargingDone() {
|
return battLife >= 95;
|
}
|
|
int PowerManager::GetBatteryLevel() {
|
return battLife;
|
}
|
|
void PowerManager::OnChargingStatusChanged(std::function<void(bool)> callback) {
|
charging_callback_ = callback;
|
}
|
|
void PowerManager::OnChargingStatusDisChanged(std::function<void(bool)> callback) {
|
discharging_callback_ = callback;
|
}
|
|
void PowerManager::CheckStartup() {
|
Settings settings1("board", true);
|
if(settings1.GetInt("sleep_flag", 0) > 0){
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
if( gpio_get_level(BOOT_BUTTON_PIN) == 1) {
|
Sleep(); //进入休眠模式
|
}else{
|
settings1.SetInt("sleep_flag", 0);
|
}
|
}
|
}
|
|
void PowerManager::Start5V() {
|
gpio_set_level(BOOT_5V_PIN, 1);
|
}
|
|
void PowerManager::Shutdown5V() {
|
gpio_set_level(BOOT_5V_PIN, 0);
|
}
|
|
void PowerManager::Start4G() {
|
gpio_set_level(BOOT_4G5V_PIN, 1);
|
}
|
|
void PowerManager::Shutdown4G() {
|
gpio_set_level(BOOT_4G5V_PIN, 0);
|
gpio_set_level(ML307_RX_PIN,1);
|
gpio_set_level(ML307_TX_PIN,1);
|
}
|
|
void PowerManager::Enable4G() {
|
gpio_set_level(BOOT_4GEN_PIN, 1);
|
}
|
|
void PowerManager::Disable4G() {
|
gpio_set_level(BOOT_4GEN_PIN, 0);
|
}
|
|
void PowerManager::Sleep() {
|
ESP_LOGI(TAG, "Entering deep sleep");
|
Settings settings("board", true);
|
settings.SetInt("sleep_flag", 1);
|
Disable4G();
|
Shutdown4G();
|
Shutdown5V();
|
|
if(gpio_evt_queue) {
|
vQueueDelete(gpio_evt_queue);
|
gpio_evt_queue = NULL;
|
}
|
ESP_ERROR_CHECK(gpio_isr_handler_remove(BOOT_BUTTON_PIN));
|
ESP_ERROR_CHECK(esp_sleep_enable_ext0_wakeup(BOOT_BUTTON_PIN, 0));
|
ESP_ERROR_CHECK(rtc_gpio_pulldown_dis(BOOT_BUTTON_PIN));
|
ESP_ERROR_CHECK(rtc_gpio_pullup_en(BOOT_BUTTON_PIN));
|
esp_deep_sleep_start();
|
}
|
|
void PowerManager::InitializeBtModul() {
|
if (MON_BTLINK_PIN == GPIO_NUM_NC) {
|
ESP_LOGW(TAG, "MON_BTLINK_PIN not configured, skipping GPIO polling setup");
|
return;
|
}
|
|
gpio_config_t io_conf = {};
|
io_conf.intr_type = GPIO_INTR_DISABLE;
|
io_conf.pin_bit_mask = (1ULL << MON_BTLINK_PIN);
|
io_conf.mode = GPIO_MODE_INPUT;
|
io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
|
io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
|
if (gpio_config(&io_conf) != ESP_OK) {
|
ESP_LOGE(TAG, "Failed to configure GPIO %d", MON_BTLINK_PIN);
|
return;
|
}
|
BaseType_t ret = xTaskCreate(BtTask, "bt_task", 2048, this, 10, &m_bt_task_handle);
|
if (ret != pdPASS) {
|
ESP_LOGE(TAG, "Failed to create BT task");
|
return;
|
}
|
}
|
|
void PowerManager::DeinitBtModul() {
|
if (MON_BTLINK_PIN == GPIO_NUM_NC) {
|
return;
|
}
|
|
if (m_bt_task_handle != nullptr) {
|
vTaskDelete(m_bt_task_handle);
|
m_bt_task_handle = nullptr;
|
}
|
|
gpio_reset_pin(MON_BTLINK_PIN);
|
}
|
|
void PowerManager::BtTask(void *arg) {
|
PowerManager *instance = static_cast<PowerManager *>(arg);
|
int last_level = -1;
|
for (;;) {
|
vTaskDelay(pdMS_TO_TICKS(100));
|
int level = gpio_get_level(MON_BTLINK_PIN);
|
if (level != last_level) {
|
last_level = level;
|
if (level == 1) {
|
ESP_LOGI(TAG, "BTLINK %d high - BT connected", MON_BTLINK_PIN);
|
if (instance->bt_link_callback_) {
|
instance->bt_link_callback_(true);
|
}
|
} else {
|
ESP_LOGI(TAG, "BTLINK %d low - BT disconnected", MON_BTLINK_PIN);
|
if (instance->bt_link_callback_) {
|
instance->bt_link_callback_(false);
|
}
|
}
|
}
|
}
|
vTaskDelete(NULL);
|
}
|
|
void PowerManager::OnBtLinkStatusChanged(std::function<void(bool)> callback) {
|
bt_link_callback_ = callback;
|
}
|
