Services not staying in advertisements for extended period after upgrading from 1.4.0

[michaelboeding]

Services not staying in advertisements for extended period after upgrading from 1.4.0

Environment

• Chip: ESP32S3
• ESP-IDF Version:
• NimBLE Version: (upgraded FROM 1.4.0 TO Latest)
• Power Management: DFS enabled, Auto light sleep enabled

Description

After upgrading from NimBLE 1.4.0, BLE service advertisements stop appearing to scanners after running for an extended period. The issue does NOT occur on version 1.4.0 with the same configuration.

Configuration

• DFS: Enabled
• Auto light sleep: Enabled
• External 32kHz crystal: Yes/No

Expected Behavior

Services remain continuously visible in advertisements (as they do in 1.4.0)

Actual Behavior

• Advertisements work normally at startup
• After extended runtime, services disappear from scans
• Did NOT happen in version 1.4.0

Questions

• Are there known changes between 1.4.0 and current version affecting advertising with light sleep?
• Should advertising be manually restarted after sleep cycles?
• Any recommended workarounds while maintaining light sleep?

Notes

Is this a regression from 1.4.0 - same code and power settings worked fine on that version. Or a change in how the 2.0 works?

[h2zero]

I'm not aware of this issue, can you share a minimal example to reproduce it?

[michaelboeding]

Heres a stripped version of my code just to make it more clear - maybe I'm doing something wrong?

#include "BluetoothLayer.h"

static const char* TAG = "BluetoothLayer";

BluetoothLayer::BluetoothLayer(){
    ESP_LOGI(TAG, "BluetoothLayer created");
    this->setup();
}

BluetoothLayer::~BluetoothLayer(){
    if (this->server != nullptr){
        NimBLEDevice::deinit(true);
    }
}

bool BluetoothLayer::setup() {
    this->setupBluetoothServer();
    return true;
}

void BluetoothLayer::tearDown(){
    if (this->server != nullptr){
        NimBLEDevice::deinit(true);
        ESP_LOGI(TAG, "Bluetooth server deleted");
    }
}

bool BluetoothLayer::connect() {
    ESP_LOGI(TAG, "Waiting for a BLE connection...");
    return true;
}

bool BluetoothLayer::disconnect() {
    ESP_LOGI(TAG, "Disconnecting from BLE device...");
    return true;
}

bool BluetoothLayer::sendData(std::vector<uint8_t> data) {
    ESP_LOGI(TAG, "Send data fired in ble layer");
    
    if (!this->connected) {
        ESP_LOGW(TAG, "Not connected to a BLE device...data not being sent");
        return false;
    }

    uint16_t mtu = NimBLEDevice::getMTU();
    uint16_t attPayloadMax = mtu - 3;
    const uint8_t headerLen = 7;
    uint16_t maxDataSize = attPayloadMax - headerLen;

    ESP_LOGI(TAG, "MTU: %d, Max Data Size: %d", mtu, maxDataSize);

    for (size_t i = 0; i < data.size(); i += maxDataSize) {
        size_t remainingDataSize = data.size() - i;
        uint8_t actualChunkSize = static_cast<uint8_t>(std::min(remainingDataSize, static_cast<size_t>(maxDataSize)));
        
        std::vector<uint8_t> chunk(data.begin() + i, data.begin() + i + actualChunkSize);

        if (this->txCharacteristic == nullptr){
            ESP_LOGW(TAG, "TX Characteristic is null");
            return false;
        }

        this->txCharacteristic->setValue(chunk);
        this->txCharacteristic->notify(chunk.data(), chunk.size());
       
        vTaskDelay(80 / portTICK_PERIOD_MS);
    }
    
    ESP_LOGI(TAG, "All Data sent");
    return true;
}

void BluetoothLayer::setupBluetoothServer(){
    if (this->server != nullptr){
        return;
    }

    NimBLEDevice::init("ESP32_BLE");
    this->server = NimBLEDevice::createServer();
    this->server->setCallbacks(this);
    
    this->setupDeviceInfoService();
    this->setupCustomService();
    this->startAdvertising();

    this->mtuSize = NimBLEDevice::getMTU();
    ESP_LOGI(TAG, "BLE services setup complete");

    this->setDefaultPhy(BLE_GAP_LE_PHY_1M_MASK, BLE_GAP_LE_PHY_1M_MASK);
}

void BluetoothLayer::setupDeviceInfoService(){
    this->deviceInfoService = this->server->createService("180A");
    this->deviceManufacturerNameCharacteristic = this->deviceInfoService->createCharacteristic("2A29", NIMBLE_PROPERTY::READ);
    this->deviceModelNumberCharacteristic = this->deviceInfoService->createCharacteristic("2A24", NIMBLE_PROPERTY::READ);
    this->deviceSerialNumberCharacteristic = this->deviceInfoService->createCharacteristic("2A25", NIMBLE_PROPERTY::READ);
    
    this->deviceManufacturerNameCharacteristic->setValue("Manufacturer");
    this->deviceModelNumberCharacteristic->setValue("Model-1");
    this->deviceSerialNumberCharacteristic->setValue("SN12345");
    
    this->deviceInfoService->start();
}

void BluetoothLayer::setupCustomService(){
    this->customService = this->server->createService("6E400001-B5A3-F393-E0A9-E50E24DCCA9E");
    this->rxCharacteristic = this->customService->createCharacteristic("6E400002-B5A3-F393-E0A9-E50E24DCCA9E", 
                                                                        NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR);
    this->txCharacteristic = this->customService->createCharacteristic("6E400003-B5A3-F393-E0A9-E50E24DCCA9E", 
                                                                        NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY);
    
    this->rxCharacteristic->setCallbacks(this);
    this->txCharacteristic->setCallbacks(this);
    
    this->customService->start();
}

void BluetoothLayer::startAdvertising(){
    this->advertisingData = this->server->getAdvertising();
    this->advertisingData->addServiceUUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E");
    this->advertisingData->setScanResponse(true);
    this->advertisingData->setName("ESP32_BLE");
    this->advertisingData->setMinInterval(2056);
    this->advertisingData->setMaxInterval(2056);
    
    if (!this->advertisingData->start()) {
        ESP_LOGE(TAG, "Failed to start advertising");
    } else {
        ESP_LOGI(TAG, "Advertising started");
    }
}

void BluetoothLayer::stopAdvertising(){
    if (this->advertisingData != nullptr){  
        ESP_LOGI(TAG, "Stopping advertising");
        this->advertisingData->stop();
    }
}

bool BluetoothLayer::setDefaultPhy(uint8_t txPhyMask, uint8_t rxPhyMask) {
    ESP_LOGI(TAG, "Setting default PHY: TX=0x%02x, RX=0x%02x", txPhyMask, rxPhyMask);
    
    int rc = ble_gap_set_prefered_default_le_phy(txPhyMask, rxPhyMask);
    
    if (rc != 0) {
        ESP_LOGE(TAG, "Failed to set default PHY: %d", rc);
        return false;
    }
    
    ESP_LOGI(TAG, "Default PHY set successfully");
    return true;
}

bool BluetoothLayer::setConnectionPhy(uint16_t connHandle, uint8_t txPhyMask, uint8_t rxPhyMask, uint16_t phyOpts) {
    ESP_LOGI(TAG, "Setting connection PHY: handle=%d, TX=0x%02x, RX=0x%02x", connHandle, txPhyMask, rxPhyMask);
    
    int rc = ble_gap_set_prefered_le_phy(connHandle, txPhyMask, rxPhyMask, phyOpts);
    
    if (rc != 0) {
        ESP_LOGE(TAG, "Failed to set connection PHY: %d", rc);
        return false;
    }
    
    ESP_LOGI(TAG, "Connection PHY update requested");
    return true;
}

bool BluetoothLayer::getConnectionPhy(uint16_t connHandle, uint8_t *txPhy, uint8_t *rxPhy) {
    ESP_LOGI(TAG, "Reading connection PHY: handle=%d", connHandle);
    
    int rc = ble_gap_read_le_phy(connHandle, txPhy, rxPhy);
    
    if (rc != 0) {
        ESP_LOGE(TAG, "Failed to read connection PHY: %d", rc);
        return false;
    }
    
    ESP_LOGI(TAG, "Connection PHY: TX=%d, RX=%d", *txPhy, *rxPhy);
    return true;
}

void BluetoothLayer::updateBLEConnectionParams(NimBLEConnInfo& connInfo) {
    uint16_t minIntervalUnits = 12;
    uint16_t maxIntervalUnits = 24;
    uint16_t latency = 0;
    uint16_t timeoutUnits = 400;

    ESP_LOGI(TAG, "Updating BLE connection parameters");

    this->server->updateConnParams(
        connInfo.getConnHandle(),
        minIntervalUnits,
        maxIntervalUnits,
        latency,
        timeoutUnits
    );
}

void BluetoothLayer::onWrite(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) {
    std::vector<uint8_t> rawData = pCharacteristic->getValue();
    ESP_LOGI(TAG, "Received %d bytes", rawData.size());
}

void BluetoothLayer::onRead(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo) {
    ESP_LOGI(TAG, "Characteristic read");
}

void BluetoothLayer::onStatus(NimBLECharacteristic* pCharacteristic, int code) {
    if(code == 0){
        ESP_LOGI(TAG, "Notify success");
    } else {
        ESP_LOGW(TAG, "Notify failed: %d", code);
    }
}

void BluetoothLayer::onSubscribe(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo, uint16_t subValue) {
    ESP_LOGI(TAG, "Client subscribed: %d", subValue);
}

void BluetoothLayer::onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo) {
    ESP_LOGI(TAG, "Client connected");
    this->connected = true;
    
    std::string address = connInfo.getAddress().toString();
    ESP_LOGI(TAG, "Address: %s", address.c_str());
    
    this->server->stopAdvertising();
}

void BluetoothLayer::onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason) {
    ESP_LOGI(TAG, "Client disconnected, reason: %d", reason);
    this->connected = false;
    
    this->server->startAdvertising();
}

void BluetoothLayer::onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo) {
    this->mtuSize = MTU;
    ESP_LOGI(TAG, "MTU changed to: %d", MTU);
}

[h2zero]

I think I see the issue, the 2.0 changes removed some of the advertisement data handling that was redundant and your code will call startAdvertising when clients disconnect, which will attempt to add a uuid each time to the advertisement. This will work only once and then fail due to lack of space. To fix it either clear the data in your startAdvertsing function or check if the data has been set already and don't set any data just advertise, or (looks like best to me) in the onDisconnect function use the pServer pointer to start advertising instead of your class object.

[michaelboeding]

Hey @h2zero just checked my commits - it seems like I tried to reset and do that actually. Besides actually calling it directly from the pServer pointer? But it should be the same one that my class stores since the server constantly stays up. I actually ended up reverting back to the 1.4.0 so I had a stable build but actually now that I'm looking at a device thats been running for awhile its not doing the same thing but its garbage data in the services. I'm on 5.3.2 on the esp idf.

Sorry I know this isn't super helpful at pinpointing but I guess now im wondering if it's an underlying issue?

[h2zero]

It could be a controller issue or something else for sure, hard to tell. The flow is that the app tells the host the commands, the host tells the controller the commands and the controller is a magic box that we can't see sadly, so it could be an issue there.

[michaelboeding]

I’ve already reduced the advertisement payload to well under the 31-byte limit. I was hoping to drop the service data entirely, but I can’t, because iOS requires at least one service data block in the advertisement for background scanning to work—and I need background scans.

So I’m kind of stuck there. Any other ideas? Maybe something related to auto light sleep? It almost feels like I’m eventually getting corrupted/garbage data. For example, in the latest logs I’m seeing values like [CDF4]. @h2zero