573 lines
20 KiB
C
573 lines
20 KiB
C
|
/**
|
||
|
|
* Copyright (c) 2012 - 2020, Nordic Semiconductor ASA
|
||
|
|
*
|
||
|
|
* All rights reserved.
|
||
|
|
*
|
||
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
||
|
|
* are permitted provided that the following conditions are met:
|
||
|
|
*
|
||
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
||
|
|
* list of conditions and the following disclaimer.
|
||
|
|
*
|
||
|
|
* 2. Redistributions in binary form, except as embedded into a Nordic
|
||
|
|
* Semiconductor ASA integrated circuit in a product or a software update for
|
||
|
|
* such product, must reproduce the above copyright notice, this list of
|
||
|
|
* conditions and the following disclaimer in the documentation and/or other
|
||
|
|
* materials provided with the distribution.
|
||
|
|
*
|
||
|
|
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
|
||
|
|
* contributors may be used to endorse or promote products derived from this
|
||
|
|
* software without specific prior written permission.
|
||
|
|
*
|
||
|
|
* 4. This software, with or without modification, must only be used with a
|
||
|
|
* Nordic Semiconductor ASA integrated circuit.
|
||
|
|
*
|
||
|
|
* 5. Any software provided in binary form under this license must not be reverse
|
||
|
|
* engineered, decompiled, modified and/or disassembled.
|
||
|
|
*
|
||
|
|
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
|
||
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||
|
|
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||
|
|
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
|
||
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
||
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
#include "sdk_common.h"
|
||
|
|
#if NRF_MODULE_ENABLED(NRF_BLE_CONN_PARAMS)
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include "nrf.h"
|
||
|
|
#include "sdk_errors.h"
|
||
|
|
#include "ble_hci.h"
|
||
|
|
#include "ble_err.h"
|
||
|
|
#include "ble_conn_params.h"
|
||
|
|
#include "ble_srv_common.h"
|
||
|
|
#include "ble_conn_state.h"
|
||
|
|
#include "nrf_sdh_ble.h"
|
||
|
|
#include "app_timer.h"
|
||
|
|
#include "app_util.h"
|
||
|
|
|
||
|
|
|
||
|
|
#define NRF_BLE_CONN_PARAMS_INSTANCE_COUNT NRF_SDH_BLE_PERIPHERAL_LINK_COUNT //!< The number of @ref ble_conn_params_instance_t instances kept by the conn_params module.
|
||
|
|
|
||
|
|
#if (NRF_BLE_CONN_PARAMS_INSTANCE_COUNT < 1)
|
||
|
|
#error Invalid NRF_SDH_BLE_PERIPHERAL_LINK_COUNT value. Set it in SDK config (nrf_sdh_ble).
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/** @brief Each peripheral link has such an instance associated with it.
|
||
|
|
*/
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
uint16_t conn_handle; //!< The connection handle of this link. If this is @ref BLE_CONN_HANDLE_INVALID, the instance is free.
|
||
|
|
app_timer_id_t timer_id; //!< The ID of the timer associated with this link.
|
||
|
|
uint8_t update_count; //!< The number of times the connection parameters have been attempted negotiated on this link.
|
||
|
|
uint8_t params_ok; //!< Whether the current connection parameters on this link are acceptable according to the @p preferred_conn_params, and configured maximum deviations.
|
||
|
|
ble_gap_conn_params_t preferred_conn_params; //!< The desired connection parameters for this link.
|
||
|
|
} ble_conn_params_instance_t;
|
||
|
|
|
||
|
|
static app_timer_t m_timer_data[NRF_BLE_CONN_PARAMS_INSTANCE_COUNT] = {{{0}}}; //!< Data needed for timers.
|
||
|
|
static ble_conn_params_instance_t m_conn_params_instances[NRF_BLE_CONN_PARAMS_INSTANCE_COUNT] = {{0}}; //!< Configuration data for each connection.
|
||
|
|
static ble_conn_params_init_t m_conn_params_config; //!< Configuration as provided by the application during intialization.
|
||
|
|
static ble_gap_conn_params_t m_preferred_conn_params; //!< The preferred connection parameters as specified during initialization.
|
||
|
|
//lint -esym(551, m_preferred_conn_params) "Not accessed"
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for retrieving the conn_params instance belonging to a conn_handle
|
||
|
|
*
|
||
|
|
* @params[in] conn_handle The connection handle to retrieve the instance of.
|
||
|
|
*
|
||
|
|
* @return A pointer to the instance, or NULL if no instance was found with that conn_handle.
|
||
|
|
*/
|
||
|
|
static ble_conn_params_instance_t * instance_get(uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
//lint -save -e681 "Loop not entered" when NRF_BLE_CONN_PARAMS_INSTANCE_COUNT is 0
|
||
|
|
for (uint32_t i = 0; i < NRF_BLE_CONN_PARAMS_INSTANCE_COUNT; i++)
|
||
|
|
{
|
||
|
|
if (m_conn_params_instances[i].conn_handle == conn_handle)
|
||
|
|
{
|
||
|
|
return &m_conn_params_instances[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//lint -restore
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for initializing an instance, and associating it with a conn_handle.
|
||
|
|
*
|
||
|
|
* @params[in] p_instance The instance to initialize and associate.
|
||
|
|
* @params[in] conn_handle The connection handle to associate with.
|
||
|
|
*/
|
||
|
|
static __INLINE void instance_claim(ble_conn_params_instance_t * p_instance, uint16_t conn_handle)
|
||
|
|
{
|
||
|
|
p_instance->conn_handle = conn_handle;
|
||
|
|
p_instance->update_count = 0;
|
||
|
|
p_instance->preferred_conn_params = m_preferred_conn_params;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for freeing an instance.
|
||
|
|
*
|
||
|
|
* @params[in] p_instance The instance to free.
|
||
|
|
*/
|
||
|
|
static __INLINE void instance_free(ble_conn_params_instance_t * p_instance)
|
||
|
|
{
|
||
|
|
p_instance->conn_handle = BLE_CONN_HANDLE_INVALID;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for validating a set of connection parameters against the preferred parameters.
|
||
|
|
*
|
||
|
|
* @param[in] p_preferred_conn_params The desired parameters.
|
||
|
|
* @param[in] p_actual_conn_params The parameters to validate.
|
||
|
|
* @param[in] max_slave_latency_err The amount of discrepancy in slave latency, in number of
|
||
|
|
* connection intervals, that will be accepted.
|
||
|
|
* @param[in] max_sup_timeout_err The amount of discrepancy in supervision timeout, in tens of
|
||
|
|
* milliseconds, that will be accepted.
|
||
|
|
*
|
||
|
|
* @return Whether the params in @p p_actual_conn_params are acceptable given the other parameters.
|
||
|
|
*/
|
||
|
|
static bool is_conn_params_ok(ble_gap_conn_params_t const * p_preferred_conn_params,
|
||
|
|
ble_gap_conn_params_t const * p_actual_conn_params,
|
||
|
|
uint16_t max_slave_latency_err,
|
||
|
|
uint16_t max_sup_timeout_err)
|
||
|
|
{
|
||
|
|
uint32_t max_allowed_sl = p_preferred_conn_params->slave_latency + max_slave_latency_err;
|
||
|
|
uint32_t min_allowed_sl = p_preferred_conn_params->slave_latency
|
||
|
|
- MIN(max_slave_latency_err, p_preferred_conn_params->slave_latency);
|
||
|
|
uint32_t max_allowed_to = p_preferred_conn_params->conn_sup_timeout + max_sup_timeout_err;
|
||
|
|
uint32_t min_allowed_to = p_preferred_conn_params->conn_sup_timeout
|
||
|
|
- MIN(max_sup_timeout_err, p_preferred_conn_params->conn_sup_timeout);
|
||
|
|
|
||
|
|
// Check if interval is within the acceptable range.
|
||
|
|
// NOTE: Using max_conn_interval in the received event data because this contains
|
||
|
|
// the client's connection interval.
|
||
|
|
if ((p_actual_conn_params->max_conn_interval < p_preferred_conn_params->min_conn_interval)
|
||
|
|
|| (p_actual_conn_params->max_conn_interval > p_preferred_conn_params->max_conn_interval))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if slave latency is within the acceptable deviation.
|
||
|
|
if ((p_actual_conn_params->slave_latency < min_allowed_sl)
|
||
|
|
|| (p_actual_conn_params->slave_latency > max_allowed_sl))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if supervision timeout is within the acceptable deviation.
|
||
|
|
if ((p_actual_conn_params->conn_sup_timeout < min_allowed_to)
|
||
|
|
|| (p_actual_conn_params->conn_sup_timeout > max_allowed_to))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static void send_error_evt(ret_code_t err_code)
|
||
|
|
{
|
||
|
|
if (m_conn_params_config.error_handler != NULL)
|
||
|
|
{
|
||
|
|
m_conn_params_config.error_handler(err_code);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for sending a conn_param_update request on-air, and handling errors.
|
||
|
|
*
|
||
|
|
* @param[in] conn_handle Connection to send request on.
|
||
|
|
* @param[in] p_new_conn_params Connection parameters to request.
|
||
|
|
*
|
||
|
|
* @return Whether the request was successfully sent.
|
||
|
|
*/
|
||
|
|
static bool send_update_request(uint16_t conn_handle, ble_gap_conn_params_t * p_new_conn_params)
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
|
||
|
|
err_code = sd_ble_gap_conn_param_update(conn_handle, p_new_conn_params);
|
||
|
|
if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY)) // NRF_ERROR_BUSY means another conn_param_update request is pending.
|
||
|
|
{
|
||
|
|
send_error_evt(err_code);
|
||
|
|
}
|
||
|
|
|
||
|
|
return (err_code == NRF_SUCCESS);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function called after conn_params_update_delay has happened. This is triggered by app_timer.
|
||
|
|
*
|
||
|
|
* @param[in] p_context Context identifying which connection this is for.
|
||
|
|
*/
|
||
|
|
static void update_timeout_handler(void * p_context)
|
||
|
|
{
|
||
|
|
uint32_t conn_handle = (uint32_t)p_context;
|
||
|
|
ble_conn_params_instance_t * p_instance = instance_get(conn_handle);
|
||
|
|
|
||
|
|
if (p_instance != NULL)
|
||
|
|
{
|
||
|
|
// Check if we have reached the maximum number of attempts
|
||
|
|
if (p_instance->update_count < m_conn_params_config.max_conn_params_update_count)
|
||
|
|
{
|
||
|
|
bool update_sent = send_update_request(conn_handle, &p_instance->preferred_conn_params);
|
||
|
|
if (update_sent)
|
||
|
|
{
|
||
|
|
p_instance->update_count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
p_instance->update_count = 0;
|
||
|
|
|
||
|
|
// Negotiation failed, disconnect automatically if this has been configured
|
||
|
|
if (m_conn_params_config.disconnect_on_fail)
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
|
||
|
|
err_code = sd_ble_gap_disconnect(conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
|
||
|
|
if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_INVALID_STATE)) // NRF_ERROR_INVALID_STATE means disconnect is already in progress.
|
||
|
|
{
|
||
|
|
send_error_evt(err_code);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Notify the application that the procedure has failed
|
||
|
|
if (m_conn_params_config.evt_handler != NULL)
|
||
|
|
{
|
||
|
|
ble_conn_params_evt_t evt;
|
||
|
|
|
||
|
|
evt.evt_type = BLE_CONN_PARAMS_EVT_FAILED;
|
||
|
|
evt.conn_handle = conn_handle;
|
||
|
|
m_conn_params_config.evt_handler(&evt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ret_code_t ble_conn_params_init(const ble_conn_params_init_t * p_init)
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
|
||
|
|
VERIFY_PARAM_NOT_NULL(p_init);
|
||
|
|
|
||
|
|
m_conn_params_config = *p_init;
|
||
|
|
m_conn_params_config.p_conn_params = &m_preferred_conn_params;
|
||
|
|
|
||
|
|
if (p_init->p_conn_params != NULL)
|
||
|
|
{
|
||
|
|
// Set the connection params in stack.
|
||
|
|
err_code = sd_ble_gap_ppcp_set(p_init->p_conn_params);
|
||
|
|
if (err_code != NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
return err_code;
|
||
|
|
}
|
||
|
|
m_preferred_conn_params = *p_init->p_conn_params;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Get the (default) connection params from stack.
|
||
|
|
err_code = sd_ble_gap_ppcp_get(&m_preferred_conn_params);
|
||
|
|
if (err_code != NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
return err_code;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//lint -save -e681 "Loop not entered" when NRF_BLE_CONN_PARAMS_INSTANCE_COUNT is 0
|
||
|
|
for (uint32_t i = 0; i < NRF_BLE_CONN_PARAMS_INSTANCE_COUNT; i++)
|
||
|
|
{
|
||
|
|
ble_conn_params_instance_t * p_instance = &m_conn_params_instances[i];
|
||
|
|
|
||
|
|
instance_free(p_instance);
|
||
|
|
p_instance->timer_id = &m_timer_data[i];
|
||
|
|
|
||
|
|
err_code = app_timer_create(&p_instance->timer_id,
|
||
|
|
APP_TIMER_MODE_SINGLE_SHOT,
|
||
|
|
update_timeout_handler);
|
||
|
|
if (err_code != NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
return NRF_ERROR_INTERNAL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//lint -restore
|
||
|
|
|
||
|
|
return NRF_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ret_code_t ble_conn_params_stop(void)
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
|
||
|
|
//lint -save -e681 "Loop not entered" when NRF_BLE_CONN_PARAMS_INSTANCE_COUNT is 0
|
||
|
|
for (uint32_t i = 0; i < NRF_BLE_CONN_PARAMS_INSTANCE_COUNT; i++)
|
||
|
|
{
|
||
|
|
err_code = app_timer_stop(m_conn_params_instances[i].timer_id);
|
||
|
|
switch (err_code)
|
||
|
|
{
|
||
|
|
case NRF_SUCCESS:
|
||
|
|
/* do nothing */
|
||
|
|
break;
|
||
|
|
|
||
|
|
case NRF_ERROR_INVALID_STATE:
|
||
|
|
/* do nothing */
|
||
|
|
break;
|
||
|
|
|
||
|
|
case NRF_ERROR_NO_MEM:
|
||
|
|
return NRF_ERROR_BUSY;
|
||
|
|
|
||
|
|
case NRF_ERROR_INVALID_PARAM:
|
||
|
|
/* fallthrough */
|
||
|
|
default:
|
||
|
|
return NRF_ERROR_INTERNAL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//lint -restore
|
||
|
|
return NRF_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for taking appropriate action based on the current state of connection parameters.
|
||
|
|
*
|
||
|
|
* @param[in] conn_handle Connection to handle.
|
||
|
|
* @param[in] p_instance Configuration for the connection.
|
||
|
|
*/
|
||
|
|
static void conn_params_negotiation(uint16_t conn_handle, ble_conn_params_instance_t * p_instance)
|
||
|
|
{
|
||
|
|
// Start negotiation if the received connection parameters are not acceptable
|
||
|
|
if (!p_instance->params_ok)
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
uint32_t timeout_ticks;
|
||
|
|
|
||
|
|
if (p_instance->update_count == 0)
|
||
|
|
{
|
||
|
|
// First connection parameter update
|
||
|
|
timeout_ticks = m_conn_params_config.first_conn_params_update_delay;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
timeout_ticks = m_conn_params_config.next_conn_params_update_delay;
|
||
|
|
}
|
||
|
|
|
||
|
|
err_code = app_timer_start(p_instance->timer_id, timeout_ticks, (void *)(uint32_t)conn_handle);
|
||
|
|
if (err_code != NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
send_error_evt(err_code);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
p_instance->update_count = 0;
|
||
|
|
|
||
|
|
// Notify the application that the procedure has succeeded
|
||
|
|
if (m_conn_params_config.evt_handler != NULL)
|
||
|
|
{
|
||
|
|
ble_conn_params_evt_t evt;
|
||
|
|
|
||
|
|
evt.evt_type = BLE_CONN_PARAMS_EVT_SUCCEEDED;
|
||
|
|
evt.conn_handle = conn_handle;
|
||
|
|
m_conn_params_config.evt_handler(&evt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for handling a connection event from the SoftDevice.
|
||
|
|
*
|
||
|
|
* @param[in] p_ble_evt Event from the SoftDevice.
|
||
|
|
*/
|
||
|
|
static void on_connect(ble_evt_t const * p_ble_evt)
|
||
|
|
{
|
||
|
|
uint8_t role = p_ble_evt->evt.gap_evt.params.connected.role;
|
||
|
|
uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
|
||
|
|
|
||
|
|
if (role != BLE_GAP_ROLE_PERIPH)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
ble_conn_params_instance_t * p_instance = instance_get(BLE_CONN_HANDLE_INVALID);
|
||
|
|
|
||
|
|
if (p_instance == NULL)
|
||
|
|
{
|
||
|
|
send_error_evt(NRF_ERROR_NO_MEM);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
instance_claim(p_instance, conn_handle);
|
||
|
|
p_instance->params_ok = is_conn_params_ok(&p_instance->preferred_conn_params,
|
||
|
|
&p_ble_evt->evt.gap_evt.params.connected.conn_params,
|
||
|
|
NRF_BLE_CONN_PARAMS_MAX_SLAVE_LATENCY_DEVIATION,
|
||
|
|
NRF_BLE_CONN_PARAMS_MAX_SUPERVISION_TIMEOUT_DEVIATION);
|
||
|
|
|
||
|
|
// Check if we shall handle negotiation on connect
|
||
|
|
if (m_conn_params_config.start_on_notify_cccd_handle == BLE_GATT_HANDLE_INVALID)
|
||
|
|
{
|
||
|
|
conn_params_negotiation(conn_handle, p_instance);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for handling a disconnection event from the SoftDevice.
|
||
|
|
*
|
||
|
|
* @param[in] p_ble_evt Event from the SoftDevice.
|
||
|
|
*/
|
||
|
|
static void on_disconnect(ble_evt_t const * p_ble_evt)
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
|
||
|
|
ble_conn_params_instance_t * p_instance = instance_get(conn_handle);
|
||
|
|
|
||
|
|
if (p_instance != NULL)
|
||
|
|
{
|
||
|
|
// Stop timer if running
|
||
|
|
err_code = app_timer_stop(p_instance->timer_id);
|
||
|
|
if (err_code != NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
send_error_evt(err_code);
|
||
|
|
}
|
||
|
|
|
||
|
|
instance_free(p_instance);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for handling a GATT write event from the SoftDevice.
|
||
|
|
*
|
||
|
|
* @details To provide the start_on_notify_cccd_handle functionality.
|
||
|
|
*
|
||
|
|
* @param[in] p_ble_evt Event from the SoftDevice.
|
||
|
|
*/
|
||
|
|
static void on_write(ble_evt_t const * p_ble_evt)
|
||
|
|
{
|
||
|
|
ble_gatts_evt_write_t const * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
|
||
|
|
|
||
|
|
// Check if this is the correct CCCD
|
||
|
|
if (
|
||
|
|
(p_evt_write->handle == m_conn_params_config.start_on_notify_cccd_handle)
|
||
|
|
&&
|
||
|
|
(p_evt_write->len == 2)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
|
||
|
|
ble_conn_params_instance_t * p_instance = instance_get(conn_handle);
|
||
|
|
|
||
|
|
if (p_instance != NULL)
|
||
|
|
{
|
||
|
|
// Check if this is a 'start notification'
|
||
|
|
if (ble_srv_is_notification_enabled(p_evt_write->data))
|
||
|
|
{
|
||
|
|
// Do connection parameter negotiation if necessary
|
||
|
|
conn_params_negotiation(conn_handle, p_instance);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ret_code_t err_code;
|
||
|
|
|
||
|
|
// Stop timer if running
|
||
|
|
err_code = app_timer_stop(p_instance->timer_id);
|
||
|
|
if (err_code != NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
send_error_evt(err_code);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**@brief Function for handling a connection parameter update event from the SoftDevice.
|
||
|
|
*
|
||
|
|
* @details This event means the peer central has changed the connection parameters or declined our
|
||
|
|
* request.
|
||
|
|
*
|
||
|
|
* @param[in] p_ble_evt Event from the SoftDevice.
|
||
|
|
*/
|
||
|
|
static void on_conn_params_update(ble_evt_t const * p_ble_evt)
|
||
|
|
{
|
||
|
|
uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
|
||
|
|
ble_conn_params_instance_t * p_instance = instance_get(conn_handle);
|
||
|
|
|
||
|
|
if (p_instance != NULL)
|
||
|
|
{
|
||
|
|
p_instance->params_ok = is_conn_params_ok(
|
||
|
|
&p_instance->preferred_conn_params,
|
||
|
|
&p_ble_evt->evt.gap_evt.params.conn_param_update.conn_params,
|
||
|
|
NRF_BLE_CONN_PARAMS_MAX_SLAVE_LATENCY_DEVIATION,
|
||
|
|
NRF_BLE_CONN_PARAMS_MAX_SUPERVISION_TIMEOUT_DEVIATION);
|
||
|
|
|
||
|
|
conn_params_negotiation(conn_handle, p_instance);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Function for handling BLE events.
|
||
|
|
*
|
||
|
|
* @param[in] p_ble_evt Event received from the BLE stack.
|
||
|
|
* @param[in] p_context Context.
|
||
|
|
*/
|
||
|
|
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
|
||
|
|
{
|
||
|
|
switch (p_ble_evt->header.evt_id)
|
||
|
|
{
|
||
|
|
case BLE_GAP_EVT_CONNECTED:
|
||
|
|
on_connect(p_ble_evt);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case BLE_GAP_EVT_DISCONNECTED:
|
||
|
|
on_disconnect(p_ble_evt);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case BLE_GATTS_EVT_WRITE:
|
||
|
|
on_write(p_ble_evt);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case BLE_GAP_EVT_CONN_PARAM_UPDATE:
|
||
|
|
on_conn_params_update(p_ble_evt);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
// No implementation needed.
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ret_code_t ble_conn_params_change_conn_params(uint16_t conn_handle,
|
||
|
|
ble_gap_conn_params_t * p_new_params)
|
||
|
|
{
|
||
|
|
ret_code_t err_code = BLE_ERROR_INVALID_CONN_HANDLE;
|
||
|
|
ble_conn_params_instance_t * p_instance = instance_get(conn_handle);
|
||
|
|
|
||
|
|
if (p_new_params == NULL)
|
||
|
|
{
|
||
|
|
p_new_params = &m_preferred_conn_params;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (p_instance != NULL)
|
||
|
|
{
|
||
|
|
// Send request to central.
|
||
|
|
err_code = sd_ble_gap_conn_param_update(conn_handle, p_new_params);
|
||
|
|
if (err_code == NRF_SUCCESS)
|
||
|
|
{
|
||
|
|
p_instance->params_ok = false;
|
||
|
|
p_instance->update_count = 1;
|
||
|
|
p_instance->preferred_conn_params = *p_new_params;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return err_code;
|
||
|
|
}
|
||
|
|
|
||
|
|
NRF_SDH_BLE_OBSERVER(m_ble_observer, BLE_CONN_PARAMS_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
|
||
|
|
|
||
|
|
#endif //ENABLED
|