Esempio n. 1
0
uint32_t ble_bps_measurement_send(ble_bps_t * p_bps, ble_bps_meas_t * p_bps_meas)
{
    uint32_t err_code;

    // Send value if connected
    if (p_bps->conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        uint8_t                encoded_bps_meas[MAX_BPM_LEN];
        uint16_t               len;
        uint16_t               hvx_len;
        ble_gatts_hvx_params_t hvx_params;
        
        len     = bps_measurement_encode(p_bps, p_bps_meas, encoded_bps_meas);
        hvx_len = len;

        memset(&hvx_params, 0, sizeof(hvx_params));
        
        hvx_params.handle = p_bps->meas_handles.value_handle;
        hvx_params.type   = BLE_GATT_HVX_INDICATION;
        hvx_params.offset = 0;
        hvx_params.p_len  = &hvx_len;
        hvx_params.p_data = encoded_bps_meas;
        
        err_code = sd_ble_gatts_hvx(p_bps->conn_handle, &hvx_params);
        if ((err_code == NRF_SUCCESS) && (hvx_len != len))
        {
            err_code = NRF_ERROR_DATA_SIZE;
        }
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
    }

    return err_code;
}
Esempio n. 2
0
File: ble_hrs.c Progetto: vikev/SLIP
uint32_t ble_hrs_heart_rate_measurement_send(ble_hrs_t * p_hrs, uint16_t heart_rate)
{
    uint32_t err_code;

    // Send value if connected and notifying
    if (p_hrs->conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        uint8_t                encoded_hrm[MAX_HRM_LEN];
        uint16_t               len;
        uint16_t               hvx_len;
        ble_gatts_hvx_params_t hvx_params;

        len     = hrm_encode(p_hrs, heart_rate, encoded_hrm);
        hvx_len = len;

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

        hvx_params.handle = p_hrs->hrm_handles.value_handle;
        hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.offset = 0;
        hvx_params.p_len  = &hvx_len;
        hvx_params.p_data = encoded_hrm;

        err_code = sd_ble_gatts_hvx(p_hrs->conn_handle, &hvx_params);
        if ((err_code == NRF_SUCCESS) && (hvx_len != len))
        {
            err_code = NRF_ERROR_DATA_SIZE;
        }
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
    }

    return err_code;
}
Esempio n. 3
0
uint32_t ble_dfu_bytes_rcvd_report(ble_dfu_t * p_dfu, uint32_t num_of_firmware_bytes_rcvd)
{
    if (p_dfu == NULL)
    {
        return NRF_ERROR_NULL;
    }
    
    if ((p_dfu->conn_handle == BLE_CONN_HANDLE_INVALID) || !m_is_dfu_service_initialized)
    {
        return NRF_ERROR_INVALID_STATE;
    }
    
    ble_gatts_hvx_params_t hvx_params;
    uint16_t               index = 0;

    // Encode the Op Code.
    m_notif_buffer[index++] = OP_CODE_RESPONSE;

    // Encode the Reqest Op Code.
    m_notif_buffer[index++] = OP_CODE_IMAGE_SIZE_REQ;

    // Encode the Response Value.
    m_notif_buffer[index++] = (uint8_t)BLE_DFU_RESP_VAL_SUCCESS;

    index += uint32_encode(num_of_firmware_bytes_rcvd, &m_notif_buffer[index]);

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

    hvx_params.handle   = p_dfu->dfu_ctrl_pt_handles.value_handle;
    hvx_params.type     = BLE_GATT_HVX_NOTIFICATION;
    hvx_params.offset   = 0;
    hvx_params.p_len    = &index;
    hvx_params.p_data   = m_notif_buffer;

    return sd_ble_gatts_hvx(p_dfu->conn_handle, &hvx_params);
}
Esempio n. 4
0
uint32_t sendDataPHYSENS(ble_pss_t * p_pss)
{
    uint32_t err_code = NRF_SUCCESS;
    uint16_t len = (SENSOR_ROW_SIZE);
    uint8_t data[SENSOR_ROW_SIZE] = {0};
    uint8_t memory[6] = {0}; // 3 datas of 6 bytes each
    uint8_t iter, iter_data;
    uint16_t new_remember = 0;
    uint16_t add = 0;
    uint16_t skip = g_index_skip;

    if ((p_pss->conn_handle != BLE_CONN_HANDLE_INVALID) && p_pss->is_notification_supported)
    {


        ble_gatts_hvx_params_t hvx_params;

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

        hvx_params.handle   = p_pss->phy_sen_level_handles.value_handle;
        hvx_params.type     = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.p_len    = &len;
        switch (ble_mode) {

        case BLE_STICK_MODE:
            if (g_state == 2) {
                data[0] = STICK_MOMENT;
                data[1] = g_battery_int;
                data[2] = 1;
                for (iter=0; iter<10; iter++) {
                    data[3+iter] = g_data_send[iter];
                }
                g_state = 3;
            } else if (g_state == 3) {
                data[0] = STICK_MOMENT;
                data[1] = g_battery_int;
                data[2] = 2;
                for (iter=10; iter<22; iter++) {
                    data[3+iter-10] = g_data_send[iter];
                }
                g_state = 0; //RESTART

            } else {
                //TODO, put code from settings
                //Send settings
                /*data[0] = STICK_MOMENT;
                data[1] = g_battery_int;
                for (iter=0; iter<14; iter++) {
                    data[2+iter] = g_data_send[iter];
                }*/
                data[0] = SETTINGS_READ;
                data[1] = g_battery_int;
                for (iter=0; iter<18; iter++) {
                    data[2+iter] = g_settings[iter];
                }

            }
            break;

        case BLE_SETTINGS_MODE:
            data[0] = SETTINGS_READ;
            data[1] = g_battery_int;
            for (iter=0; iter<18; iter++) {
                data[2+iter] = g_settings[iter];
            }
            break;
        case BLE_CALIB_AXIS_MODE:
            data[0] = CALIB_OUTPUT;
            data[1] = g_battery_int;
            for (iter=0; iter<8; iter++) {
                data[2+iter] = g_calib_axis[iter];
            }
            for (iter=8; iter<18; iter++) {
                data[2+iter] = 0;
            }
            break;
        case BLE_FREE_MODE:
        case BLE_OTHER_MODE:
        case BLE_SHOT_MODE:
            // TODO mode magement
            // Draft mode and real mode mangement
            // Indexing later
            switch(g_state) {
            case 0:
            case 1:

                data[0] = DATA_DRAFT;
                data[1] = g_battery_int;

                for (iter_data = 0; iter_data<3; iter_data++) {
                    for (iter=0; iter<6; iter++) {
                        data[2+iter + (iter_data*6)] = g_data_send[iter + (iter_data*6)];
                    }
                }
                break;
            case 2:
                data[0] = DATA_START;
                data[1] = g_battery_int;
                // 300 for 30, but 32 indexes system.
                // Take ratio (300 / (30/32))
                //TODO
                if (g_remember < 320) {
                    g_remember = BR25S_CIRCULAR_BUFFER - (320-g_remember);
                } else {
                    g_remember -= 320;
                }
                g_shot_br25s_index = 0;
                break;
            case 3:
                data[0] = DATA;
                data[1] = g_battery_int;
                break;
            case 4:
                data[0] = DATA_END;
                data[1] = g_battery_int;
                break;
            }

            if (g_state >= 2) {
                new_remember = g_remember;

                for (iter_data=0; iter_data<3; iter_data++) {

                    getDatas(memory, 6, new_remember);

                    new_remember += g_skip[g_index_skip % 5];
                    add += g_skip[g_index_skip % 5];
                    g_index_skip++;

                    if (new_remember >= BR25S_CIRCULAR_BUFFER) {
                        new_remember = 0;
                    }

                    for (iter=0; iter<6; iter++) {
                        data[2+iter + (iter_data*6)] = memory[iter];
                    }
                }
            }

            break;
        }
        hvx_params.p_data = data;

        err_code = sd_ble_gatts_hvx(p_pss->conn_handle, &hvx_params);



        if (ble_mode == BLE_STICK_MODE && g_state <= 1) {
            return NRF_ERROR_INVALID_STATE; // Send only one data
        } else if (ble_mode == BLE_STICK_MODE) {
            return err_code;
        }

        // Add only if complete data
        if (ble_mode == BLE_SHOT_MODE && err_code == NRF_SUCCESS && g_state >= 2) {

            if (g_state == 2) {
                g_state = 3;

            } else if (g_state == 4) {
                g_state = 0;
                g_real_index = 0; //Flush everything
                g_valid = 1;
                g_index_skip = 0;
            }

            g_remember = new_remember;
            g_shot_br25s_index += add;
            if (g_remember >= BR25S_CIRCULAR_BUFFER)
                g_remember == 0;

            if (g_state == 3) {
                // 18 left + 2 extra(Nothing)
                if (g_shot_br25s_index >= BR25S_CIRCULAR_BUFFER - 20) {
                    // This sample and the last one
                    g_state = 4;
                }
            }
        } else if (g_state >= 2) {
            // Reinit some value
            g_index_skip = skip;
        }
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
    }


    if ((ble_mode == BLE_SHOT_MODE || ble_mode == BLE_FREE_MODE) && g_state <= 1) {
        return NRF_ERROR_INVALID_STATE; // Send only one data
    }

    return err_code;
}
Esempio n. 5
0
/**@brief Function for sending response from Specific Operation Control Point.
 *
 * @param[in]   p_cgms        Service instance.
 * @param[in]   p_racp_val   RACP value to be sent.
 */
static void racp_send(nrf_ble_cgms_t * p_cgms, ble_racp_value_t * p_racp_val)
{
    uint32_t               err_code;
    uint8_t                encoded_resp[25];
    uint8_t                len;
    uint16_t               hvx_len;
    ble_gatts_hvx_params_t hvx_params;

    if (
        (p_cgms->cgms_com_state != STATE_RACP_RESPONSE_PENDING)
        &&
        (p_cgms->racp_data.racp_proc_records_reported_since_txcomplete > 0)
       )
    {
        p_cgms->cgms_com_state = STATE_RACP_RESPONSE_PENDING;
        return;
    }

    // Send indication
    len     = ble_racp_encode(p_racp_val, encoded_resp);
    hvx_len = len;

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

    hvx_params.handle = p_cgms->char_handles.racp.value_handle;
    hvx_params.type   = BLE_GATT_HVX_INDICATION;
    hvx_params.offset = 0;
    hvx_params.p_len  = &hvx_len;
    hvx_params.p_data = encoded_resp;

    err_code = sd_ble_gatts_hvx(p_cgms->conn_handle, &hvx_params);

    // Error handling
    if ((err_code == NRF_SUCCESS) && (hvx_len != len))
    {
        err_code = NRF_ERROR_DATA_SIZE;
    }

    switch (err_code)
    {
        case NRF_SUCCESS:
            // Wait for HVC event
            p_cgms->cgms_com_state = STATE_RACP_RESPONSE_IND_VERIF;
            break;

        case BLE_ERROR_NO_TX_PACKETS:
            // Wait for TX_COMPLETE event to retry transmission
            p_cgms->cgms_com_state = STATE_RACP_RESPONSE_PENDING;
            break;

        case NRF_ERROR_INVALID_STATE:
            // Make sure state machine returns to the default state
            p_cgms->cgms_com_state = STATE_NO_COMM;
            break;

        default:
            // Report error to application
            if (p_cgms->error_handler != NULL)
            {
                p_cgms->error_handler(err_code);
            }

            // Make sure state machine returns to the default state
            p_cgms->cgms_com_state = STATE_NO_COMM;
            break;
    }
}
Esempio n. 6
0
/**@brief Function for handling the Disconnect event.
 *
 * @param[in] p_si7021  si7021 Service structure.
 * @param[in]   hum  Relative Humidity Raw 16-Bit.
 * @param[in]   temp Temperature Raw 16-Bit.
 */
uint32_t ble_si7021_sensor_update(ble_si7021_t * p_si7021, uint16_t hum, uint16_t temp) {
	uint8_t encoded_data[BLE_si7021_VALUE_MAX_LEN];
	//uint8_t len;

    if (p_si7021 == NULL) {
        return NRF_ERROR_NULL;
    }

    uint32_t err_code = NRF_SUCCESS;
    ble_gatts_value_t gatts_value;

    if ((hum != p_si7021->last_humraw && hum != 0) || (temp != p_si7021->last_tempraw && temp != 0)) {
    	NRF_LOG_DEBUG("ble_si7021_sensor_update %x,%x\n\r",hum,temp);

	    uint16_encode(hum,&encoded_data[0]);
	    uint16_encode(temp,&encoded_data[2]);

        // Initialize value struct.
        memset(&gatts_value, 0, sizeof(gatts_value));

        gatts_value.len     = BLE_si7021_VALUE_MAX_LEN;
        gatts_value.offset  = 0;
        gatts_value.p_value = &encoded_data[0];

    	NRF_LOG_DEBUG("sd_ble_gatts_value_set %x,%x\n\r",p_si7021->conn_handle,p_si7021->value_char_handles.value_handle);
        // Update database. Set the value of a given attribute
        err_code = sd_ble_gatts_value_set(p_si7021->conn_handle,
        		                          p_si7021->value_char_handles.value_handle,
                                          &gatts_value);
    	NRF_LOG_DEBUG("sd_ble_gatts_value_set =%d\n\r",err_code);
        if (err_code == NRF_SUCCESS) {
            // save new temperature value.
        	p_si7021->last_humraw = hum;
        	p_si7021->last_tempraw = temp;
        } else {
            return err_code;
        }

        // Send value if connected and notifying.
        if (p_si7021->conn_handle != BLE_CONN_HANDLE_INVALID) {
            ble_gatts_hvx_params_t hvx_params;

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

            hvx_params.handle = p_si7021->value_char_handles.value_handle;
            hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;
            hvx_params.offset = gatts_value.offset;
            hvx_params.p_len  = &gatts_value.len;
            hvx_params.p_data = gatts_value.p_value;

        	NRF_LOG_DEBUG("sd_ble_gatts_hvx\n\r");
            // Notify or Indicate an attribute value
            err_code = sd_ble_gatts_hvx(p_si7021->conn_handle, &hvx_params);
        	NRF_LOG_DEBUG("sd_ble_gatts_hvx =%d\n\r",err_code);
        } else {
            err_code = NRF_ERROR_INVALID_STATE;
        }
    }

    return err_code;
}
Esempio n. 7
0
ble_error_t nRF5xGattServer::write(Gap::Handle_t connectionHandle, GattAttribute::Handle_t attributeHandle, const uint8_t buffer[], uint16_t len, bool localOnly)
{
    ble_error_t returnValue = BLE_ERROR_NONE;

    ble_gatts_value_t value = {
        /* .len     = */ len,
        /* .offset  = */ 0,
        /* .p_value = */ const_cast<uint8_t *>(buffer),
    };

    if (localOnly) {
        /* Only update locally regardless of notify/indicate */
        ASSERT_INT( ERROR_NONE,
                    sd_ble_gatts_value_set(connectionHandle, attributeHandle, &value),
                    BLE_ERROR_PARAM_OUT_OF_RANGE );
        return BLE_ERROR_NONE;
    }

    int characteristicIndex = resolveValueHandleToCharIndex(attributeHandle);
    if ((characteristicIndex != -1) &&
        (p_characteristics[characteristicIndex]->getProperties() & (GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_INDICATE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY))) {
        /* HVX update for the characteristic value */
        ble_gatts_hvx_params_t hvx_params;

        hvx_params.handle = attributeHandle;
        hvx_params.type   =
            (p_characteristics[characteristicIndex]->getProperties() & GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY) ? BLE_GATT_HVX_NOTIFICATION : BLE_GATT_HVX_INDICATION;
        hvx_params.offset = 0;
        hvx_params.p_data = const_cast<uint8_t *>(buffer);
        hvx_params.p_len  = &len;

        if (connectionHandle == BLE_CONN_HANDLE_INVALID) { /* use the default connection handle if the caller hasn't specified a valid connectionHandle. */
            nRF5xGap &gap = (nRF5xGap &) nRF5xn::Instance(BLE::DEFAULT_INSTANCE).getGap();
            connectionHandle = gap.getConnectionHandle();
        }

        bool updatesEnabled = false;
        if (connectionHandle != BLE_CONN_HANDLE_INVALID) {
            ble_error_t err = areUpdatesEnabled(connectionHandle, attributeHandle, &updatesEnabled);

            // FIXME: The softdevice allocates and populates CCCD when the client
            // interract with them. Checking for updates may return an out of
            // range error in such case.
            if(err && err != BLE_ERROR_PARAM_OUT_OF_RANGE) {
                return err;
            }
        }

        bool updates_permitted = false;
        ble_gap_conn_sec_t connection_security;
        uint32_t err = sd_ble_gap_conn_sec_get(connectionHandle, &connection_security);
        if (!err &&
            (connection_security.sec_mode.sm == 1) &&
            (connection_security.sec_mode.lv >=  p_characteristics[characteristicIndex]->getUpdateSecurityRequirement().value())) {
            updates_permitted = true;
        }

        if (updatesEnabled && updates_permitted) {
            error_t error = (error_t) sd_ble_gatts_hvx(connectionHandle, &hvx_params);
            if (error != ERROR_NONE) {
                switch (error) {
                    case ERROR_BLE_NO_TX_BUFFERS: /*  Notifications consume application buffers. The return value can be used for resending notifications. */
                    case ERROR_BUSY:
                        returnValue = BLE_STACK_BUSY;
                        break;

                    case ERROR_INVALID_STATE:
                    case ERROR_BLEGATTS_SYS_ATTR_MISSING:
                        returnValue = BLE_ERROR_INVALID_STATE;
                        break;

                    default :
                        ASSERT_INT( ERROR_NONE,
                                    sd_ble_gatts_value_set(connectionHandle, attributeHandle, &value),
                                    BLE_ERROR_PARAM_OUT_OF_RANGE );

                        /* Notifications consume application buffers. The return value can
                        * be used for resending notifications. */
                        returnValue = BLE_STACK_BUSY;
                        break;
                }
            }
        } else {
            returnValue = set_attribute_value(connectionHandle, attributeHandle, &value);
        }
    } else {
        returnValue = set_attribute_value(connectionHandle, attributeHandle, &value);
    }

    return returnValue;
}
Esempio n. 8
0
uint32_t mesh_srv_char_val_set(uint8_t index, uint8_t* data, uint16_t len, bool update_sender)
{
    if (!is_initialized)
    {
        return NRF_ERROR_INVALID_STATE;
    }
    
    if (index > g_mesh_service.value_count || index == 0)
    {
        return NRF_ERROR_INVALID_ADDR;
    }
    
    if (len > MAX_VALUE_LENGTH)
    {
        return NRF_ERROR_INVALID_LENGTH;
    }
    uint32_t error_code = 0;
    
    mesh_char_metadata_t* ch_md = &g_mesh_service.char_metadata[index - 1];
    
    /* this is now a new version of this data, signal to the rest of the mesh */
    ++ch_md->version_number;
    
    bool first_time = 
        (ch_md->flags & 
        (1 << MESH_MD_FLAGS_USED_POS)) == 0;
    
    if (first_time)
    {
        ch_md->flags |= 
            (1 << MESH_MD_FLAGS_INITIALIZED_POS) |
            (1 << MESH_MD_FLAGS_USED_POS);
        trickle_init(&ch_md->trickle);
    }
    else
    {
        trickle_rx_inconsistent(&ch_md->trickle);
    }
    
    if (update_sender || first_time)
    {
        ble_gap_addr_t my_addr;
        sd_ble_gap_address_get(&my_addr);
        memcpy(&ch_md->last_sender_addr, &my_addr, sizeof(ble_gap_addr_t));
        ch_md->flags |= (1 << MESH_MD_FLAGS_IS_ORIGIN_POS);
    }
        
    /* notify the connected central node, if any */
    if (g_active_conn_handle != CONN_HANDLE_INVALID)
    {
        ble_gatts_hvx_params_t notify_params;
        notify_params.handle = ch_md->char_value_handle;
        notify_params.offset = 0;
        notify_params.p_data = data;
        notify_params.p_len = &len;
        notify_params.type = BLE_GATT_HVX_NOTIFICATION;
        error_code = sd_ble_gatts_hvx(g_active_conn_handle, &notify_params);
        if (error_code != NRF_SUCCESS)
        {
            if (error_code == BLE_ERROR_INVALID_CONN_HANDLE)
            {
                g_active_conn_handle = CONN_HANDLE_INVALID;
            }
            else if (error_code == BLE_GATTS_EVT_SYS_ATTR_MISSING)
            {
                sd_ble_gatts_sys_attr_set(g_active_conn_handle, NULL, 0);
            }
            else
            {
                return NRF_ERROR_INTERNAL;
            }
        }
    }
    else
    {
        error_code = sd_ble_gatts_value_set(
            ch_md->char_value_handle, 
            0, &len, data);
        
        if (error_code != NRF_SUCCESS)
        {
            return NRF_ERROR_INTERNAL;
        }
    }
    
    return NRF_SUCCESS;
}
/**@brief Function for decoding a command packet with RPC_SD_BLE_GATTS_HVX opcode.
 *
 * This function will decode the command, call the BLE Stack API, and also send command response
 * to the peer through the the transport layer.
 *
 * @param[in] p_command         The encoded structure that needs to be decoded and passed on
 *                              to the BLE Stack API.
 * @param[in] command_len       The length of the encoded command read from transport layer.
 *
 * @retval NRF_SUCCESS               If the decoding of the command was successful, the SoftDevice
 *                                   API was called, and the command response was sent to peer,
 *                                   otherwise an error code.
 * @retval NRF_ERROR_INVALID_LENGTH  If the content length of the packet is not conforming to the
 *                                   codec specification.
 */
static uint32_t gatts_hvx_handle(uint8_t * const p_command, uint32_t command_len)
{
    uint32_t               err_code;
    uint16_t               conn_handle;
    ble_gatts_hvx_params_t hvx_params;
    uint8_t                resp_data[sizeof(uint16_t)];

    uint16_t                 hvx_params_data_length = 0;
    uint32_t                 index                  = 0;
    ble_gatts_hvx_params_t * p_hvx_params           = NULL;

    conn_handle  = uint16_decode(&p_command[index]);
    index       += sizeof(uint16_t);
    RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_HVX);

    if (p_command[index++] == RPC_BLE_FIELD_PRESENT)
    {
        hvx_params.handle  = uint16_decode(&p_command[index]);
        index             += sizeof(uint16_t);
        hvx_params.type    = p_command[index++];
        hvx_params.offset  = uint16_decode(&p_command[index]);
        index             += sizeof(uint16_t);
        RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_HVX);
        if (p_command[index++] == RPC_BLE_FIELD_PRESENT)
        {
            hvx_params_data_length  = uint16_decode(&p_command[index]);
            index                  += sizeof(uint16_t);
            hvx_params.p_len        = &hvx_params_data_length;
        }
        else
        {
            hvx_params.p_len = NULL;
        }
        RPC_DECODER_LENGTH_CHECK(command_len,
                                 (index + hvx_params_data_length),
                                 SD_BLE_GATTS_HVX);

        if (p_command[index++] == RPC_BLE_FIELD_PRESENT)
        {
            hvx_params.p_data = &(p_command[index]);
        }
        else
        {
            hvx_params.p_data = NULL;
        }
        p_hvx_params = &hvx_params;
    }

    RPC_DECODER_LENGTH_CHECK(command_len, index, SD_BLE_GATTS_HVX);

    err_code = sd_ble_gatts_hvx(conn_handle, p_hvx_params);

    if (err_code == NRF_SUCCESS)
    {
        if (p_hvx_params != NULL && p_hvx_params->p_len != NULL)
        {
            UNUSED_VARIABLE(uint16_encode(*(p_hvx_params->p_len), resp_data));
            return ble_rpc_cmd_resp_data_send(SD_BLE_GATTS_HVX,
                                              err_code,
                                              resp_data,
                                              sizeof(resp_data));
        }
    }

    return ble_rpc_cmd_resp_send(SD_BLE_GATTS_HVX, err_code);
}