Peripheral UART - 20 Byte Limitation

RE: Peripheral UART - 20 Byte Limitation

FinnBiggs — Mon, 30 Sep 2024 21:52:46 GMT

Hi again Susheel,

I've located what I was missing.

I needed to either:

Add MTU negotiation to the .connected callback
OR
Add
- # Auto negotiate MTU on connection
  
  CONFIG_BT_GATT_CLIENT=y
  
  CONFIG_BT_GATT_AUTO_UPDATE_MTU=y

I opted to add the two config options above. Now, my sniffer trace indicates that the MTU negotiations happen immediately on connection, and my messages are sent as blocks limited by the option

# UART Chunk Size (40 original --> increase)

CONFIG_BT_NUS_UART_BUFFER_SIZE=80

Thank you very much for looking at my post -- I'll mark this reply as a solution and hope this helps other people who encounter this in the future.

Enjoy your week!

Best,

- Finn

RE: Peripheral UART - 20 Byte Limitation

FinnBiggs — Mon, 30 Sep 2024 19:38:58 GMT

Hi Susheel,

Thanks for getting back to me!

Unfortunately, there may be more than just enabling the KConfig MTU options involved in fixing this.

Before my first post, I experimented with the config options that seemed to make sense until I got frustrated with my lack of progress. I followed the options within the ble_throughput sample and didn't manage to succeed at increasing the allowed send size.

-----------------------------------

To that end, please find attached my application "peripheral_uart_ext (zip)"

This application is the peripheral_uart sample, modified to include the config options for increasing MTU size. I also organized the prj.conf differently than in the sample.

Checking the autoconf.h after building, I find that the MTU size is updated. In this sample, one cannot send more than 20 bytes from app-> remote, and cannot send more than 20 bytes from remote -> app, which is unchanged by the MTU KConfig options.

Grateful for advice on how to proceed.

---------------------------------

Application build instructions

zip file contains source and config options
west build command contained in scripts/dk.sh
- (either run this command on CLI from nrfConnect terminal, or use information within for build configuration options)

Behavior replication instructions

Build and flash attached application to nrf52840dk
Connect to NORDIC_UART_SERVICE using external application
- I used nRF Connect Android App
Subscribe to Nordic UART Service TX Characteristic
Send string of 20 characters to RX Characteristic
- Observe successful send to device and print to logging
Send string of 21+ characters to RX characteristic
- Observe failure to send
- App Logs Error: "Error 6 (0x6): GATT REQ NOT SUPPORTED"
Open Serial connection to Dev Kit
Send 20 char string (18 + '\r' + '\n')
- Observe success of transfer to external application (TX Characteristic)
Send 21+ char string
- Observe failure to send
- Example warnings from sending following string "0000000000000000000\r\n" (19 zeros, \r\n = 21 char)
- <wrn> bt_att: No ATT channel for MTU 24
  <wrn> bt_gatt: No buffer available to send notification
  <wrn> peripheral_uart: Failed to send data over BLE connection

----------------------------------

Did you find success with the modifications you suggested? If so, I wonder if something else is wrong with my app setup, build system, or environment.

Thank you for your advice and time.

Best,

- Finn

devzone.nordicsemi.com/.../peripheral_5F00_uart_5F00_ext.zip

RE: Peripheral UART - 20 Byte Limitation

Susheel Nuguru — Mon, 30 Sep 2024 08:05:34 GMT

n peripheral_uart sample, it looks like CONFIG_BT_NUS_UART_BUFFER_SIZE plays a role in fifo size used to save data while BT or UART is busy. Need to reconfigure this size aswell to get bigger chunk transfers.

To increase the limit of data you can send over BLE, you can adjust the Maximum Transmission Unit (MTU) size. The MTU size determines the maximum amount of data that can be sent in a single packet. By default, the MTU size is set to 23 bytes, which includes the L2CAP header of 4 bytes, leaving 20 bytes for payload. However, the MTU size can be increased up to 247 bytes.

In the prj.conf file of your project, you can add or modify the following configuration options:

CONFIG_BT_USER_DATA_LEN_UPDATE=y
CONFIG_BT_L2CAP_TX_MTU=247
CONFIG_BT_BUF_ACL_TX_SIZE=251
CONFIG_BT_BUF_ACL_RX_SIZE=251
CONFIG_BT_CTLR_DATA_LENGTH_MAX=251

This will increase the MTU size to 247 bytes, allowing you to send more data in a single packet.

Regarding your second question, if you want to send data in batches, you can use the UART driver's asynchronous API. This API provides functions for sending and receiving data in a non-blocking manner. You can use the uart_tx function to send data, and the uart_callback_set function to set a callback that will be called when the transmission is complete. This way, you can send the next batch of data in the callback function.

Here is an example of how you can use the asynchronous API:

struct uart_data_t *buf;

buf = k_malloc(sizeof(*buf));
if (buf) {
buf->len = 0;
} else {
   LOG_WRN("Not able to allocate UART receive buffer");
   k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
   return;
}

uart_rx_enable(uart, buf->data, sizeof(buf->data), UART_WAIT_FOR_RX);

In this example, a buffer is allocated and then passed to the uart_rx_enable function, which starts the reception of data. When the reception is complete, the callback function set with uart_callback_set will be called.

Please note that the actual implementation may vary depending on your specific requirements and the structure of your code.