Dealing with data packet loss between a peripheral device (nRF52832) and a central device (nRF52840)

[Tai]

Hi everyone,

I'm setting up 02 peripheral devices (nRF53832 Dev KIT) that connect to a central device (nRF52840 Dev KIT). In the past few days, I've tested its throughput using only 1 peripheral device to send data to the central one at 250 samples/sec with 16 bytes data packet (15-byte data packet + 1 byte index to check if any data packet loss) as shown in the following figure. I'm using SDK17.02 and NUS service for both peripheral device and central device. I'm using 2M PHY, DLE enabled and ATT MTU 247 bytes.

The following code is the ble_nus_data_send function being used to send data to the central device. 

uint32_t ble_nus_data_send(ble_nus_t * p_nus,
                           uint8_t   * p_data,
                           uint16_t   p_length,
                           uint16_t    conn_handle)
{
    ret_code_t                 err_code;
    ble_gatts_hvx_params_t     hvx_params;
    ble_nus_client_context_t * p_client;
    //ble_evt_t const * p_ble_evt;
    ble_nus_evt_t * p_evt;

    VERIFY_PARAM_NOT_NULL(p_nus);

    err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage, conn_handle, (void *) &p_client);
    VERIFY_SUCCESS(err_code);

    if ((conn_handle == BLE_CONN_HANDLE_INVALID) || (p_client == NULL))
    {
        return NRF_ERROR_NOT_FOUND;
    }

    if (!p_client->is_notification_enabled)
    {
        return NRF_ERROR_INVALID_STATE;
    }

    if (p_length > BLE_NUS_MAX_DATA_LEN)
    {
        return NRF_ERROR_INVALID_PARAM;
    }

    memset(&hvx_params, 0, sizeof(hvx_params));

    hvx_params.handle = p_nus->tx_handles.value_handle;
    hvx_params.p_data = p_data;
    hvx_params.p_len  = &p_length;
    hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;
    
    err_code = sd_ble_gatts_hvx(conn_handle, &hvx_params);

    return err_code;
}

I put this function in while (1) loop along with my sensor data saved in array as one of parameters (uint8_t* p_data) in the main.c to keep sending data. The error I got from this function: sd_ble_gatts_hvx() is NRF_ERROR_RESOURCES. Following some suggestions on other posts like this [1, 2], there are two approaches I used:

Approach #1: Once I receive NRF_ERROR_RESOURCES, I resend the data packet till the error goes away. I keep printing the err_code and it showed NRF_SUCCESS; however, I checked on the terminal debug of the central device, I'm still seeing some data packet loss. I noticed some data packets were resent several times. The following illustrates what I'm saying. P/s: I checked on the index number (16th byte) of each data packet and printed out on the central side.

Approach #2: It's slightly similar to the first one, but once I received the NRF_ERROR_RESOURCES, I wait till the BLE_GATTS_EVT_HVN_TX_COMPLETE event happened. This event was triggered at the ble_nus_on_ble_evt function:

void ble_nus_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
    if ((p_context == NULL) || (p_ble_evt == NULL))
    {
        return;
    }

    ble_nus_t * p_nus = (ble_nus_t *)p_context;

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
            on_connect(p_nus, p_ble_evt);
            break;

        case BLE_GATTS_EVT_WRITE:
            on_write(p_nus, p_ble_evt);
            break;

        case BLE_GATTS_EVT_HVN_TX_COMPLETE:
            on_hvx_tx_complete(p_nus, p_ble_evt);
            break;

        default:
            // No implementation needed.
            break;
    }
}

So whenever BLE_GATTS_EVT_HVN_TX_COMPLETE event happened, it called the following function, and I used BLE_NUS_EVT_TX_RDY as an event to see if Service is ready to accept new data to be transmitted. I create a bool variable (as a flag) and whenever BLE_NUS_EVT_TX_RDY is called, the flag is TRUE. Thus when sending data to over BLE, if NRF_ERROR_RESOURCES happened, I wait for the flag is TRUE before calling the BLE sending function. However, the data packet loss still happened. 

static void on_hvx_tx_complete(ble_nus_t * p_nus, ble_evt_t const * p_ble_evt)
{
    ret_code_t                 err_code;
    ble_nus_evt_t              evt;
    ble_nus_client_context_t * p_client;

    err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage,
                                 p_ble_evt->evt.gatts_evt.conn_handle,
                                 (void *) &p_client);
    if (err_code != NRF_SUCCESS)
    {
        NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.",
                      p_ble_evt->evt.gatts_evt.conn_handle);
        return;
    }

    if ((p_client->is_notification_enabled) && (p_nus->data_handler != NULL))
    {
        memset(&evt, 0, sizeof(ble_nus_evt_t));
        evt.type        = BLE_NUS_EVT_TX_RDY;
        evt.p_nus       = p_nus;
        evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle;
        evt.p_link_ctx  = p_client;

        p_nus->data_handler(&evt);
    }
}

Please advise on if I need to update/modify the above approaches to solve data loss problem. Thanks!

[Simonr]

Hi

Thank you for the update. What application exactly is your nRF peripheral and central projects based on? Could you try with the throughput sample and see if you have the same issue there? https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/samples/bluetooth/throughput/README.html 

If you're just using a modified version of the Peripheral and Central UART applications it could be that a buffer is filling up either on the transmitting or receiving side if you're transmitting over BLE faster than the UART buffer can handle the messages for example.

Best regards,

Simon

[Tai]

Thank you for your reply, Simon! I'm trying to create a multimodal sensor for bio-signal data collection. These sensors aren't placed close to each other, so having multiple peripheral devices connected with sensors, and a central hub to transmit all data to a phone app is the main direction right now.

I'm not using Zephyr libraries for this project. For peripheral side, I'm using ble_app_uart example and adding sensor's code and send data over the air to the central hub. For the central hub, I'm modifying ble_app_uart_c example to collect data from peripheral devices and then send these data to the phone app.

More specifically, the following code snippet shows where I catch data being sent from peripheral devices ( at BLE_NUS_C_EVT_NUS_TX_EVT event). At the same time, I sent these data to the phone app via NUS send function. Is there any situation that sending data to the phone app take too long so that it affects the central device gets data from peripheral ones?

Please take a look at this short snippet and I would much appreciate if you could recommend if there is another way to handle data coming from peripheral devices and also sending these data to the phone app. Thanks!

static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, ble_nus_c_evt_t const * p_ble_nus_evt)
{
    ret_code_t err_code;

    switch (p_ble_nus_evt->evt_type)
    {
        case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:
            NRF_LOG_INFO("Discovery complete.");
            err_code = ble_nus_c_handles_assign(p_ble_nus_c, p_ble_nus_evt->conn_handle, &p_ble_nus_evt->handles);
            APP_ERROR_CHECK(err_code);

            err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c);
            APP_ERROR_CHECK(err_code);
            NRF_LOG_INFO("Connected to device with Nordic UART Service.");
            break;

        case BLE_NUS_C_EVT_NUS_TX_EVT:
            //ble_nus_chars_received_uart_print(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len);
            // receive data from peripheral devices
            // then transmit it to a phone app using - err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
            break;

        case BLE_NUS_C_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected.");
            scan_start();
            break;
    }
}