Not all characteristics recognized (only Android)

[chrs89]

Hello,
I have the code snippet below. I have multiple characteristics Read, Write, Notify. When connection to an IOS, all charactersitics of the advertised service are recogniced from clients side.
When Connecting with Android only 4 Characteristics are recognized. (seems there is a cut off when 4 characteristics are in the stack?)

Here the code:
/*

• Project: [Project Name]
• Description: [Brief description of the project]
• Author: [Your Name]
• Date: [Date of creation or last update]
• Notes:
• • MTU size functionality not working
• • To Solve: how can the GATT Functionality can be enabled in the automatically generated file "sdkconfig.dfrobot_firebeetle2_esp32"
• • Add setMTU function to BLEClient.cpp/.h espressif/arduino-esp32#4999 (May the issue is that there are not the right libraries or platform or in usage)
• This code is released under the [license name].
• For more details, see [link to license or legal information].
  */

//#include <BLEDevice.h>
//#include <BLEServer.h>
//#include <BLEUtils.h>
//#include <BLE2902.h>

#include <NimBLEDevice.h>

#include "HX711.h"
#include
#include "driver/timer.h"
#include "esp_gatt_defs.h"

// Send Large Datasets
bool deviceConnected = false;
bool startSending = false;
bool startSampling = false;
bool queueFull = false;
SemaphoreHandle_t queueMutex;
#define QUEUE_LENGTH 1000
#define ITEM_SIZE sizeof(int)
QueueHandle_t dataQueue;

int dataThreshold = 100; // Adjusted threshold for example
const int totalSamples = 1000;
int sampleCounter = 0;
hw_timer_t *timer1 = NULL;
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
// Function prototype
void sendLargeDataTask(void * parameter);
void clearQueue(QueueHandle_t queue);

// BLE Connecton MTU size
const int desiredMTU = 103;
const int defaultMTU = 23;
int actualMTU = 23;
bool mtuNegotiated = false;

// Deep Sleep
#define seconds_to_trigger_DeepSleep 600 // Timer in seconds until sleep mode is triggered

// Timer
#define timer_prescale 64000
hw_timer_t *timer0 = NULL;
int32_t counter = 0;
RTC_DATA_ATTR int bootCount = 0;

#define DEVICE_SERVICE_UUID "DFCD0001-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_STARTDATA "DFCD000A-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_STOPDATA "DFCD000B-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_SENSORDATA "DFCD000C-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_STARTLARGEDATA "DFCD000D-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_STARTLARGEDATA "DFCD000D-36E1-4688-B7F5-EA07361B26A8"

#define DEVICE_SERVICE_UUID_1 "DFCD0002-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_LARGEDATA "DFCD000E-36E1-4688-B7F5-EA07361B26A8"

#define DEVICE_SERVICE_UUID_2 "DFCD0003-36E1-4688-B7F5-EA07361B26A8"
#define CHARACTERISTIC_UUID_SENDFLAG "DFCD000F-36E1-4688-B7F5-EA07361B26A8"

bool sendData = false; // Flag to indicate whether to send sensor data
bool resetDSTimer = false; // Flag to reset DeepSleep timer

BLEServer pServer = NULL;
BLECharacteristic pCharacteristic_R_StartData= NULL;
BLECharacteristic* pCharacteristic_R_StopData= NULL;
BLECharacteristic* pCharacteristic_W_SensorData= NULL;
BLECharacteristic* pCharacteristic_R_StartLargeData= NULL;
BLECharacteristic* pCharacteristic_W_LargeData= NULL;
BLECharacteristic* pCharacteristic_W_SendFlag= NULL;

class MyServerCallbacks : public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
deviceConnected = true;
// Attempt to set the desired MTU size
//BLEDevice::setMTU(desiredMTU);
//actualMTU = BLEDevice::getMTU();
//Serial.println("actualMTU after Connection");
//Serial.println(actualMTU);
}

void onDisconnect(BLEServer* pServer) {
    // On client disconnect
    deviceConnected = false;
    sendData = false; // Stop sending sensor data on disconnect
    startSending = false;
    mtuNegotiated = false; // Reset MTU negotiation status
   
    BLEAdvertising* pAdvertising = pServer->getAdvertising();
    pAdvertising->start(); // Restart advertising
    Serial.println("Device disconnected, restarting advertising");
}

};

class MyClientCallbacks : public BLEClientCallbacks {
void onConnect(BLEClient* pClient) {
Serial.println("Client connected");
}

void onDisconnect(BLEClient* pClient) {
    Serial.println("Client disconnected");
}

};

class MyCallbacks : public BLECharacteristicCallbacks {
void onWrite(BLECharacteristic* pCharacteristic) {
std::string value = pCharacteristic->getValue();

    if (value.length() > 0) {
        if (pCharacteristic == pCharacteristic_R_StartData && value[0] == 0x01) {
            sendData = true; // Start sending sensor data
            resetDSTimer = true; //
        } else if (pCharacteristic == pCharacteristic_R_StopData && value[0] == 0x01) {
            sendData = false; // Stop sending sensor data
        } else if (pCharacteristic == pCharacteristic_R_StartLargeData && value[0] == 0x01) { 
            clearQueue(dataQueue);
            delay(100);
            startSampling = true;
            sampleCounter = 0;
            timerAlarmEnable(timer1); // Start the timer interrupt
        }
        else if (pCharacteristic == pCharacteristic_R_StartLargeData && value[0] == 0x00) { 
            sampleCounter = 0;
            startSampling = false;
            timerAlarmDisable(timer1); // Start the timer interrupt
        }
    }
}

};

void setupBLE() {
BLEDevice::init("SmartEdge");
pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());

BLEService* pService = pServer->createService(BLEUUID(DEVICE_SERVICE_UUID));




pCharacteristic_R_StartData = pService->createCharacteristic(
                         BLEUUID(CHARACTERISTIC_UUID_STARTDATA),
                         NIMBLE_PROPERTY::WRITE
                       );
pCharacteristic_R_StartData->setCallbacks(new MyCallbacks());

pCharacteristic_R_StopData = pService->createCharacteristic(
                         BLEUUID(CHARACTERISTIC_UUID_STOPDATA),
                         NIMBLE_PROPERTY::WRITE
                       );
pCharacteristic_R_StopData->setCallbacks(new MyCallbacks());

pCharacteristic_R_StartLargeData = pService->createCharacteristic(
                         BLEUUID(CHARACTERISTIC_UUID_STARTLARGEDATA),
                         NIMBLE_PROPERTY::WRITE
                       );
pCharacteristic_R_StartLargeData->setCallbacks(new MyCallbacks());

// Create the characteristic for sending sensor data
pCharacteristic_W_SensorData = pService->createCharacteristic(
                         BLEUUID(CHARACTERISTIC_UUID_SENSORDATA), // Replace with your sensor characteristic UUID
                         NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY
                       );


// Create the characteristic for sending large sensor data
pCharacteristic_W_LargeData = pService->createCharacteristic(
                         BLEUUID(CHARACTERISTIC_UUID_LARGEDATA), // Replace with your sensor characteristic UUID
                         NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY
                       );


// Create the characteristic for sending large sensor data
pCharacteristic_W_SendFlag = pService->createCharacteristic(
                         BLEUUID(CHARACTERISTIC_UUID_SENDFLAG), // Replace with your sensor characteristic UUID
                         NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY
                       );

pService->start();


//BLEAdvertising* pAdvertising = pServer->getAdvertising(); //this still is working for backward compatibility
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();

pAdvertising->addServiceUUID(DEVICE_SERVICE_UUID);
pAdvertising->setScanResponse(true);
//pAdvertising->setMinPreferred(0x06);  // functions that help with iPhone connections issue
//pAdvertising->setMinPreferred(0x12);

BLEDevice::startAdvertising();
//pAdvertising->start();

// Register the GATT client event handler

// Set the default MTU size
Serial.println(BLEDevice::setMTU(desiredMTU));

}

// Timer based interrupt Service Routines --------------------------------

void IRAM_ATTR onTimer() {
// Sample data and push it to the queue
int hallValue = hallRead(); // Read the Hall sensor value
//Serial.println(hallValue); // Debug print for hallValue

 if (sampleCounter == dataThreshold) {
    startSending = true; // Assuming this flag is for another part of your application
}

BaseType_t xHigherPriorityTaskWoken = pdFALSE;
portENTER_CRITICAL_ISR(&timerMux);



if (sampleCounter < QUEUE_LENGTH) {
    if (xQueueSendFromISR(dataQueue, &hallValue, &xHigherPriorityTaskWoken) == pdTRUE) {
        sampleCounter++;
    } else {
        // Handle queue full case
        //Serial.println("Queue full");
    }
} else {
    // If sampleCounter >= QUEUE_LENGTH
    startSampling = false;

    timerAlarmDisable(timer1); // Stop the timer interrupt after 20,000 samples
}

portEXIT_CRITICAL_ISR(&timerMux);
if (xHigherPriorityTaskWoken) {
    portYIELD_FROM_ISR();
}

}

// Timer ISR: Deep slee 

void IRAM_ATTR Timer0_ISR()
{
counter++;
esp_deep_sleep_start();

}

void clearQueue(QueueHandle_t queue) {
int dummy;
while (xQueueReceive(queue, &dummy, 0) == pdTRUE) {
// Discarding all items
}
queueFull = false;
}

// Sensor Configuration
long lastMsg = 0;
bool bSensorValue = false; // flag for fetching sensor value
double sensorValue = 0;
String dataToSend;

/*
//HX711 Configuration
HX711 scale; // Initializes library functions.
double calibration_factor = -55080;//-20328; // Defines calibration factor we'll use for calibrating.
// HX711 circuit wiring
#define SDA 21
#define SCL 22
*/

/*
Method to print the reason by which ESP32
has been awaken from sleep
*/
void print_wakeup_reason(){
esp_sleep_wakeup_cause_t wakeup_reason;

wakeup_reason = esp_sleep_get_wakeup_cause();

switch(wakeup_reason)
{
case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
}
}

void setup()
{
Serial.begin(9600);

setupBLE();

// Initialize Timer Interrupt
Serial.println("Interrupt Initialized");
timer0 = timerBegin(0,timer_prescale, true); // Prescaler set to 80*1e6 which means timer ticks every second
timerAttachInterrupt(timer0, &Timer0_ISR, true);
timerAlarmWrite(timer0, 1250*seconds_to_trigger_DeepSleep, true);
timerAlarmEnable(timer0);

//Increment boot number and print it every reboot
++bootCount;
Serial.println("Boot number: " + String(bootCount));

//Print the wakeup reason for ESP32
print_wakeup_reason();

/*
    First we configure the wake up source
    We set our ESP32 to wake up for an external trigger.
    There are two types for ESP32, ext0 and ext1 .
    ext0 uses RTC_IO to wakeup thus requires RTC peripherals
    to be on while ext1 uses RTC Controller so doesnt need
    peripherals to be powered on.
    Note that using internal pullups/pulldowns also requires
    RTC peripherals to be turned on.
*/
esp_sleep_enable_ext0_wakeup(GPIO_NUM_39, 1); //1 = High, 0 = Low


/*
    Initialize Bluetooth Classic Interface
*/


/*
pinMode(ledPIN, OUTPUT);
pinMode(led1PIN, OUTPUT);
pinMode(resetButtonPin, INPUT_PULLDOWN);


scale.set_gain(64);
scale.begin(SDA,SCL);
scale.tare();          // Resets the scale to 0.

*/




// Configure the timer interrupt
timer1 = timerBegin(1, 80, true); // Timer 1, Prescaler 80 (1us tick), Count up
timerAttachInterrupt(timer1, &onTimer, true);
timerAlarmWrite(timer1, 1000, true); // 1000 us = 1 ms = 1000 Hz
timerAlarmDisable(timer1); // Disable the timer initially




delay(1000); //Take some time to open up the Serial Monitor

}

void loop()
{
long now = millis();

/*
// Check if User Reset is triggered by Button
if (digitalRead(resetButtonPin) == HIGH) {
    delay(50); // Debouncing delay
    if (digitalRead(resetButtonPin) == HIGH) {
        resetButtonPressed = true;
    }
} else {
    // Reset if the button was pressed
    if (resetButtonPressed) {
        Serial.println("Reset button pressed. Resetting...");
        delay(100); // Delay for stability
        ESP.restart(); // Trigger a software reset
    }
    resetButtonPressed = false;
}

*/

//Serial.println(counter);
//Serial.println("active mode");



if (resetDSTimer)
{
    timerRestart(timer0);
    Serial.println("Reset DST"); // Reset Deep Sleep Timer
    resetDSTimer = false;
}


/*
Get Value from weight Cell here in if loop the code is waiting 20 ms to send a new value
within this 20 ms a new value shall be fetched from the weight cell
*/

if (sendData) {
    char sens_str[8];
    /*
    if (!bSensorValue){
      digitalWrite(led1PIN, HIGH);
      float sens = scale.get_value(1)/(calibration_factor);
      dtostrf(sens, 1, 2, sens_str);
      // Store timestamp as binary data (unsigned long)
      digitalWrite(led1PIN, LOW);
      }
    */
    if (now - lastMsg > 160) { // former 16 for ~80 Hz resoulution 
        
        //float sens = scale.get_value(1)/(calibration_factor);
        //dtostrf(sens, 1, 2, sens_str);

        float sens = 5.12;
        
        dtostrf(sens, 1, 2, sens_str);
        
        pCharacteristic_W_SensorData->setValue(sens_str);
        pCharacteristic_W_SensorData->notify();
        
        lastMsg = now;
        bSensorValue = false;

        Serial.println(sens); 
    }
}
else if (!sendData && !startSending)
{
    // Save Energy
    // Shut down Scale
    // Further Measures to save energy
    Serial.print("MTU Size: ");
    Serial.print(BLEDevice::getMTU());
    Serial.print("\n");
}

delay(1000);

}

[h2zero]

This looks like an Android/App issue. There isn't anything in this library that could cause this but maybe someone else has had a similar experience and can help.

[Mir1001]

Could you try to reset the phone? Android can have some old cache, sometimes switching off/on Bluetooth also helps.