Modify pc-ble-driver example for Nordic UART Service

[Kampino]

I try to modify one of the pc-ble-driver examples to work together with my PCA10040 and the Nordic UART Service example in my Qt application, but the application doesn´t discover two characteristics and receive an event with the ID 0x23 and 0x12:

Open softdevice...
Log:  2 - Successfully opened COM5. Baud rate: 1000000. Flow control: none. Parity: none.
Status:  6 - Target Reset performed
Status:  7 - Connection active
Enable softdevice...
Start scanning...
Scan started
Received advertisement report with device address:  0x453e4ff9a8
Connection established
Discovering primary service
Received an unhandled event with ID: 0x 23
Received service discovery response
Found  1  services
Discovered service with UUID: 0x 1 , start handle: 0x ffff , end handle: 0x ffff
Discovering characteristics
Received characteristic discovery response, characteristics count:  1
Characteristic handle: 0x c , UUID: 0x 2
Discovering characteristic's descriptors
No characteristic handle found
Received an unhandled event with ID: 0x 12
Disconnected, reason: 0x 22

How do I have to modify the code to use both characteristics of the service?

#include "qt_ble.h"

#define BLE_UUID_CCCD                                           0x2902

#define MSEC_TO_UNITS(TIME, RESOLUTION)                         (((TIME) * 1000) / (RESOLUTION))

#define BLE_UUID_NUS_SERVICE            0x0001
#define NUS_BASE_UUID                   {{0x9E, 0xCA, 0xDC, 0x24, 0x0E, 0xE5, 0xA9, 0xE0, 0x93, 0xF3, 0xA3, 0xB5, 0x00, 0x00, 0x40, 0x6E}}

//static uint32_t _mDeviceServiceUUID     = 0;
static uint32_t _mDeviceCharUUID        = 0;
static uint32_t _mErrorCode             = 0;
static uint32_t _mConfigID              = 0;
static uint16_t _mCCCDHandle            = 0;
static uint16_t _mCharHandle            = 0;
static uint16_t _mConnectionHandle      = 0;
static uint16_t _mServiceStartHandle    = 0;
static uint16_t _mServiceEndHandle      = 0;
static uint8_t  _mConnectedDevices      = 0;
static bool _mConnectionInProgress;

static ble_uuid_t UUID;
static ble_cfg_t _mBLE_Config;
static adapter_t* _mAdapter;
static physical_layer_t* _mPhy;
static data_link_layer_t* _mData_link_layer;
static transport_layer_t* _mTransport_layer;

static const ble_gap_scan_params_t Scan_Params =
{
    0,                       // Set if active scanning.
    0,                       // Set if selective scanning.
    0,
    (uint16_t)0x00A0,
    (uint16_t)0x0050,
    (uint16_t)0x00
};

static const ble_gap_conn_params_t Connection_Params =
{
    (uint16_t)MSEC_TO_UNITS(7.5, 1250),
    (uint16_t)MSEC_TO_UNITS(7.5, 1250),
    (uint16_t)0,
    (uint16_t)MSEC_TO_UNITS(4000, 10000)
};

uint32_t Qt_BLE::Open(QString Port, uint32_t ServiceUUID, uint32_t CharacteristicUUID)
{
    const uint32_t RAM_Start = 0;
    uint32_t* App_RAM_Base = NULL;

    /*
    _mDeviceServiceUUID = ServiceUUID;
    _mDeviceCharUUID = CharacteristicUUID;*/
    _mConfigID = 1;
    _mConnectedDevices = 0;
    _mConnectionHandle = 0;
    _mConnectionInProgress = false;

    _mPhy = sd_rpc_physical_layer_create_uart(Port.toLocal8Bit().data(), 1000000, SD_RPC_FLOW_CONTROL_NONE, SD_RPC_PARITY_NONE);
    _mData_link_layer = sd_rpc_data_link_layer_create_bt_three_wire(_mPhy, 250);
    _mTransport_layer = sd_rpc_transport_layer_create(_mData_link_layer, 1500);
    _mAdapter = sd_rpc_adapter_create(_mTransport_layer);
    sd_rpc_log_handler_severity_filter_set(_mAdapter, SD_RPC_LOG_INFO);

    DEBUG << "Open softdevice...";
    _mErrorCode = sd_rpc_open(_mAdapter, Qt_BLE::StatusHandler, Qt_BLE::on_Event, Qt_BLE::LogHandler);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "Failed to open nRF BLE Driver. Error code: 0x" << hex << _mErrorCode;
    }

    _mBLE_Config.gap_cfg.role_count_cfg.periph_role_count    = 0;
    _mBLE_Config.gap_cfg.role_count_cfg.central_role_count   = 1;
    _mBLE_Config.gap_cfg.role_count_cfg.central_sec_count    = 0;

    _mErrorCode = sd_ble_cfg_set(_mAdapter, BLE_GAP_CFG_ROLE_COUNT, &_mBLE_Config, RAM_Start);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "sd_ble_cfg_set() failed when attempting to set BLE_GAP_CFG_ROLE_COUNT. Error code: 0x" << hex << _mErrorCode;
    }

    memset(&_mBLE_Config, 0x00, sizeof(ble_cfg_t));
    _mBLE_Config.conn_cfg.conn_cfg_tag                        = _mConfigID;
    _mBLE_Config.conn_cfg.params.gatt_conn_cfg.att_mtu        = 150;

    _mErrorCode = sd_ble_cfg_set(_mAdapter, BLE_CONN_CFG_GATT, &_mBLE_Config, RAM_Start);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "sd_ble_cfg_set() failed when attempting to set BLE_CONN_CFG_GATT. Error code: 0x" << hex << _mErrorCode;
    }

    DEBUG << "Enable softdevice...";
    _mErrorCode = sd_ble_enable(_mAdapter, App_RAM_Base);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "Failed to enable nRF BLE Driver. Error code: 0x" << hex << _mErrorCode;
    }

    return _mErrorCode;
}

uint32_t Qt_BLE::StartScan(void)
{
    DEBUG << "Start scanning...";
    _mErrorCode = sd_ble_gap_scan_start(_mAdapter, &Scan_Params);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "Scan start failed with error code: 0x" << hex << _mErrorCode;
    }
    else
    {
        DEBUG << "Scan started";
    }

    return _mErrorCode;
}

uint32_t Qt_BLE::Close(void)
{
    return sd_rpc_close(_mAdapter);
}

void Qt_BLE::StatusHandler(adapter_t* p_Adapter, sd_rpc_app_status_t Code, const char* p_Message)
{
    DEBUG << "Status: " << Code << "-" << p_Message;
}

void Qt_BLE::LogHandler(adapter_t* p_Adapter, sd_rpc_log_severity_t Severity, const char* p_Message)
{
    DEBUG << "Log: " << Severity << "-" << p_Message;
}

void Qt_BLE::AddressToString(ble_gap_addr_t Address, rsize_t Size, uint8_t* p_Buffer)
{
    char Temp[3];

    for(int i = 5; i >= 0; --i)
    {
        sprintf(Temp, "%02X", Address.addr[i]);
        strcat_s((char*)p_Buffer, Size, Temp);
    }
}

bool Qt_BLE::Find_Adv_Name(const ble_gap_evt_adv_report_t* p_Adv_Report, const char* p_Name)
{
    uint32_t ErrorCode;
    data_t adv_data;
    data_t dev_name;

    adv_data.p_Data = (uint8_t*)p_Adv_Report->data;
    adv_data.Length = p_Adv_Report->dlen;

    // Search for advertising names
    ErrorCode = Parse_Adv_Report(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME, &adv_data, &dev_name);
    if(ErrorCode == NRF_SUCCESS)
    {
        if(memcmp(p_Name, dev_name.p_Data, dev_name.Length) == 0)
        {
            return true;
        }
    }
    else
    {
        // Look for the short local name if it was not found as complete
        ErrorCode = Parse_Adv_Report(BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME,  &adv_data, &dev_name);
        if(ErrorCode != NRF_SUCCESS)
        {
            return false;
        }

        if(memcmp(p_Name, dev_name.p_Data, dev_name.Length) == 0)
        {
            return true;
        }
    }

    return false;
}

uint32_t Qt_BLE::Parse_Adv_Report(uint8_t type, data_t* p_AdvData, data_t* p_TypeData)
{
    uint32_t Index = 0;
    uint8_t* p_Data;

    p_Data = p_AdvData->p_Data;

    while(Index < p_AdvData->Length)
    {
        uint8_t field_length = p_Data[Index];
        uint8_t field_type   = p_Data[Index + 1];

        if(field_type == type)
        {
            p_TypeData->p_Data = &p_Data[Index + 2];
            p_TypeData->Length = field_length - 1;

            return NRF_SUCCESS;
        }

        Index += field_length + 1;
    }

    return NRF_ERROR_NOT_FOUND;
}

uint32_t Qt_BLE::Start_ServiceDiscovery(adapter_t* p_Adapter)
{
    uint16_t Start_Handle = 0x01;

    DEBUG << "Discovering primary service";

    ble_uuid128_t         nus_base_uuid = NUS_BASE_UUID;

    _mErrorCode = sd_ble_uuid_vs_add(p_Adapter, &nus_base_uuid, &UUID.type);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "Failed to get UUID with error code: 0x" << hex << _mErrorCode;
    }

    UUID.uuid = BLE_UUID_NUS_SERVICE;

    // Initiate procedure to find the primary BLE_UUID_HEART_RATE_SERVICE.
    _mErrorCode = sd_ble_gattc_primary_services_discover(p_Adapter, _mConnectionHandle, Start_Handle, &UUID);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "Failed to initiate or continue a GATT Primary Service Discovery procedure with error code: 0x" << hex << _mErrorCode;
    }

    return _mErrorCode;
}

void Qt_BLE::on_Event(adapter_t* p_Adapter, ble_evt_t* p_Event)
{
    switch(p_Event->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
        {
            Qt_BLE::on_Connected(p_Adapter, &(p_Event->evt.gap_evt));
            break;
        }
        case BLE_GAP_EVT_DISCONNECTED:
        {
            DEBUG << "Disconnected, reason: 0x" << hex << p_Event->evt.gap_evt.params.disconnected.reason;

            _mConnectedDevices--;
            _mConnectionHandle = 0;
            break;
        }
        case BLE_GAP_EVT_ADV_REPORT:
        {
            Qt_BLE::on_Adv_Report(p_Adapter, &(p_Event->evt.gap_evt));
            break;
        }
        case BLE_GAP_EVT_TIMEOUT:
        {
            Qt_BLE::on_Timeout(&(p_Event->evt.gap_evt));
            break;
        }
        case BLE_GATTC_EVT_PRIM_SRVC_DISC_RSP:
        {
            on_Service_Discovery_Response(&(p_Event->evt.gattc_evt));
            break;
        }
        case BLE_GATTC_EVT_CHAR_DISC_RSP:
        {
            on_Characteristic_Discovery_Response(&(p_Event->evt.gattc_evt));
            break;
        }
        case BLE_GATTC_EVT_DESC_DISC_RSP:
        {
            on_Descriptor_Discovery_Response(&(p_Event->evt.gattc_evt));
            break;
        }
        case BLE_GATTC_EVT_WRITE_RSP:
        {
            on_Write_Response(&(p_Event->evt.gattc_evt));
            break;
        }
        case BLE_GATTC_EVT_HVX:
        {
            DEBUG << "BLE_GATTC_EVT_HVX";
            //on_hvx(&(p_ble_evt->evt.gattc_evt));
            break;
        }
        case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
        {
            on_Conn_Params_Update_Request(&(p_Event->evt.gap_evt));
            break;
        }
        case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
        {
            on_Exchange_MTU_Request(&(p_Event->evt.gatts_evt));
            break;
        }
        case BLE_GATTC_EVT_EXCHANGE_MTU_RSP:
        {
            DEBUG << "BLE_GATTC_EVT_EXCHANGE_MTU_RSP";
            //on_exchange_mtu_response(&(p_ble_evt->evt.gattc_evt));
            break;
        }
        default:
        {
            DEBUG << "Received an unhandled event with ID: 0x" << hex << p_Event->header.evt_id;
            break;
        }
    }
}

void Qt_BLE::on_Adv_Report(adapter_t* p_Adapter, const ble_gap_evt_t* const p_Event)
{
    uint32_t ErrorCode;
    uint8_t Buffer[50] = {0};

    AddressToString(p_Event->params.adv_report.peer_addr, sizeof(Buffer), Buffer);
    DEBUG << "Received advertisement report with device address: " << Buffer;

    if(Find_Adv_Name(&p_Event->params.adv_report, "Nordic_UART"))
    {
        ErrorCode = sd_ble_gap_connect(p_Adapter, &(p_Event->params.adv_report.peer_addr), &Scan_Params, &Connection_Params, _mConfigID);
        if(ErrorCode != NRF_SUCCESS)
        {
            DEBUG << "Connection Request Failed, reason %d\n" << ErrorCode;
            return;
        }
    }
}

void Qt_BLE::on_Connected(adapter_t* p_Adapter, const ble_gap_evt_t* const p_Event)
{
    DEBUG << "Connection established";

    _mConnectedDevices++;
    _mConnectionHandle = p_Event->conn_handle;
    _mConnectionInProgress = false;

    Start_ServiceDiscovery(p_Adapter);
}

void Qt_BLE::on_Timeout(const ble_gap_evt_t* const p_Event)
{
    if(p_Event->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
    {
        _mConnectionInProgress = false;
    }
    else if(p_Event->params.timeout.src == BLE_GAP_TIMEOUT_SRC_SCAN)
    {
        StartScan();
    }
}

void Qt_BLE::on_Service_Discovery_Response(const ble_gattc_evt_t* const p_Event)
{
    uint32_t ServiceIndex;
    const ble_gattc_service_t* Service;
    ble_gattc_handle_range_t HandleRange;

    DEBUG << "Received service discovery response";

    if(p_Event->gatt_status != NRF_SUCCESS)
    {
        DEBUG << "Service discovery failed. Error code 0x" << hex << p_Event->gatt_status;
        return;
    }

    if(p_Event->params.prim_srvc_disc_rsp.count == 0)
    {
        DEBUG << "Service not found";
    }
    else
    {
        DEBUG << "Found " << p_Event->params.prim_srvc_disc_rsp.count << " services";
    }

    ServiceIndex = 0; /* We expect to discover only the Heart Rate service as requested. */
    Service = &(p_Event->params.prim_srvc_disc_rsp.services[ServiceIndex]);

    if(Service->uuid.uuid != UUID.uuid)
    {
        DEBUG << "Unknown service discovered with UUID: 0x" << hex << Service->uuid.uuid;
        return;
    }

    _mServiceStartHandle = Service->handle_range.start_handle;
    _mServiceEndHandle = Service->handle_range.end_handle;

    DEBUG << "Discovered service with UUID: 0x" << hex << Service->uuid.uuid << ", start handle: 0x" << hex << _mServiceEndHandle << ", end handle: 0x" << hex << _mServiceEndHandle;
    DEBUG << "Discovering characteristics";

    HandleRange.start_handle = _mServiceStartHandle;
    HandleRange.end_handle = _mServiceEndHandle;

    _mErrorCode = sd_ble_gattc_characteristics_discover(_mAdapter, _mConnectionHandle, &HandleRange);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "sd_ble_gattc_characteristics_discover() failed, reason: " << hex << _mErrorCode;
        return;
    }
}

void Qt_BLE::on_Characteristic_Discovery_Response(const ble_gattc_evt_t* const p_Event)
{
    ble_gattc_handle_range_t HandleRange;

    if(p_Event->gatt_status != NRF_SUCCESS)
    {
        DEBUG << "Characteristic discovery failed. Error code 0x" << p_Event->gatt_status;
        return;
    }

    DEBUG << "Received characteristic discovery response, characteristics count: " << p_Event->params.char_disc_rsp.count;

    for(int i = 0; i < p_Event->params.char_disc_rsp.count; i++)
    {
        DEBUG << "Characteristic handle: 0x" << hex <<p_Event->params.char_disc_rsp.chars[i].handle_decl << ", UUID: 0x" << hex << p_Event->params.char_disc_rsp.chars[i].uuid.uuid;

        if(p_Event->params.char_disc_rsp.chars[i].uuid.uuid == _mDeviceCharUUID)
        {
            _mCharHandle = p_Event->params.char_disc_rsp.chars[i].handle_decl;
        }
    }

    DEBUG << "Discovering characteristic's descriptors";

    if(_mCharHandle == 0)
    {
        DEBUG << "No characteristic handle found";
        return;
    }

    HandleRange.start_handle = _mCharHandle;
    HandleRange.end_handle = _mServiceEndHandle;

    _mErrorCode = sd_ble_gattc_descriptors_discover(_mAdapter, _mConnectionHandle, &HandleRange);
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "sd_ble_gattc_descriptors_discover() failed, reason: " << hex << _mErrorCode;
    }
}

void Qt_BLE::on_Descriptor_Discovery_Response(const ble_gattc_evt_t* const p_Event)
{
    if(p_Event->gatt_status != NRF_SUCCESS)
    {
        DEBUG << "Descriptor discovery failed. Error code 0x" << hex << p_Event->gatt_status;
    }

    DEBUG << "Received descriptor discovery response, descriptor count: " << p_Event->params.desc_disc_rsp.count;

    for(int i = 0; i < p_Event->params.desc_disc_rsp.count; i++)
    {
        DEBUG << "Descriptor handle: 0x" << hex << p_Event->params.desc_disc_rsp.descs[i].handle << ", UUID: 0x" << hex << p_Event->params.desc_disc_rsp.descs[i].uuid.uuid;

        if(p_Event->params.desc_disc_rsp.descs[i].uuid.uuid == BLE_UUID_CCCD)
        {
            _mCCCDHandle = p_Event->params.desc_disc_rsp.descs[i].handle;

            ble_gattc_write_params_t write_params;
            uint8_t                  cccd_value[2] = {0x01, 0};

            DEBUG << "Setting HRM CCCD";

            if(_mCCCDHandle == 0)
            {
                DEBUG << "Error. No CCCD handle has been found";
            }

            write_params.handle     = _mCCCDHandle;
            write_params.len        = 2;
            write_params.p_value    = cccd_value;
            write_params.write_op   = BLE_GATT_OP_WRITE_REQ;
            write_params.offset     = 0;

            sd_ble_gattc_write(_mAdapter, _mConnectionHandle, &write_params);
        }
    }
}

void Qt_BLE::on_Write_Response(const ble_gattc_evt_t* const p_Event)
{
    DEBUG << "Received write response.";

    if(p_Event->gatt_status != NRF_SUCCESS)
    {
        DEBUG << "Error. Write operation failed. Error code: 0x" << hex << p_Event->gatt_status;
    }
}

void Qt_BLE::on_Conn_Params_Update_Request(const ble_gap_evt_t* const p_Event)
{
    _mErrorCode = sd_ble_gap_conn_param_update(_mAdapter, _mConnectionHandle, &(p_Event->params.conn_param_update_request.conn_params));
    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "Conn params update failed, Error code: " << hex << _mErrorCode;
    }
}

void Qt_BLE::on_Exchange_MTU_Request(const ble_gatts_evt_t* const)
{
    _mErrorCode = sd_ble_gatts_exchange_mtu_reply(_mAdapter, _mConnectionHandle, BLE_GATT_ATT_MTU_DEFAULT);

    if(_mErrorCode != NRF_SUCCESS)
    {
        DEBUG << "MTU exchange request reply failed, err_code: 0x" << hex << _mErrorCode;
    }
}

[Vidar Berg]

Hello,

The unhandled events are BLE_GAP_EVT_CONN_PARAM_UPDATE (0x12) and BLE_GAP_EVT_DATA_LENGTH_UPDATE_REQUEST (0x23), and this is what leads to the disconnect with reason 0x22 in the end (BLE_HCI_STATUS_CODE_LMP_RESPONSE_TIMEOUT). Please try to handle theses events has Sigurd suggested in this post: https://devzone.nordicsemi.com/f/nordic-q-a/44172/disconnection-between-ble_app_hrs-example-in-sdk-15-2-0-and-heart_rate_collector-example-with-pc-ble-driver-c-c

You may refer to the following message sequence charts that shows how the app should respond to these SD requests as well:

 - Data Length Update Procedure,

- Peripheral Connection Parameter Update

Lastly, I made a pc-ble-driver example to connect to the BLE blinky application a while ago. It does not handle data length requests, but you may still find it relevant as it includes service discovery of a custom service with multiple characteristics. I'm including it here in case you're interested:

blinky_client.zip

[Kampino]

Thank you for the example. It´s really helpful, but I don´t understand why my application report only one characteristic with the UUID 2 (which should be the RX characteristic from the example)

[Vidar Berg]

Hello,

Have you had any progress on this? If not, I think you can try the sample code I sent in my previous reply, and just update the UUID to match the ones you use. Alternatively, try increment the service handle before starting the characteristic discovery like I did.

[Kampino]

Hi Vidar,

yes, I make some good progress. I try to implement some data transmission with the NUS from Nordic and the transmission pc -> nRF52 is working, but the other way doesn´t work yet. Does your example provide code for the data reception. I think the LED part will do this, but it doesn´t work for me.

[Vidar Berg]

Good to hear that you have made good progress. Yes, my demo  sample supports sending (toggle LED) and subscribing to notifications (button press). You can program the ble_app_blinky sample to another board if you want to try it out.

blinky client log output:

[Kampino]

Hi @Vidar,

my application is working now as expected (not perfect, but I will improve it) 

Thanks for your example