Error after writing to GATT characteristic (value>400) three-four times

[abu-rehan]

Hi!

I am using ARDUINO NANO 33 BLE SENSE as peripheral and Web Bluetooth API to write a characteristic value on it.
The value size is 512 bytes.
I am using this sketch: https://github.com/arduino-libraries/ArduinoBLE/tree/master/examples/Peripheral/LED with the following modification:

//BLEByteCharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);
BLECharacteristic switchCharacteristic("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite, 512);

I can successfully write to the characteristic first few times but then it gets stuck.
The issue also occurs if I write to four different characteristics (512 each) one after another.
Occurs even if I disconnect between writes.
From my observation, this issue never occurs for value size<200 bytes. It occurs sporadically for size=256.

Web Bluetooth script to reproduce the issue:

Connect then Write<br>
<button id="connect">Connect</button>
<button id="write1">Write</button>

<script>
var bleService = '19b10000-e8f2-537e-4f6c-d104768a1214'
var bleCharacteristic1 = '19b10001-e8f2-537e-4f6c-d104768a1214'
var arduinoDevice;
var gattService;
var gattCharacteristic1;
const testbyte1= new Uint8Array([0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x41,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x71,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
							0x51,0x42, 0x43, 0x44 , 0x45, 0x46,0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50]);
console.log(testbyte1);

function connect(){
	navigator.bluetooth.requestDevice({ filters: [{services: [bleService]}] })
	.then(device => {arduinoDevice= device;
		return arduinoDevice.gatt.connect();})
	.then(server => server.getPrimaryService(bleService))
	.then(service => {gattService= service;
		return gattService.getCharacteristic(bleCharacteristic1)})
	.then(characteristic1 => {gattCharacteristic1= characteristic1;
		console.log("Connect done");})
	.catch(error => { console.error(error);
					Promise.resolve();});
}

function write(){
	if(arduinoDevice.gatt.connected){
		gattCharacteristic1.writeValue(testbyte1.slice(0,512))
		.then(_ =>{
			console.log('Written')
		})
		.catch(error => { console.error(error)
						Promise.resolve();});
	}
	else{ alert('Device not connected');
	}
}

document.getElementById('connect').addEventListener('click', connect, false);
document.getElementById('write1').addEventListener('click', write, false);
</script>

[polldo]

Hi @aburehan2020 ,
in the BLE stack there is a parameter called MTU. This param is device specific. It indicates the maximum amount of bytes that can be transmitted through BLE.
In the case of the nano33ble, that is mounting an nrf52, the max MTU is 247. Thus, you can only write up to 247 - 3 bytes (due to the ATT overhead)

[abu-rehan]

Hi @polldo ,
If that is the case then shouldn't it be that you can never write more than 244 bytes? I can write that about 2-3 times before it fails.
I do not know a lot about microcontrollers. If that really explains it then you can close this issue.

[polldo]

@aburehan2020 yes, you cannot receive more than 244 bytes in a single transfer. I'm quite sure you are only receiving the first 244 bytes of the buffer

[wpilgri]

I am SOOO happy I found this as I have been trying to use my Arduino 33 BLE to gather some sensor data at a high rate and then transfer via bluetooth. I am trying to capture 100 readings that consume a 24 byte struct per reading and transfer it all via bluetooth to my laptop. Works great for 10 points (240 bytes) but caps out at 244 bytes as described above. Despite declarations of burstmodestructDataChar() to the contrary below, it looks like it is ignored.

#include <Arduino.h>
#include <ArduinoBLE.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/quaternion.h>

//----------------------------------------------------------------------------------------------------------------------
// BLE UUIDs
//----------------------------------------------------------------------------------------------------------------------
#define BLE_UUID_ENVIRONMENT                      "181C" //Service

#define BLE_UUID_RUNMODE                          "2A56" //Characteristic for string writing and reading.

#define BLE_UUID_CONTMODE_STRUCTDATA              "2A57" //Characteristic for calibration string writing.
                                                          // As a struct.  Most efficient method vs. a string.


#define BLE_UUID_BURSTMODESTRUCTDATA              "2A58"  //Characteristic for data as as struct in burst mode
                                                          // which will return multiple structs in an array

#define BLE_UUID_NUMPTS                           "2A21" // Number of points to record when in burst mode.  TBD

#define BLE_UUID_BURST_OPMODE                    "2A4E"  // Mode of operation.
                                                          // To be defined:  False=Continuous, True=burst mode.

//----------------------------------------------------------------------------------------------------------------------
// BLE
//----------------------------------------------------------------------------------------------------------------------
#define BLE_DEVICE_NAME                           "Arduino Nano 33 BLE"
#define BLE_LOCAL_NAME                            "SensorMonitor"  //The name that Python uses to find device

//----------------------------------------------------------------------------------------------------------------------
// CONSTANTS
//----------------------------------------------------------------------------------------------------------------------
#define SAMPLE_RATE 1000    // How often do we read and update BLE data.  Delay in ms.

#define NUMPTS_BURSTMODE 100  //Number of points to record when in burst mode

//----------------------------------------------------------------------------------------------------------------------
// STRUCTURE DEFINITION
// Note:  The unpacking in Python needs to match the byte configuration of the struct here.
//----------------------------------------------------------------------------------------------------------------------
    // uint_8 = 1 byte
    // int = 4 bytes
    //unsigned long = 4 bytes
    //unisgned short =u_int16_t = 2 bytes

typedef struct  __attribute__ ((packed)) {
  unsigned long timeread;
  int qw; //float Quaternion values will be scaled to int by multiplying by constant
  int qx;
  int qy;
  int qz;
  uint8_t cal_system;
  uint8_t cal_gyro;
  uint8_t cal_accel;
  uint8_t cal_mag;
}sensordata ;

sensordata d;

//----------------------------------------------------------------------------------------------------------------------
//  #########################   FUNCTION DEFINITIONS.  NEED FOR PLATFORMIO  (not Arduino)      #########################
//
//      https://docs.platformio.org/en/latest/faq.html#convert-arduino-file-to-c-manually

void writeHandler(BLEDevice central, BLECharacteristic characteristic);
void updateSensorStructData();
void updateSensorData();
sensordata readSensorDataAsStruct();
//----------------------------------------------------------------------------------------------------------------------


// ********************** INITIALIZATION **************************************

//Setup the BNO055 sensor
Adafruit_BNO055 myIMU=Adafruit_BNO055();

BLEService mainService(BLE_UUID_ENVIRONMENT);  

// A FLAG to stop and stop reading and updating data.
BLEBoolCharacteristic runmodeChar(BLE_UUID_RUNMODE,BLERead | BLEWrite | BLENotify);


BLECharacteristic contmodestructDataChar (BLE_UUID_CONTMODE_STRUCTDATA,BLERead | BLENotify, sizeof(d)  );

//New Additions to support burst mode
BLEBoolCharacteristic burstoperationmodeChar (BLE_UUID_BURST_OPMODE,BLERead|BLEWrite );
BLEUnsignedShortCharacteristic burstmodenumptsChar (BLE_UUID_NUMPTS,BLERead|BLEWrite );

// ********CRITICAL Characteristic that has limited write amount !!!*******************
BLECharacteristic burstmodestructDataChar (BLE_UUID_BURSTMODESTRUCTDATA,BLERead | BLENotify, sizeof(d)*NUMPTS_BURSTMODE  );

unsigned long previousMillis = 0;  // last time the reading was done, in ms


// ********************** SETUP **************************************
void setup() {

  Serial.begin(115200);    // initialize serial communication

  //Setup BNO055 IMU
  myIMU.begin();
  delay(1000);
  myIMU.setExtCrystalUse(true);
  

  pinMode(LED_BUILTIN, OUTPUT); // initialize the built-in LED pin to indicate when a central is connected

  // begin initialization
  if (!BLE.begin()) {
    Serial.println("starting BLE failed!");

    while (1);
  }

  BLE.setDeviceName( BLE_DEVICE_NAME );
  BLE.setLocalName( BLE_LOCAL_NAME );
  BLE.setAdvertisedService( mainService ); // add the service UUID
  

// ********************** EVENT HANDLERS  **************************************
  runmodeChar.setEventHandler(BLEWritten, writeHandler);
    //Should expand to more handles and less inline code.  TBD

// ********************** ADD CHARACTERISTICS **********************************    
  mainService.addCharacteristic(runmodeChar); //Add characteristic to test writing 

  mainService.addCharacteristic(contmodestructDataChar); //Characteristic that will send struct.

  mainService.addCharacteristic(burstoperationmodeChar); //Characteristic that will allow user to set operating mode.
  
  mainService.addCharacteristic(burstmodenumptsChar); //Characteristic that will allow user to set operating mode.
  
  mainService.addCharacteristic(burstmodestructDataChar); //Characteristic that will allow user to set operating mode.

 
 // ********************** DESCRIPTORS TO IMPROVE READABILITY*******************
  BLEDescriptor runmodeDescriptor("2901", "Run Flag:  True=Run, False=Stop.  Needs to be true to read sensor");
  runmodeChar.addDescriptor(runmodeDescriptor);

  BLEDescriptor structdataDescriptor("2901", "CONTINUOUS MODE:  Data as a C Struct");
  contmodestructDataChar.addDescriptor(structdataDescriptor);
  

  BLEDescriptor modeDescriptor("2901", "BURST MODE FLAG: True=Burst Mode, False=Continuous");
  burstoperationmodeChar.addDescriptor(modeDescriptor);
    
  BLEDescriptor burstnumptsDescriptor("2901", "BURST MODE:  Set Number of Pts to collect in burst mode");
  burstmodenumptsChar.addDescriptor(burstnumptsDescriptor);

  BLEDescriptor burstmodestructdataDescriptor("2901", "BURST MODE:  Data as an array of C Structs, numpts long");
  burstmodestructDataChar.addDescriptor(burstmodestructdataDescriptor);

  // *********************** SET DEFAULT VALUES *********************************

  burstmodenumptsChar.setValue(NUMPTS_BURSTMODE); //Set default number of points for burst mode.
  burstoperationmodeChar.setValue(false);  //default to continuous mode

  runmodeChar.setValue(false); //Don't start running immediately...alow for config
  

  //Add the Service
  BLE.addService(mainService);

  /* Start advertising BLE.  It will start continuously transmitting BLE
    advertising packets and will be visible to remote BLE central devices
    until it receives a new connection */

  BLE.advertise();

  //Debugging

  Serial.print("Size of sensor struct=");
  Serial.println(sizeof(d));

  Serial.print("Size of burst mode sensor struct=");
  Serial.println(sizeof(d)*NUMPTS_BURSTMODE);

  Serial.print("Size of unsigned short=");
  Serial.println(sizeof(u_int16_t));

  Serial.println("Bluetooth device advertising, waiting for connections...");
} //End Setup


// ********************** MAIN LOOP **************************************
void loop() {

  // wait for a BLE central
  BLEDevice central = BLE.central();

  // if a central is connected to the peripheral:
  if (central) {
    Serial.print("Connected to central: ");
    // print the central's BT address:
    Serial.println(central.address());
    // turn on the LED to indicate the connection:
    digitalWrite(LED_BUILTIN, HIGH);


   Serial.println("Waiting for run mode to be set TRUE.");

    while(!runmodeChar.value())
    {
      //Do nothing until the run mode is set.
       //Serial.println("Waiting on run mode flag...");
      BLE.poll();
    }

    //read mode Characteristic so we know which mode to operate in.
    bool currentopmode = burstoperationmodeChar.value();
    Serial.print("Current operating mode: ");
    if(currentopmode==false){
      Serial.println("Continuous");
    } else{
      Serial.println("Burst");
    }

    Serial.print("Current run mode: ");
    Serial.println(runmodeChar.value());
    
    if(currentopmode==false){
      // ********************************************************************
      // ** Continuous Mode **
      // ********************************************************************
      Serial.println("Entered Continuous Run Mode.");
        // while the central is connected:
        while (central.connected() && runmodeChar.value() ) {
            unsigned long currentMillis = millis();

            // ####################################################
            // if time interval have passed, check the value:
            // ####################################################
            if (currentMillis - previousMillis >= SAMPLE_RATE) {
                previousMillis = currentMillis;
                
                //Read the datafrom sensor
                sensordata data = readSensorDataAsStruct();

                //Update characteristic
                contmodestructDataChar.writeValue((uint8_t *)&data, sizeof(data));
            }
        }
    
    } else{
      // ********************************************************************
      // ** Burst Mode   THIS IS THE PROBLEM AREA WITH LIMITED WRITE CAPACITY**
      // ********************************************************************

        u_int16_t ptsread=0; // Initialize pt counter

        //Define array of structs
        sensordata burstdata[NUMPTS_BURSTMODE], *burstdataptr ;
        Serial.print("\tSize of Burst Data=");
        Serial.println(sizeof(burstdata));
        burstdataptr=&burstdata[0]; //Initialize

        Serial.println("Entered Burst Run Mode.");

        int i=0;
        while (central.connected() && runmodeChar.value() ) {
            if (ptsread<NUMPTS_BURSTMODE){
                //take a reading
                //DEBUG:  *burstdataptr=readSensorDataAsStruct();
                burstdata[i]=readSensorDataAsStruct();
                //Increment pointer
                //DEBUG:  burstdataptr++;
                i++;
                ptsread++;
            } else{
                //Send update to Bluetooth
                
               // **********WRITE COMMAND THAT CAUSES THE ISSUE ***************************
                burstmodestructDataChar.writeValue( (uint8_t *) &burstdata, sizeof(burstdata) );
                
                
                //reset counter so we can start collecting next sample
                ptsread=0;
                i=0;
                //reset pointer
                //DEBUG:  burstdataptr=&burstdata[0]; //Initialize
                
    
            }//endif
        
        }//end while
    }

    // when the central disconnects, turn off the LED:
    digitalWrite(LED_BUILTIN, LOW);
    Serial.print("Disconnected from central: ");
    Serial.println(central.address());
    
  } //end if connected

}// End Loop() function

// ********************** SUPPORT FUNCTIONS **************************************

void updateSensorStructData(){
  /*Read the current quaternion value and calibration and update characteristics
    Using Struct.
    This does both read and update.  Break into two separate functions for better re-use
     
  */

  // Get calibration information
  uint8_t system, gyro, accel, mag = 0;
  myIMU.getCalibration(&system, &gyro, &accel, &mag);

  // Get quaternion directly.
  imu::Quaternion quat=myIMU.getQuat(); 
    
  unsigned long tnow=millis();

  //Declare struct and populate
  //The scaler 10000 converts a float so it can be sent as an int.
  //It will be decoded back to float on receiving side.
  sensordata datareading;

  datareading.timeread=tnow;
  datareading.qw=(int) (quat.w()*10000);
  datareading.qx=(int) (quat.x()*10000);
  datareading.qy=(int) (quat.y()*10000);
  datareading.qz=(int) (quat.z()*10000);
  datareading.cal_system=system;
  datareading.cal_gyro=gyro;
  datareading.cal_accel=accel;
  datareading.cal_mag=mag;

  // Serial.print("Quaternion value: "); // print it
  // Serial.print(quat.w() );
  // Serial.print(" , ");
  // Serial.print(quat.x() );
  // Serial.print(" , ");
  // Serial.print(quat.y() );
  //  Serial.print(" , ");
  // Serial.println(quat.z() );

  //Write values to Characteristics.
  //  Cast pointer to byte so it indexes 1 byte at a time,  sizeof returns number of bytes.
  contmodestructDataChar.writeValue((uint8_t *)&datareading, sizeof(datareading));

  //Debug data writing below
  //contmodestructDataChar.writeValue((uint8_t *)&dummydata, sizeof(dummydata));

  // stringCalibrationChar.writeValue(buffer2);

  //Write debug info to serial port.
  // Serial.println(buffer);
  // Serial.println(buffer2);
  
}

sensordata readSensorDataAsStruct(){
  /*  Read the current quaternion value and calibration and return as struct.
        Returns a Struct with the data.  */

  // Get calibration information
  uint8_t system, gyro, accel, mag = 0;
  myIMU.getCalibration(&system, &gyro, &accel, &mag);

  // Get quaternion directly.
  imu::Quaternion quat=myIMU.getQuat(); 
    
  unsigned long tnow=millis();

  //Declare struct and populate
  //The scaler 10000 converts a float so it can be sent as an int.
  //It will be decoded back to float on receiving side.
  sensordata datareading;

  datareading.timeread=tnow;
  datareading.qw=(int) (quat.w()*10000);
  datareading.qx=(int) (quat.x()*10000);
  datareading.qy=(int) (quat.y()*10000);
  datareading.qz=(int) (quat.z()*10000);
  datareading.cal_system=system;
  datareading.cal_gyro=gyro;
  datareading.cal_accel=accel;
  datareading.cal_mag=mag;

  return datareading;
  
}

void writeHandler(BLEDevice central, BLECharacteristic characteristic){
  //Event Handler.  Fires when something is written to the string characteristic
  
  // Serial.print("WriteHandler UUID: ");
  // Serial.println(characteristic.uuid());
  u_int8_t setval=0;

  int valuelen = characteristic.valueLength();  //Get Size
  Serial.print("writeHandler:  Size Written=");
  Serial.print(valuelen);
  Serial.print("| Data= ");

  for (int i=0;i<valuelen ;i++) {
    setval=(u_int8_t)characteristic.value()[i];
    Serial.print(setval);
  }
  Serial.println("");

  if (setval==false)
    {
      //If false -> in stop Mode
      Serial.println("runmode set to FALSE");
    } else
    {
      Serial.println("runmode set to TRUE");
    }

} //End Writehandler

So the million dollar question is how are you supposed to transfer a large amount of data over bluetooth? I need a continuous sampling of data points so I can do a proper FFT, thus the reason I was trying to grab a large number of points.

Any advice on how a large amount (10,000 bytes) of data is most effectively sent over bluetooth??

Where can I find the MTU setting so I can go inspect the code? I assume there's no opportunity to override this value?

Thank you Very Much...learning something new every day!