How to notify several characteristics in central

RE: How to notify several characteristics in central

Petter Myhre — Mon, 18 Sep 2017 13:32:14 GMT

The logic that I mentioned in the previous post did not work because, I was not able to sync between central and peripheral (meaning, peripheral transmits too soon and central misses some).

RE: How to notify several characteristics in central

Petter Myhre — Mon, 18 Sep 2017 13:30:37 GMT

3.I'm note sure if you mean by write here. If you mean that you have a characteristic on your peripheral and your peripheral application writes into it with sd_ble_gatts_value_set() the central will not get any notification. If you mean that you have a characteristic on your peripheral and your peripheral application writes into it with sd_ble_gatts_hvx() the central will get a notification. Usually a write is something that the client is doing to the server, where the characteristic is. Please try to use the correct terminology, if not is very difficult to understand what you mean. If you are not sure what the different terms mean, add a new question, and ask.

4.I meant using write command to write to the CCCDs, not to the characteristic values.

RE: How to notify several characteristics in central

Petter Myhre — Mon, 18 Sep 2017 13:30:30 GMT

Yes, I mean write without response in GATT, which is write command in ATT.
ble_app_uart_c uses write command, see ble_nus_c_string_send().

RE: How to notify several characteristics in central

nordicdev — Sat, 16 Sep 2017 23:33:43 GMT

The logic that I mentioned in the previous post did not work because, I was not able to sync between central and peripheral (meaning, peripheral transmits too soon and central misses some). The problem becomes worse when the number of peripherals increase. Please let me know if the following logic is correct:

I have 1 central and 2 peripherals, each having 4 characteristic. My aim is to send data from each of the 4 characteristics from both the peripherals to central and vice versa. But, since the central can have only one characteristic to be notified at a time, I have come up with the following logic - so that I dont have to change the enable notification from one characteristic to another at the central end.

Peripheral and central have 4 characteristics - the uuids of the characteristics match between central and peripheral.
central has notification enabled only for charcteristic 4. In peripheral the first 3 characteristics have write without response and 4th characteristic has notification enabled.
When I want to transmit data in one of the characteristic from peripheral to central, I write respective (different) data to all 4 characteristics. As soon as characteristic 4 is written in peripheral, central gets notified. Now, central reads the characteristic 4 in ble_nus_c_evt and first 3 characteristics using sd_ble_gattc_read. By this way, all 4 characteristics from both the peripherals would not be missed by the central.

RE: How to notify several characteristics in central

nordicdev — Fri, 15 Sep 2017 17:37:45 GMT

Hi Petter, thanks for the reply. Sorry about the indentation.

By "You could of course try to use write command instead." do you mean write command without response? (reference: www.safaribooksonline.com/.../ch04.html).
Could you please share a central and peripheral combo code that uses write command without response?
If I use write command without response during declaration at periperals, will the central get an event when peripheral writes into that characteristics? Or, should the central do polling to find if a new data has been written to each characteristic (when peripheral uses write command without response during declaration)? If so, which register to poll at the central?
If I wanted to use write with response, then, will the following logic work if I have 3 characteristics at the central and peripheral side?

In the peripheral side, make sure that the 3 characteristics are defined with write and not write_wo_response:

char_md.char_props.write         = 1;
char_md.char_props.write_wo_resp = 0;

The peripheral first writes to characteristic 1 and waits till BLE_GATTC_EVT_WRITE_RSP event has been got in the peripheral. The central first runs the routine: ble_nus_c_rx_notif_enable with cccd_configure with the handle of characteristic 1. This would mean that when peripheral writes data to characteristic1, the central would receive notification under : ble_nus_c_on_ble_evt routine with an event id : BLE_GATTC_EVT_HVX with p_ble_evt->evt.gattc_evt.params.hvx.handle == p_ble_nus_c->handles.characteristic1. So, now the central can go ahead and read the data recieved in BLE_NUS_C_EVT_NUS_RX_EVT (in the routine: ble_nus_c_evt_handler). Once the central reads out the data sent by the peripheral, the peripheral would receive a BLE_GATTC_EVT_WRITE_RSP event.

Now, the peripheral would send data in characteristic 2 and wait for BLE_GATTC_EVT_WRITE_RSP to be received. In the central side, once the central receives data in characteristic 1, it would call the routine: ble_nus_c_rx_notif_enable with cccd_configure with the handle of characteristic 2.

Once central receives data in characteristic 2, (the peripheral would receive BLE_GATTC_EVT_WRITE_RSP at the same time), the central would call would call the routine: ble_nus_c_rx_notif_enable with cccd_configure with the handle of characteristic 3 and peripheral would write data to characteristic 3 and wait for BLE_GATTC_EVT_WRITE_RSP to happen, etc. Whenever the peripheral wants to write data to any of the characteristics, the above procedure would be followed. Even if the peripheral wants to write to only 1 characteristic (for example characteristic 3), the peripheral still needs to write dummy data to characteristics 1 and 2 so that the central and peripheral are in sync about which characteristic to be written (by peripheral) and read (by the central).

Is the above logic correct?

RE: How to notify several characteristics in central

Petter Myhre — Mon, 11 Sep 2017 07:59:39 GMT

Can you please try to use the 101010 button when you insert code? Then I don't need to edit every time.

You probably get busy because you are trying to do several write requests at the same time. You can only send one write request at the time, then you have to wait for the response before you send a new one.

RE: How to notify several characteristics in central

nordicdev — Sun, 10 Sep 2017 21:09:50 GMT

Hi Petter, Thanks for the reply. In the central code, in the ble_nus_c_rx_notif_enable, I have configured only one of the characteristics as shown below:

uint32_t ble_nus_c_rx_notif_enable(ble_nus_c_t * p_ble_nus_c)
{
    VERIFY_PARAM_NOT_NULL(p_ble_nus_c);

    if ( (p_ble_nus_c->conn_handle == BLE_CONN_HANDLE_INVALID)
       ||(p_ble_nus_c->handles.nus_rx_debug_cccd_handle == BLE_GATT_HANDLE_INVALID)
			||(p_ble_nus_c->handles.nus_rx_speed_cccd_handle == BLE_GATT_HANDLE_INVALID)
			||(p_ble_nus_c->handles.nus_rx_information_cccd_handle == BLE_GATT_HANDLE_INVALID)
       )
    {
        return NRF_ERROR_INVALID_STATE;
    }

		return cccd_configure(p_ble_nus_c->conn_handle,p_ble_nus_c->handles.nus_rx_speed_cccd_handle, true);

}

I have configured only for 1 characteristic in ble_nus_c_rx_notif_enable because, if I configure for more than 1 characteristic, I get NRF_ERROR_BUSY error. Also, upon discovery event, I assign cccd handles for all the characteristics as shown below:

void ble_nus_c_on_db_disc_evt(ble_nus_c_t * p_ble_nus_c, ble_db_discovery_evt_t * p_evt)
{
    ble_nus_c_evt_t nus_c_evt;
    memset(&nus_c_evt,0,sizeof(ble_nus_c_evt_t));

    ble_gatt_db_char_t * p_chars = p_evt->params.discovered_db.charateristics;

    // Check if the NUS was discovered.
    if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE &&
        p_evt->params.discovered_db.srv_uuid.uuid == BLE_UUID_NUS_SERVICE &&
        p_evt->params.discovered_db.srv_uuid.type == p_ble_nus_c->uuid_type)
    {

        uint32_t i;

        for (i = 0; i < p_evt->params.discovered_db.char_count; i++)
        {
            switch (p_chars[i].characteristic.uuid.uuid)
            {

                case BLE_UUID_NUS_RX_SPEED_CHARACTERISTIC:
                    nus_c_evt.handles.nus_rx_speed_handle = p_chars[i].characteristic.handle_value;
                    nus_c_evt.handles.nus_rx_speed_cccd_handle = p_chars[i].cccd_handle;
                    break;

                case BLE_UUID_NUS_TX_SPEED_CHARACTERISTIC:
                    nus_c_evt.handles.nus_tx_handle_speed = p_chars[i].characteristic.handle_value;
                    break;
								
                case BLE_UUID_NUS_RX_INFORMATION_CHARACTERISTIC:
                    nus_c_evt.handles.nus_rx_information_handle = p_chars[i].characteristic.handle_value;
                    nus_c_evt.handles.nus_rx_information_cccd_handle = p_chars[i].cccd_handle;
                    break;

                case BLE_UUID_NUS_TX_INFORMATION_CHARACTERISTIC:
                    nus_c_evt.handles.nus_tx_handle_information = p_chars[i].characteristic.handle_value;
                    break;								

								
                case BLE_UUID_NUS_RX_DEBUG_CHARACTERISTIC:
                    nus_c_evt.handles.nus_rx_debug_handle = p_chars[i].characteristic.handle_value;
                    nus_c_evt.handles.nus_rx_debug_cccd_handle = p_chars[i].cccd_handle;
                    break;

                case BLE_UUID_NUS_TX_DEBUG_CHARACTERISTIC:
                    nus_c_evt.handles.nus_tx_handle_debug = p_chars[i].characteristic.handle_value;
                    break;		

                case BLE_UUID_NUS_RX_CONTROL_CHARACTERISTIC:
                    nus_c_evt.handles.nus_rx_control_handle = p_chars[i].characteristic.handle_value;
                    nus_c_evt.handles.nus_rx_control_cccd_handle = p_chars[i].cccd_handle;
                    break;

                case BLE_UUID_NUS_TX_CONTROL_CHARACTERISTIC:
                    nus_c_evt.handles.nus_tx_handle_control = p_chars[i].characteristic.handle_value;
                    break;									
								

                default:
                    break;
            }
        }
        if (p_ble_nus_c->evt_handler != NULL)
        {
            nus_c_evt.conn_handle = p_evt->conn_handle;
            nus_c_evt.evt_type    = BLE_NUS_C_EVT_DISCOVERY_COMPLETE;
            p_ble_nus_c->evt_handler(p_ble_nus_c, &nus_c_evt);
        }
    }
}

Also I have used the following routines:

static uint32_t cccd_configure(uint16_t conn_handle, uint16_t cccd_handle, bool enable)
{
    uint8_t buf[BLE_CCCD_VALUE_LEN];

    buf[0] = enable ? BLE_GATT_HVX_NOTIFICATION : 0;
    buf[1] = 0;

    const ble_gattc_write_params_t write_params = {
        .write_op = BLE_GATT_OP_WRITE_REQ,
        .flags    = BLE_GATT_EXEC_WRITE_FLAG_PREPARED_WRITE,
        .handle   = cccd_handle,
        .offset   = 0,
        .len      = sizeof(buf),
        .p_value  = buf
    };

    return sd_ble_gattc_write(conn_handle, &write_params);
}

uint32_t ble_nus_c_handles_assign(ble_nus_c_t * p_ble_nus,
                                  const uint16_t conn_handle,
                                  const ble_nus_c_handles_t * p_peer_handles)
{
    VERIFY_PARAM_NOT_NULL(p_ble_nus);

    p_ble_nus->conn_handle = conn_handle;
    if (p_peer_handles != NULL)
    {
        p_ble_nus->handles.nus_rx_control_cccd_handle = p_peer_handles->nus_rx_control_cccd_handle;
        p_ble_nus->handles.nus_rx_control_handle      = p_peer_handles->nus_rx_control_handle;
        p_ble_nus->handles.nus_tx_handle_control      = p_peer_handles->nus_tx_handle_control;
			
        p_ble_nus->handles.nus_rx_speed_cccd_handle = p_peer_handles->nus_rx_speed_cccd_handle;
        p_ble_nus->handles.nus_rx_speed_handle      = p_peer_handles->nus_rx_speed_handle;
        p_ble_nus->handles.nus_tx_handle_speed      = p_peer_handles->nus_tx_handle_speed;		
			
        p_ble_nus->handles.nus_rx_information_cccd_handle = p_peer_handles->nus_rx_information_cccd_handle;
        p_ble_nus->handles.nus_rx_information_handle      = p_peer_handles->nus_rx_information_handle;
        p_ble_nus->handles.nus_tx_handle_information      = p_peer_handles->nus_tx_handle_information;				
			

        p_ble_nus->handles.nus_rx_debug_cccd_handle = p_peer_handles->nus_rx_debug_cccd_handle;
        p_ble_nus->handles.nus_rx_debug_handle      = p_peer_handles->nus_rx_debug_handle;
        p_ble_nus->handles.nus_tx_handle_debug      = p_peer_handles->nus_tx_handle_debug;			
    }
    return NRF_SUCCESS;
}

RE: How to notify several characteristics in central

Petter Myhre — Sun, 10 Sep 2017 09:43:47 GMT

I am not talking about enabling read and write permissions, I'm talking about the client (central) enabling notifications by writing 0x0001 to the CCCD of the characteristics you want to notify.

Have you done this on all characteristics you want to be able to notify? Or only one?

RE: How to notify several characteristics in central

nordicdev — Sat, 09 Sep 2017 18:31:37 GMT

Hi Petter, Thanks for the reply. Yes, I am enabling the read and write permissions to the peripherals for all the characteristics. I use the following for adding all characteristics at the peripheral side:

static uint32_t rx_char_add_information(ble_nus_t * p_nus, const ble_nus_init_t * p_nus_init)
{
    /**@snippet [Adding proprietary characteristic to S110 SoftDevice] */
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_md_t cccd_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;

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

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);

    cccd_md.vloc = BLE_GATTS_VLOC_STACK;

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

    char_md.char_props.notify = 1;
    char_md.p_char_user_desc  = NULL;
    char_md.p_char_pf         = NULL;
    char_md.p_user_desc_md    = NULL;
    char_md.p_cccd_md         = &cccd_md;
    char_md.p_sccd_md         = NULL;

    ble_uuid.type = p_nus->uuid_type;
    ble_uuid.uuid = BLE_UUID_NUS_RX_INFORMATION_CHARACTERISTIC;

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

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);

    attr_md.vloc    = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 0;
    attr_md.vlen    = 1;

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

    attr_char_value.p_uuid    = &ble_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len  = sizeof(uint8_t);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len   = BLE_NUS_MAX_RX_CHAR_LEN;

    return sd_ble_gatts_characteristic_add(p_nus->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_nus->rx_handles_information);
    /**@snippet [Adding proprietary characteristic to S110 SoftDevice] */
}

But, at the central side, I get notified when a peripheral has written to one particular characteristic(which is the same characteristic used in ble_nus_c_rx_notif_enable). In other words, I dont get notified at the central end when the peripheral writes to the any characteristic that is not used in ble_nus_c_rx_notif_enable.

RE: How to notify several characteristics in central

Petter Myhre — Fri, 08 Sep 2017 09:16:19 GMT

Ok. What is the problem? Have you enabled notifications in all peripherals by writing to their CCCD?

RE: How to notify several characteristics in central

nordicdev — Thu, 07 Sep 2017 23:12:02 GMT

Hi Petter, Thanks for the reply. But, I need to get notifications at the central code, whenever a characteristic gets written by any of the peripherals that are already in connected mode with the central.

RE: How to notify several characteristics in central

Petter Myhre — Wed, 30 Aug 2017 11:02:16 GMT

If you are using write request you have to enable one notification at the time, because you can only do one write request at the time, you have to wait for the response before you send a new one.

And I think you must use write request to write to descriptors. You could of course try to use write command instead.