Chapter 65: BLE Battery Service Implementation

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/timers.h"
#include "esp_system.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_bt.h"
#include "esp_gap_ble_api.h"
#include "esp_gatts_api.h"
#include "esp_bt_main.h"
#include "esp_bt_defs.h"
#include "esp_gatt_common_api.h"

#define BAS_TAG "BAS_SERVER"
#define DEVICE_NAME "ESP32_BAS_Device"

// Battery Service
#define GATTS_SERVICE_UUID_BAS          0x180F
// Battery Level Characteristic
#define GATTS_CHAR_UUID_BATTERY_LEVEL   0x2A19
// Characteristic Presentation Format Descriptor
#define GATTS_DESCR_UUID_CHAR_FORMAT    0x2904
// Client Characteristic Configuration Descriptor
#define GATTS_DESCR_UUID_CCC            0x2902


#define PROFILE_NUM 1
#define PROFILE_BAS_APP_ID 0
#define SVC_INST_ID 0 // Service instance ID

// Attribute handles
enum {
    BAS_IDX_SVC,                // Battery Service Declaration

    BAS_IDX_BATT_LVL_CHAR,      // Battery Level Characteristic Declaration
    BAS_IDX_BATT_LVL_VAL,       // Battery Level Characteristic Value
    BAS_IDX_BATT_LVL_CCC,       // Battery Level CCCD
    BAS_IDX_BATT_LVL_PRES_FMT,  // Battery Level Presentation Format Descriptor

    BAS_IDX_NB,
};
uint16_t bas_handle_table[BAS_IDX_NB];

// Current battery level (0-100%)
static uint8_t current_battery_level = 100;
// Timer to simulate battery discharge
TimerHandle_t battery_sim_timer;

// Client connection information
typedef struct {
    esp_gatt_if_t gatt_if;
    uint16_t conn_id;
    bool notifications_enabled;
} client_conn_info_t;
static client_conn_info_t connected_client = {0}; // Simplified for one client

// Characteristic Presentation Format value for Battery Level (percentage)
static const uint8_t batt_level_pres_fmt[7] = {
    0x04, // Format: uint8
    0x00, // Exponent: 0
    0xAD, // Unit: Percentage (0x27AD LSB first)
    0x27, // Unit: Percentage (MSB)
    0x01, // Namespace: Bluetooth SIG Assigned Numbers
    0x00, // Description: LSB
    0x00  // Description: MSB
};

// Advertising parameters
static esp_ble_adv_params_t adv_params = {
    .adv_int_min        = 0x20,
    .adv_int_max        = 0x40,
    .adv_type           = ADV_TYPE_IND,
    .own_addr_type      = BLE_ADDR_TYPE_PUBLIC,
    .channel_map        = ADV_CHNL_ALL,
    .adv_filter_policy  = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
};

// Advertising data
static esp_ble_adv_data_t adv_data = {
    .set_scan_rsp        = false,
    .include_name        = true,
    .include_txpower     = true,
    .min_interval        = 0x0006, 
    .max_interval        = 0x0010,
    .appearance          = 0x00,
    .flag                = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
};

// Function to send battery level notification
static void send_battery_level_notification(void) {
    if (connected_client.conn_id != 0 && connected_client.notifications_enabled) {
        ESP_LOGI(BAS_TAG, "Sending battery level notification: %d%%", current_battery_level);
        esp_ble_gatts_send_indicate(connected_client.gatt_if,
                                    connected_client.conn_id,
                                    bas_handle_table[BAS_IDX_BATT_LVL_VAL],
                                    sizeof(current_battery_level),
                                    &current_battery_level,
                                    false); // false for notification, true for indication
    }
}

// Timer callback to simulate battery discharge
void battery_simulation_timer_cb(TimerHandle_t xTimer) {
    if (current_battery_level > 0) {
        current_battery_level--;
    } else {
        current_battery_level = 100; // Reset for demo
    }
    ESP_LOGI(BAS_TAG, "Simulated Battery Level: %d%%", current_battery_level);
    send_battery_level_notification();
}


static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param) {
    switch (event) {
    case ESP_GATTS_REG_EVT:
        ESP_LOGI(BAS_TAG, "REG_EVT, status %d, app_id %d, gatts_if %d", param->reg.status, param->reg.app_id, gatts_if);
        if (param->reg.status == ESP_GATT_OK) {
            connected_client.gatt_if = gatts_if; // Store for this profile
        } else {
            ESP_LOGE(BAS_TAG, "GATTS App registration failed"); return;
        }

        esp_err_t set_dev_name_ret = esp_ble_gap_set_device_name(DEVICE_NAME);
        if (set_dev_name_ret){ ESP_LOGE(BAS_TAG, "set device name failed, error code = %x", set_dev_name_ret); }
        
        esp_err_t adv_config_ret = esp_ble_gap_config_adv_data(&adv_data);
        if (adv_config_ret){ ESP_LOGE(BAS_TAG, "config adv data failed, error code = %x", adv_config_ret); }

        // Create Battery Service
        esp_gatt_srvc_id_t service_id;
        service_id.is_primary = true;
        service_id.id.uuid.len = ESP_UUID_LEN_16;
        service_id.id.uuid.uuid.uuid16 = GATTS_SERVICE_UUID_BAS;

        esp_ble_gatts_create_service(gatts_if, &service_id, BAS_IDX_NB); // BAS_IDX_NB is num_handles
        break;

    case ESP_GATTS_CREATE_EVT:
        ESP_LOGI(BAS_TAG, "CREATE_SVC_EVT, status %d, service_handle %d", param->create.status, param->create.service_handle);
        if (param->create.status == ESP_GATT_OK) {
            bas_handle_table[BAS_IDX_SVC] = param->create.service_handle;

            // Add Battery Level Characteristic
            esp_bt_uuid_t char_uuid;
            char_uuid.len = ESP_UUID_LEN_16;
            char_uuid.uuid.uuid16 = GATTS_CHAR_UUID_BATTERY_LEVEL;

            esp_attr_value_t char_val = {
                .attr_max_len = sizeof(current_battery_level),
                .attr_len     = sizeof(current_battery_level),
                .attr_value   = &current_battery_level, // Initial value
            };
            // Properties: Read + Notify. Permissions: Read.
            esp_ble_gatts_add_char(param->create.service_handle, &char_uuid,
                                   ESP_GATT_PERM_READ,
                                   ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_NOTIFY,
                                   &char_val, NULL); // Auto response for read
        }
        break;

    case ESP_GATTS_ADD_CHAR_EVT:
        ESP_LOGI(BAS_TAG, "ADD_CHAR_EVT, status %d, attr_handle %d, service_handle %d, char_uuid %04x",
                 param->add_char.status, param->add_char.attr_handle, param->add_char.service_handle, param->add_char.char_uuid.uuid.uuid16);
        if (param->add_char.status == ESP_GATT_OK) {
            if (param->add_char.char_uuid.uuid.uuid16 == GATTS_CHAR_UUID_BATTERY_LEVEL) {
                bas_handle_table[BAS_IDX_BATT_LVL_CHAR] = param->add_char.attr_handle; // Char decl handle
                // The value handle is typically attr_handle + 1 if no other descriptors are between decl and value
                // However, ESP-IDF examples often use the attr_handle from ADD_CHAR_EVT as the value handle for notifications
                // For clarity, let's assume ADD_CHAR_EVT's attr_handle IS the value handle for simple cases
                // or more robustly, you'd use the handle from a separate ADD_CHAR_VAL event if that existed,
                // or manage handles more explicitly if you build the table manually.
                // For esp_ble_gatts_send_indicate, the value handle is needed.
                // The stack creates the value attribute implicitly. The handle from ADD_CHAR_EVT is for the declaration.
                // Let's assume the value handle is param->add_char.attr_handle + 1 for now.
                // A more robust way is to query handles or use a predefined table structure.
                // For simplicity, we'll use a fixed offset logic for this example,
                // assuming value is right after declaration.
                bas_handle_table[BAS_IDX_BATT_LVL_VAL] = param->add_char.attr_handle; // This is usually the characteristic declaration handle
                                                                                       // The actual value handle is typically +1

                // Add CCCD for Battery Level
                esp_bt_uuid_t cccd_uuid;
                cccd_uuid.len = ESP_UUID_LEN_16;
                cccd_uuid.uuid.uuid16 = GATTS_DESCR_UUID_CCC;
                esp_attr_value_t cccd_val = {
                    .attr_max_len = 2, // CCCD is 2 bytes
                    .attr_len     = 2,
                    .attr_value   = (uint8_t[]){0x00, 0x00} // Initial: notifications disabled
                };
                esp_ble_gatts_add_char_descr(param->add_char.service_handle, &cccd_uuid,
                                             ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE,
                                             &cccd_val, NULL); // Auto response for read/write
            }
        }
        break;

    case ESP_GATTS_ADD_CHAR_DESCR_EVT:
        ESP_LOGI(BAS_TAG, "ADD_DESCR_EVT, status %d, attr_handle %d, service_handle %d, descr_uuid %04x",
                 param->add_char_descr.status, param->add_char_descr.attr_handle, 
                 param->add_char_descr.service_handle, param->add_char_descr.descr_uuid.uuid.uuid16);
        if (param->add_char_descr.status == ESP_GATT_OK) {
            if (param->add_char_descr.descr_uuid.uuid.uuid16 == GATTS_DESCR_UUID_CCC) {
                bas_handle_table[BAS_IDX_BATT_LVL_CCC] = param->add_char_descr.attr_handle;

                // Add Characteristic Presentation Format Descriptor for Battery Level
                esp_bt_uuid_t pres_fmt_uuid;
                pres_fmt_uuid.len = ESP_UUID_LEN_16;
                pres_fmt_uuid.uuid.uuid16 = GATTS_DESCR_UUID_CHAR_FORMAT;
                esp_attr_value_t pres_fmt_val = {
                    .attr_max_len = sizeof(batt_level_pres_fmt),
                    .attr_len     = sizeof(batt_level_pres_fmt),
                    .attr_value   = (uint8_t*)batt_level_pres_fmt,
                };
                esp_ble_gatts_add_char_descr(param->add_char_descr.service_handle, &pres_fmt_uuid,
                                             ESP_GATT_PERM_READ,
                                             &pres_fmt_val, NULL); // Auto response
            } else if (param->add_char_descr.descr_uuid.uuid.uuid16 == GATTS_DESCR_UUID_CHAR_FORMAT) {
                bas_handle_table[BAS_IDX_BATT_LVL_PRES_FMT] = param->add_char_descr.attr_handle;
                // All attributes for BAS added, now start the service
                esp_ble_gatts_start_service(bas_handle_table[BAS_IDX_SVC]);
            }
        }
        break;

    case ESP_GATTS_START_EVT:
        ESP_LOGI(BAS_TAG, "SERVICE_START_EVT, status %d, service_handle %d", param->start.status, param->start.service_handle);
        break;

    case ESP_GATTS_CONNECT_EVT:
        ESP_LOGI(BAS_TAG, "CONNECT_EVT, conn_id %d, remote %02x:%02x:%02x:%02x:%02x:%02x:, gatts_if %d",
                 param->connect.conn_id,
                 param->connect.remote_bda[0], param->connect.remote_bda[1], param->connect.remote_bda[2],
                 param->connect.remote_bda[3], param->connect.remote_bda[4], param->connect.remote_bda[5],
                 gatts_if);
        connected_client.conn_id = param->connect.conn_id;
        connected_client.gatt_if = gatts_if; // Update gatt_if for this connection
        connected_client.notifications_enabled = false;
        // Stop advertising on connection if desired, or allow multiple connections
        // esp_ble_gap_stop_advertising();
        break;

    case ESP_GATTS_DISCONNECT_EVT:
        ESP_LOGI(BAS_TAG, "DISCONNECT_EVT, conn_id %d, reason %d", param->disconnect.conn_id, param->disconnect.reason);
        connected_client.conn_id = 0;
        connected_client.notifications_enabled = false;
        // Restart advertising to allow new connections
        esp_ble_gap_start_advertising(&adv_params);
        break;

    case ESP_GATTS_READ_EVT:
        ESP_LOGI(BAS_TAG, "READ_EVT, conn_id %d, trans_id %" PRIu32 ", handle %d", 
                 param->read.conn_id, param->read.trans_id, param->read.handle);
        // For Battery Level value, if auto_rsp is not used, respond here:
        if (param->read.handle == bas_handle_table[BAS_IDX_BATT_LVL_VAL]) {
            // This example uses auto_rsp for the value, so stack handles it.
            // If manual:
            // esp_gatt_rsp_t rsp;
            // memset(&rsp, 0, sizeof(esp_gatt_rsp_t));
            // rsp.attr_value.handle = param->read.handle;
            // rsp.attr_value.len = sizeof(current_battery_level);
            // rsp.attr_value.value[0] = current_battery_level;
            // esp_ble_gatts_send_response(gatts_if, param->read.conn_id, param->read.trans_id, ESP_GATT_OK, &rsp);
        }
        break;

    case ESP_GATTS_WRITE_EVT:
        ESP_LOGI(BAS_TAG, "WRITE_EVT, conn_id %d, trans_id %" PRIu32 ", handle %d, len %d, value:",
                 param->write.conn_id, param->write.trans_id, param->write.handle, param->write.len);
        esp_log_buffer_hex(BAS_TAG, param->write.value, param->write.len);

        if (param->write.handle == bas_handle_table[BAS_IDX_BATT_LVL_CCC] && param->write.len == 2) {
            uint16_t cccd_val = (param->write.value[1] << 8) | param->write.value[0];
            if (cccd_val == 0x0001) {
                ESP_LOGI(BAS_TAG, "Notifications ENABLED for Battery Level");
                connected_client.notifications_enabled = true;
                // Send initial notification
                send_battery_level_notification();
            } else if (cccd_val == 0x0000) {
                ESP_LOGI(BAS_TAG, "Notifications DISABLED for Battery Level");
                connected_client.notifications_enabled = false;
            } else {
                ESP_LOGE(BAS_TAG, "Invalid CCCD value: 0x%04x", cccd_val);
            }
        }
        // Send response if needed (this example uses auto_rsp for CCCD)
        if (param->write.need_rsp) {
             esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, NULL);
        }
        break;
    
    case ESP_GATTS_CONF_EVT: // Confirmation for indication
        ESP_LOGI(BAS_TAG, "CONF_EVT, status %d, handle %d", param->conf.status, param->conf.handle);
        break;

    default:
        break;
    }
}

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
    switch (event) {
    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
        ESP_LOGI(BAS_TAG, "Advertising data set complete");
        esp_ble_gap_start_advertising(&adv_params);
        break;
    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
        if (param->adv_start_cmpl.status == ESP_BT_STATUS_SUCCESS) {
            ESP_LOGI(BAS_TAG, "Advertising started successfully");
        } else {
            ESP_LOGE(BAS_TAG, "Advertising start failed, error status = %x", param->adv_start_cmpl.status);
        }
        break;
    // ... other GAP events ...
    default:
        break;
    }
}


void app_main(void) {
    esp_err_t ret;

    ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) { ESP_LOGE(BAS_TAG, "Initialize controller failed: %s", esp_err_to_name(ret)); return; }
    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret) { ESP_LOGE(BAS_TAG, "Enable controller failed: %s", esp_err_to_name(ret)); return; }
    ret = esp_bluedroid_init();
    if (ret) { ESP_LOGE(BAS_TAG, "Init Bluedroid failed: %s", esp_err_to_name(ret)); return; }
    ret = esp_bluedroid_enable();
    if (ret) { ESP_LOGE(BAS_TAG, "Enable Bluedroid failed: %s", esp_err_to_name(ret)); return; }

    ret = esp_ble_gatts_register_callback(gatts_profile_event_handler);
    if (ret) { ESP_LOGE(BAS_TAG, "GATTS register error: %s", esp_err_to_name(ret)); return; }
    ret = esp_ble_gap_register_callback(gap_event_handler);
    if (ret) { ESP_LOGE(BAS_TAG, "GAP register error: %s", esp_err_to_name(ret)); return; }
    
    ret = esp_ble_gatts_app_register(PROFILE_BAS_APP_ID);
    if (ret) { ESP_LOGE(BAS_TAG, "GATTS app register error: %s", esp_err_to_name(ret)); return; }

    // Create and start battery simulation timer (e.g., every 5 seconds)
    battery_sim_timer = xTimerCreate("BatterySimTimer", pdMS_TO_TICKS(5000), pdTRUE, (void *)0, battery_simulation_timer_cb);
    if (battery_sim_timer == NULL || xTimerStart(battery_sim_timer, 0) != pdPASS) {
        ESP_LOGE(BAS_TAG, "Failed to start battery simulation timer");
    } else {
        ESP_LOGI(BAS_TAG, "Battery simulation timer started.");
    }
    
    ESP_LOGI(BAS_TAG, "BAS Server Initialized. Advertising will start after GATTS registration.");
}