How to send data via a characteristic as fast as possible / detect lost information

[Tirus42]

Hello together,

I am working on a BLE remote control interface with a flexible web interface (web bluetooth) to allow to control actions on the ESP via a browser. See https://github.com/Tirus42/Arduino-BLE-Remote for details, the send operation is located there: https://github.com/Tirus42/Arduino-BLE-Remote/blob/6832e6bfcbdc5fab2857ab38abc1bb5b38dc6e3b/arduino-library/src/BLELedController.cpp#L489.

For this, i send some data (in my example about 1,5kb) to the connected client by using
characteristic.notify() inside a loop with 128 byte chunks.

This works, as long as the whole data block is not too large,
but for example 5kb of data, there are many packets lost.
Also i got problems, when multiple clients are connected.

I assume that the BLE stack contains a send queue which will be overloaded by to many packets.
Is there a way to detect this and to handle it properly?

I saw in a example (https://github.com/h2zero/NimBLE-Arduino/blob/master/examples/Refactored_original_examples/BLE_server_multiconnect/BLE_server_multiconnect.ino Line 139) that a simple delay is used. But this seems not to be a reliable solution.

[h2zero]

You should wait for the onStatus callback to signal when its safe to send another packet. Note that you will not be able to send anymore than 512 bytes per connection event, which is determined by the client.

[Tirus42]

Thank you for your response.

I started to use the onStatus() callback. But I run into the next problem when more than one client is connected.
It looks like the callback comes once for every client.

Is there a reliable way to determine the amount of callbacks I will receive?

Probably I could use the characteristic.getSubscribedCount() to determine the number of connected clients.
But I assume there will be a time window between reading the subscriber count and calling the notify() method, in which one client could disconnect.

Also it seems that the callback will always be called from inside the notify() operation. Would it be possible to just return the success/failure as return value of notify()?

[h2zero]

Returning the result from notify would not be correct because the stack returns the result after the data is sent via a callback.

What I suggest is keeping a running total of subscribers via the onSubscribe callback then checking the number of status callbacks received against that number.

[Tirus42]

Thank you again for your response.

I tried this approach but run into the next problem.
I got the case that I have two subscribers to my characteristic and I try to send some data.
In this case I want to send 8x 255 bytes (the MTU of both clients). My program calls characteristic->indicate() with the block of data and waits until 2 onStatus() callbacks are received with status == SUCCESS_NOTIFY.

By testing this setup I got two different error cases:

1. instead of status = SUCCESS_NOTIFY i received status = ERROR_GATT with code = 6. This two times.
   I this case i suppose the correct behavior would be to call charachterstic->indicate() with the same data again and hope for better luck.

2. I received two callbacks, but one with status = SUCCESS_NOTIFY and the second with status = ERROR_GATT.
   In this case I have no idea to handle this correctly. I assume that for one client the data was enqueued and for the second it failed.
   Now I am in trouble, because I cant determine by the callbacks which client failed now can I send the data to only one client again.

I did see that in the current master branch the methods got a additional NimBLEConnInfo parameter to send data to only one client.
But the onStatus() callback seems to miss the NimBLEConnInfo.

Also I observed that the onStatus() callback always comes from the call stack inside the indicate() function.
Wouldn't that make it possible to handle the success / failure internally and return the success / failure directly?

[Tirus42]

I solved the problem by using functions from NimBLE directly instead of the Arduino wrapper.
For details see arduino-library/src/AsyncBLECharacteristicWriter.cpp

I use ble_gatts_notify_custom() to send the data block to each subscriber and handle the return code of the function call.
When the operation failes, I just wait a short time to let the BLE stack process the pending packets and try again
(The delay() should be no probleme here, as the whole function runs inside a own thread).

This also allows to handle each subscriber individually even when all listen to the same characteristic.

[h2zero]

Thanks for the update, I should look to improve the API to handle this situation.