Hello my current setup use :
nRF52 dev kit
Segger Embedded Studio V4.4
SDK160098a08e2
s132
nRF connect on a iPod touch
I can compile and once connected appreciate the cycling power serivce 0x1818 being advertised as well as cycling power measurement characteristic 0x2A63 and cycling power feature 0x2A65 in the attribute table.
However, I wasn't able to implement correctly a update handler that would send new measurement to the central device
here's my implementation :
static void cps_timeout_handler(void * p_context)
{
uint32_t err_code;
ble_cps_meas_t cps_measurement;
UNUSED_PARAMETER(p_context);
cps_measurement.power_measurement = 24;
err_code = ble_cps_measurement_send(&m_cps, &cps_measurement);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_BUSY) &&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
if (m_auto_calibration_in_progress)
{
err_code = ble_sc_ctrlpt_rsp_send(&(m_cps.ctrl_pt), BLE_SCPT_SUCCESS);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES)
)
{
APP_ERROR_HANDLER(err_code);
}
if (err_code != NRF_ERROR_RESOURCES)
{
m_auto_calibration_in_progress = false;
}
}
}
It's inspired from the ble_app_cscs example but unlike the cscs demo, I cant update the field.
I included ble_cp.h and ble_cp.c and my main.
I could change BLE_SENSOR_LOCATION characteristic or change battery level characteristic but can't figure out what's wrong with the power measurement.
Thanks for help
/* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved.
*
* The information contained herein is property of Nordic Semiconductor ASA.
* Terms and conditions of usage are described in detail in NORDIC
* SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
*
* Licensees are granted free, non-transferable use of the information. NO
* WARRANTY of ANY KIND is provided. This heading must NOT be removed from
* the file.
*
*/
/* Attention!
* To maintain compliance with Nordic Semiconductor ASA�s Bluetooth profile
* qualification listings, this section of source code must not be modified.
*/
#include "ble_cp.h"
#include <string.h>
#include "nordic_common.h"
#include "ble_l2cap.h"
#include "ble_srv_common.h"
#include "app_util.h"
#define OPCODE_LENGTH 1 /**< Length of opcode inside Cycling Power Measurement packet. */
#define HANDLE_LENGTH 2 /**< Length of handle inside Cycling Power Measurement packet. */
#define MAX_CPM_LEN (BLE_L2CAP_MTU_MIN - OPCODE_LENGTH - HANDLE_LENGTH) /**< Maximum size of a transmitted Cycling Power Measurement. */
// Cycling Power Measurement flag bits
#define CP_MEAS_FLAG_MASK_WHEEL_REV_DATA_PRESENT (0x01 << 0) /**< Wheel revolution data present flag bit. */
#define CP_MEAS_FLAG_MASK_CRANK_REV_DATA_PRESENT (0x01 << 1) /**< Crank revolution data present flag bit. */
/**@brief Function for handling the Connect event.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_connect(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
p_cps->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
}
/**@brief Function for handling the Disconnect event.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_disconnect(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
UNUSED_PARAMETER(p_ble_evt);
p_cps->conn_handle = BLE_CONN_HANDLE_INVALID;
}
/**@brief Function for handling write events to the cpS Measurement characteristic.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_evt_write Write event received from the BLE stack.
*/
static void on_meas_cccd_write(ble_cps_t * p_cps, ble_gatts_evt_write_t * p_evt_write)
{
if (p_evt_write->len == 2)
{
// CCCD written, update notification state
if (p_cps->evt_handler != NULL)
{
ble_cps_evt_t evt;
if (ble_srv_is_notification_enabled(p_evt_write->data))
{
evt.evt_type = BLE_cpS_EVT_NOTIFICATION_ENABLED;
}
else
{
evt.evt_type = BLE_cpS_EVT_NOTIFICATION_DISABLED;
}
p_cps->evt_handler(p_cps, &evt);
}
}
}
/**@brief Function for handling the Write event.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_ble_evt Event received from the BLE stack.
*/
static void on_write(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
if (p_evt_write->handle == p_cps->meas_handles.cccd_handle)
{
on_meas_cccd_write(p_cps, p_evt_write);
}
}
void ble_cps_on_ble_evt(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
on_connect(p_cps, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnect(p_cps, p_ble_evt);
break;
case BLE_GATTS_EVT_WRITE:
on_write(p_cps, p_ble_evt);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for encoding a cpS Measurement.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_cp_measurement Measurement to be encoded.
* @param[out] p_encoded_buffer Buffer where the encoded data will be written.
*
* @return Size of encoded data.
*/
static uint8_t cp_measurement_encode(ble_cps_t * p_cps,
ble_cps_meas_t * p_cp_measurement,
uint8_t * p_encoded_buffer)
{
uint16_t flags = 0;
uint8_t len = 2;
flags = 0x01;
len += uint16_encode(p_cp_measurement->power_measurement, &p_encoded_buffer[len]);
len = 20;
// Flags Field
p_encoded_buffer[0] = (uint8_t) ((flags >> 8) & 0x00FF);
p_encoded_buffer[1] = (uint8_t) (flags & 0x00FF);
return len;
}
/**@brief Function for adding cp Measurement characteristics.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_cps_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t cp_measurement_char_add(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
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;
ble_cps_meas_t initial_scm;
uint8_t encoded_scm[MAX_CPM_LEN];
memset(&cccd_md, 0, sizeof(cccd_md));
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
cccd_md.write_perm = p_cps_init->cp_meas_attr_md.cccd_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_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_POWER_MEASUREMENT_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm );
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&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 = cp_measurement_encode(p_cps, &initial_scm, encoded_scm);
attr_char_value.init_offs = 0;
attr_char_value.max_len = MAX_CPM_LEN;
attr_char_value.p_value = encoded_scm;
return sd_ble_gatts_characteristic_add(p_cps->service_handle,
&char_md,
&attr_char_value,
&p_cps->meas_handles);
}
/**@brief Function for adding cp Feature characteristics.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_cps_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t cp_feature_char_add(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t init_value_encoded[4];
uint8_t init_value_len;
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 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 = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_POWER_FEATURE_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_cps_init->cp_feature_attr_md.read_perm;
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
init_value_len = uint32_encode(p_cps_init->feature, &init_value_encoded[0]);
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = init_value_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = init_value_len;
attr_char_value.p_value = init_value_encoded;
return sd_ble_gatts_characteristic_add(p_cps->service_handle,
&char_md,
&attr_char_value,
&p_cps->feature_handles);
}
/**@brief Function for adding cp Sensor Location characteristic.
*
* @param[in] p_cps Cycling Power Service structure.
* @param[in] p_cps_init Information needed to initialize the service.
*
* @return NRF_SUCCESS on success, otherwise an error code.
*/
static uint32_t cp_sensor_loc_char_add(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
ble_gatts_char_md_t char_md;
ble_gatts_attr_t attr_char_value;
ble_uuid_t ble_uuid;
ble_gatts_attr_md_t attr_md;
uint8_t init_value_len;
uint8_t encoded_init_value[1];
memset(&char_md, 0, sizeof(char_md));
char_md.char_props.read = 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 = NULL;
char_md.p_sccd_md = NULL;
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_SENSOR_LOCATION_CHAR);
memset(&attr_md, 0, sizeof(attr_md));
attr_md.read_perm = p_cps_init->cp_sensor_loc_attr_md.read_perm;
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
attr_md.vloc = BLE_GATTS_VLOC_STACK;
attr_md.rd_auth = 0;
attr_md.wr_auth = 0;
attr_md.vlen = 0;
memset(&attr_char_value, 0, sizeof(attr_char_value));
init_value_len = sizeof(uint8_t);
if (p_cps_init->sensor_location != NULL)
{
encoded_init_value[0] = *p_cps_init->sensor_location;
}
attr_char_value.p_uuid = &ble_uuid;
attr_char_value.p_attr_md = &attr_md;
attr_char_value.init_len = init_value_len;
attr_char_value.init_offs = 0;
attr_char_value.max_len = init_value_len;
attr_char_value.p_value = encoded_init_value;
return sd_ble_gatts_characteristic_add(p_cps->service_handle,
&char_md,
&attr_char_value,
&p_cps->sensor_loc_handles);
}
uint32_t ble_cps_init(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
uint32_t err_code;
ble_uuid_t ble_uuid;
ble_cs_ctrlpt_init_t sc_ctrlpt_init;
// Initialize service structure
p_cps->evt_handler = p_cps_init->evt_handler;
p_cps->conn_handle = BLE_CONN_HANDLE_INVALID;
p_cps->feature = p_cps_init->feature;
// Add service
BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_POWER);
err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
&ble_uuid,
&p_cps->service_handle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add Cycling Power measurement characteristic
err_code = cp_measurement_char_add(p_cps, p_cps_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add Cycling Power feature characteristic
err_code = cp_feature_char_add(p_cps, p_cps_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
// Add Sensor Location characteristic (optional)
if (p_cps_init->sensor_location != NULL)
{
err_code = cp_sensor_loc_char_add(p_cps, p_cps_init);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
return err_code;
//Add speed and cadence control point characteristic
// sc_ctrlpt_init.error_handler = p_cps_init->error_handler;
// sc_ctrlpt_init.size_list_supported_locations = p_cps_init->size_list_supported_locations;
// sc_ctrlpt_init.supported_functions = p_cps_init->ctrplt_supported_functions;
// sc_ctrlpt_init.evt_handler = p_cps_init->ctrlpt_evt_handler;
// sc_ctrlpt_init.list_supported_locations = p_cps_init->list_supported_locations;
// sc_ctrlpt_init.sc_ctrlpt_attr_md = p_cps_init->cp_ctrlpt_attr_md;
// sc_ctrlpt_init.sensor_location_handle = p_cps->sensor_loc_handles.value_handle;
// sc_ctrlpt_init.service_handle = p_cps->service_handle;
// return ble_sc_ctrlpt_init(&p_cps->ctrl_pt, &sc_ctrlpt_init);
}
uint32_t ble_cps_measurement_send(ble_cps_t * p_cps, ble_cps_meas_t * p_measurement)
{
uint32_t err_code;
// Send value if connected and notifying
if (p_cps->conn_handle != BLE_CONN_HANDLE_INVALID)
{
uint8_t encoded_cp_meas[MAX_CPM_LEN];
uint16_t len;
uint16_t hvx_len;
ble_gatts_hvx_params_t hvx_params;
len = cp_measurement_encode(p_cps, p_measurement, encoded_cp_meas);
hvx_len = len;
memset(&hvx_params, 0, sizeof(hvx_params));
hvx_params.handle = p_cps->meas_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_cp_meas;
err_code = sd_ble_gatts_hvx(p_cps->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;
}
/**
* Copyright (c) 2014 - 2019, 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.
*
*/
/** @file
*
* @defgroup ble_sdk_app_csc_main main.c
* @{
* @ingroup ble_sdk_app_csc
* @brief Cycling Speed and Cadence Service Sample Application main file.
*
* This file contains the source code for a sample application using the Cycling Speed and Cadence
* Service.
* It also includes the sample code for Battery and Device Information services.
* This application uses the @ref srvlib_conn_params module.
*
* This application implements supports for both Wheel revolution Data and Crank Revolution Data.
* In addition, this application also has support for all 'Speed and Cadence Control Point'.
*/
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_err.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_cp.h"
#include "ble_bas.h"
#include "ble_cscs.h"
#include "ble_dis.h"
#include "ble_conn_params.h"
#include "sensorsim.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "fds.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#define DEVICE_NAME "Wattza" /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME "LSTech+" /**< Manufacturer. Will be passed to Device Information Service. */
#define APP_BLE_OBSERVER_PRIO 3 /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */
#define APP_ADV_INTERVAL 40 /**< The advertising interval (in units of 0.625 ms. This value corresponds to 25 ms). */
#define APP_ADV_DURATION 18000 /**< The advertising duration (180 seconds) in units of 10 milliseconds. */
#define BATTERY_LEVEL_MEAS_INTERVAL APP_TIMER_TICKS(2000) /**< Battery level measurement interval (ticks). */
#define MIN_BATTERY_LEVEL 81 /**< Minimum battery level as returned by the simulated measurement function. */
#define MAX_BATTERY_LEVEL 100 /**< Maximum battery level as returned by the simulated measurement function. */
#define BATTERY_LEVEL_INCREMENT 1 /**< Value by which the battery level is incremented/decremented for each call to the simulated measurement function. */
#define SPEED_AND_CADENCE_MEAS_INTERVAL 1000 /**< Speed and cadence measurement interval (milliseconds). */
#define WHEEL_CIRCUMFERENCE_MM 2100 /**< Simulated wheel circumference in millimeters. */
#define KPH_TO_MM_PER_SEC 278 /**< Constant to convert kilometers per hour into millimeters per second. */
#define MIN_SPEED_KPH 10 /**< Minimum speed in kilometers per hour for use in the simulated measurement function. */
#define MAX_SPEED_KPH 40 /**< Maximum speed in kilometers per hour for use in the simulated measurement function. */
#define SPEED_KPH_INCREMENT 1 /**< Value by which speed is incremented/decremented for each call to the simulated measurement function. */
#define DEGREES_PER_REVOLUTION 360 /**< Constant used in simulation for calculating crank speed. */
#define RPM_TO_DEGREES_PER_SEC 6 /**< Constant to convert revolutions per minute into degrees per second. */
#define MIN_CRANK_RPM 20 /**< Minimum cadence in RPM for use in the simulated measurement function. */
#define MAX_CRANK_RPM 110 /**< Maximum cadence in RPM for use in the simulated measurement function. */
#define CRANK_RPM_INCREMENT 3 /**< Value by which cadence is incremented/decremented in the simulated measurement function. */
#define MIN_CONN_INTERVAL MSEC_TO_UNITS(500, UNIT_1_25_MS) /**< Minimum acceptable connection interval (0.5 seconds). */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(1000, UNIT_1_25_MS) /**< Maximum acceptable connection interval (1 second). */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory timeout (4 seconds). */
#define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */
#define SEC_PARAM_BOND 1 /**< Perform bonding. */
#define SEC_PARAM_MITM 0 /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC 0 /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS 0 /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES BLE_GAP_IO_CAPS_NONE /**< No I/O capabilities. */
#define SEC_PARAM_OOB 0 /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE 7 /**< Minimum encryption key size. */
#define SEC_PARAM_MAX_KEY_SIZE 16 /**< Maximum encryption key size. */
#define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
BLE_CPS_DEF(m_cps);
BLE_BAS_DEF(m_bas); /**< Battery service instance. */
BLE_CSCS_DEF(m_cscs); /**< Cycling speed and cadence service instance. */
NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
NRF_BLE_QWR_DEF(m_qwr); /**< Context for the Queued Write module.*/
BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */
APP_TIMER_DEF(m_battery_timer_id); /**< Battery timer. */
APP_TIMER_DEF(m_csc_meas_timer_id); /**< CSC measurement timer. */
APP_TIMER_DEF(m_cps_timer_id);
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
static sensorsim_cfg_t m_battery_sim_cfg; /**< Battery Level sensor simulator configuration. */
static sensorsim_state_t m_battery_sim_state; /**< Battery Level sensor simulator state. */
static sensorsim_cfg_t m_speed_kph_sim_cfg; /**< Speed simulator configuration. */
static sensorsim_state_t m_speed_kph_sim_state; /**< Speed simulator state. */
static sensorsim_cfg_t m_crank_rpm_sim_cfg; /**< Crank simulator configuration. */
static sensorsim_state_t m_crank_rpm_sim_state; /**< Crank simulator state. */
static uint32_t m_cumulative_wheel_revs; /**< Cumulative wheel revolutions. */
static bool m_auto_calibration_in_progress; /**< Set when an autocalibration is in progress. */
static ble_sensor_location_t supported_locations[] = /**< Supported location for the sensor location. */
{
BLE_SENSOR_LOCATION_FRONT_WHEEL,
BLE_SENSOR_LOCATION_LEFT_CRANK,
BLE_SENSOR_LOCATION_RIGHT_CRANK,
BLE_SENSOR_LOCATION_LEFT_PEDAL,
BLE_SENSOR_LOCATION_RIGHT_PEDAL,
BLE_SENSOR_LOCATION_FRONT_HUB,
BLE_SENSOR_LOCATION_REAR_DROPOUT,
BLE_SENSOR_LOCATION_CHAINSTAY,
BLE_SENSOR_LOCATION_REAR_WHEEL,
BLE_SENSOR_LOCATION_REAR_HUB
};
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifiers. */
{
{BLE_UUID_CYCLING_POWER, BLE_UUID_TYPE_BLE},
// {BLE_UUID_CYCLING_SPEED_AND_CADENCE, BLE_UUID_TYPE_BLE},
{BLE_UUID_BATTERY_SERVICE, BLE_UUID_TYPE_BLE},
{BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE}
};
static void advertising_start(bool erase_bonds);
/**@brief Callback function for asserts in the SoftDevice.
*
* @details This function will be called in case of an assert in the SoftDevice.
*
* @warning This handler is an example only and does not fit a final product. You need to analyze
* how your product is supposed to react in case of Assert.
* @warning On assert from the SoftDevice, the system can only recover on reset.
*
* @param[in] line_num Line number of the failing ASSERT call.
* @param[in] file_name File name of the failing ASSERT call.
*/
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
app_error_handler(DEAD_BEEF, line_num, p_file_name);
}
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
pm_handler_on_pm_evt(p_evt);
pm_handler_flash_clean(p_evt);
switch (p_evt->evt_id)
{
case PM_EVT_PEERS_DELETE_SUCCEEDED:
advertising_start(false);
break;
default:
break;
}
}
/**@brief Function for performing battery measurement and updating the Battery Level characteristic
* in Battery Service.
*/
static void battery_level_update(void)
{
ret_code_t err_code;
uint8_t battery_level;
battery_level = (uint8_t)sensorsim_measure(&m_battery_sim_state, &m_battery_sim_cfg);
err_code = ble_bas_battery_level_update(&m_bas, battery_level, BLE_CONN_HANDLE_ALL);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_BUSY) &&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
}
/**@brief Function for handling the Battery measurement timer timeout.
*
* @details This function will be called each time the battery level measurement timer expires.
*
* @param[in] p_context Pointer used for passing some arbitrary information (context) from the
* app_start_timer() call to the timeout handler.
*/
static void battery_level_meas_timeout_handler(void * p_context)
{
UNUSED_PARAMETER(p_context);
battery_level_update();
}
/**@brief Function for populating simulated cycling speed and cadence measurements.
*/
static void csc_sim_measurement(ble_cscs_meas_t * p_measurement)
{
static uint16_t cumulative_crank_revs = 0;
static uint16_t event_time = 0;
static uint16_t wheel_revolution_mm = 0;
static uint16_t crank_rev_degrees = 0;
uint16_t mm_per_sec;
uint16_t degrees_per_sec;
uint16_t event_time_inc;
// Per specification event time is in 1/1024th's of a second.
event_time_inc = (1024 * SPEED_AND_CADENCE_MEAS_INTERVAL) / 1000;
// Calculate simulated wheel revolution values.
p_measurement->is_wheel_rev_data_present = true;
mm_per_sec = KPH_TO_MM_PER_SEC * sensorsim_measure(&m_speed_kph_sim_state,
&m_speed_kph_sim_cfg);
wheel_revolution_mm += mm_per_sec * SPEED_AND_CADENCE_MEAS_INTERVAL / 1000;
m_cumulative_wheel_revs += wheel_revolution_mm / WHEEL_CIRCUMFERENCE_MM;
wheel_revolution_mm %= WHEEL_CIRCUMFERENCE_MM;
p_measurement->cumulative_wheel_revs = m_cumulative_wheel_revs;
p_measurement->last_wheel_event_time =
event_time + (event_time_inc * (mm_per_sec - wheel_revolution_mm) / mm_per_sec);
// Calculate simulated cadence values.
p_measurement->is_crank_rev_data_present = true;
degrees_per_sec = RPM_TO_DEGREES_PER_SEC * sensorsim_measure(&m_crank_rpm_sim_state,
&m_crank_rpm_sim_cfg);
crank_rev_degrees += degrees_per_sec * SPEED_AND_CADENCE_MEAS_INTERVAL / 1000;
cumulative_crank_revs += crank_rev_degrees / DEGREES_PER_REVOLUTION;
crank_rev_degrees %= DEGREES_PER_REVOLUTION;
p_measurement->cumulative_crank_revs = cumulative_crank_revs;
p_measurement->last_crank_event_time =
event_time + (event_time_inc * (degrees_per_sec - crank_rev_degrees) / degrees_per_sec);
event_time += event_time_inc;
}
/**@brief Function for handling the Cycling Speed and Cadence measurement timer timeouts.
*
* @details This function will be called each time the cycling speed and cadence
* measurement timer expires.
*
* @param[in] p_context Pointer used for passing some arbitrary information (context) from the
* app_start_timer() call to the timeout handler.
*/
static void csc_meas_timeout_handler(void * p_context)
{
uint32_t err_code;
ble_cscs_meas_t cscs_measurement;
UNUSED_PARAMETER(p_context);
csc_sim_measurement(&cscs_measurement);
err_code = ble_cscs_measurement_send(&m_cscs, &cscs_measurement);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_BUSY) &&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
if (m_auto_calibration_in_progress)
{
err_code = ble_sc_ctrlpt_rsp_send(&(m_cscs.ctrl_pt), BLE_SCPT_SUCCESS);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES)
)
{
APP_ERROR_HANDLER(err_code);
}
if (err_code != NRF_ERROR_RESOURCES)
{
m_auto_calibration_in_progress = false;
}
}
}
static void cps_timeout_handler(void * p_context)
{
uint32_t err_code;
ble_cps_meas_t cps_measurement;
UNUSED_PARAMETER(p_context);
cps_measurement.power_measurement = 24;
err_code = ble_cps_measurement_send(&m_cps, &cps_measurement);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_BUSY) &&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
)
{
APP_ERROR_HANDLER(err_code);
}
if (m_auto_calibration_in_progress)
{
err_code = ble_sc_ctrlpt_rsp_send(&(m_cps.ctrl_pt), BLE_SCPT_SUCCESS);
if ((err_code != NRF_SUCCESS) &&
(err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES)
)
{
APP_ERROR_HANDLER(err_code);
}
if (err_code != NRF_ERROR_RESOURCES)
{
m_auto_calibration_in_progress = false;
}
}
}
/**@brief Function for the Timer initialization.
*
* @details Initializes the timer module. This creates and starts application timers.
*/
static void timers_init(void)
{
ret_code_t err_code;
// Initialize timer module.
err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
// Create timers.
err_code = app_timer_create(&m_battery_timer_id,
APP_TIMER_MODE_REPEATED,
battery_level_meas_timeout_handler);
APP_ERROR_CHECK(err_code);
/*
// Create battery timer.
err_code = app_timer_create(&m_csc_meas_timer_id,
APP_TIMER_MODE_REPEATED,
csc_meas_timeout_handler);
APP_ERROR_CHECK(err_code);
*/
err_code = app_timer_create(&m_cps_timer_id,
APP_TIMER_MODE_REPEATED,
cps_timeout_handler);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for the GAP initialization.
*
* @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the
* device including the device name, appearance, and the preferred connection parameters.
*/
static void gap_params_init(void)
{
ret_code_t err_code;
ble_gap_conn_params_t gap_conn_params;
ble_gap_conn_sec_mode_t sec_mode;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)DEVICE_NAME,
strlen(DEVICE_NAME));
APP_ERROR_CHECK(err_code);
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_CYCLING_POWER_SENSOR);
APP_ERROR_CHECK(err_code);
memset(&gap_conn_params, 0, sizeof(gap_conn_params));
gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
gap_conn_params.slave_latency = SLAVE_LATENCY;
gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;
err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the GATT module.
*/
static void gatt_init(void)
{
ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling Queued Write Module errors.
*
* @details A pointer to this function will be passed to each service which may need to inform the
* application about an error.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for handling Speed and Cadence Control point events
*
* @details Function for handling Speed and Cadence Control point events.
* This function parses the event and in case the "set cumulative value" event is received,
* sets the wheel cumulative value to the received value.
*/
ble_scpt_response_t sc_ctrlpt_event_handler(ble_sc_ctrlpt_t * p_sc_ctrlpt,
ble_sc_ctrlpt_evt_t * p_evt)
{
switch (p_evt->evt_type)
{
case BLE_SC_CTRLPT_EVT_SET_CUMUL_VALUE:
m_cumulative_wheel_revs = p_evt->params.cumulative_value;
break;
case BLE_SC_CTRLPT_EVT_START_CALIBRATION:
m_auto_calibration_in_progress = true;
break;
default:
// No implementation needed.
break;
}
return (BLE_SCPT_SUCCESS);
}
/**@brief Function for initializing services that will be used by the application.
*
* @details Initialize the Cycling Speed and Cadence, Battery and Device Information services.
*/
static void services_init(void)
{
uint32_t err_code;
ble_cscs_init_t cscs_init;
ble_bas_init_t bas_init;
ble_dis_init_t dis_init;
ble_cps_init_t cps_init;
ble_sensor_location_t sensor_location;
nrf_ble_qwr_init_t qwr_init = {0};
// Initialize Queued Write Module.
qwr_init.error_handler = nrf_qwr_error_handler;
err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init);
APP_ERROR_CHECK(err_code);
// Initialize Cycling Power Service module
memset(&cps_init, 0, sizeof(cps_init));
cps_init.evt_handler = NULL;
cps_init.feature = BLE_CPS_FEATURE_WHEEL_REV_BIT | BLE_CPS_FEATURE_CRANK_REV_BIT |
BLE_CPS_FEATURE_MULTIPLE_SENSORS_BIT;
cps_init.cp_meas_attr_md = SEC_OPEN;
cps_init.cp_feature_attr_md = SEC_OPEN;
cps_init.cp_ctrlpt_attr_md = SEC_OPEN;
// Here the sec level for the Cycling Speed and Cadence Service can be changed/increased.
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cps_init.cp_meas_attr_md.cccd_write_perm); // for the measurement characteristic, only the CCCD write permission can be set by the application, others are mandated by service specification
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cps_init.cp_feature_attr_md.read_perm); // for the feature characteristic, only the read permission can be set by the application, others are mandated by service specification
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cps_init.cp_ctrlpt_attr_md.write_perm); // for the SC control point characteristic, only the write permission and CCCD write can be set by the application, others are mandated by service specification
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cps_init.cp_ctrlpt_attr_md.cccd_write_perm); // for the SC control point characteristic, only the write permission and CCCD write can be set by the application, others are mandated by service specification
cps_init.ctrplt_supported_functions = BLE_SRV_SC_CTRLPT_CUM_VAL_OP_SUPPORTED
|BLE_SRV_SC_CTRLPT_SENSOR_LOCATIONS_OP_SUPPORTED
|BLE_SRV_SC_CTRLPT_START_CALIB_OP_SUPPORTED;
cps_init.ctrlpt_evt_handler = sc_ctrlpt_event_handler;
cps_init.list_supported_locations = supported_locations;
cps_init.size_list_supported_locations = sizeof(supported_locations) / sizeof(ble_sensor_location_t);
sensor_location = BLE_SENSOR_LOCATION_IN_SHOE; // initializes the sensor location to add the sensor location characteristic.
cps_init.sensor_location = &sensor_location;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cps_init.cp_sensor_loc_attr_md.read_perm); // for the sensor location characteristic, only the read permission can be set by the application, others are mendated by service specification
err_code = ble_cps_init(&m_cps, &cps_init);
APP_ERROR_CHECK(err_code);
/*
// Initialize Cycling Speed and Cadence Service.
memset(&cscs_init, 0, sizeof(cscs_init));
cscs_init.evt_handler = NULL;
cscs_init.feature = BLE_CSCS_FEATURE_WHEEL_REV_BIT | BLE_CSCS_FEATURE_CRANK_REV_BIT |
BLE_CSCS_FEATURE_MULTIPLE_SENSORS_BIT;
// Here the sec level for the Cycling Speed and Cadence Service can be changed/increased.
cscs_init.csc_meas_cccd_wr_sec = SEC_OPEN;
cscs_init.csc_feature_rd_sec = SEC_OPEN;
cscs_init.csc_location_rd_sec = SEC_OPEN;
cscs_init.sc_ctrlpt_cccd_wr_sec = SEC_OPEN;
cscs_init.sc_ctrlpt_wr_sec = SEC_OPEN;
cscs_init.ctrplt_supported_functions = BLE_SRV_SC_CTRLPT_CUM_VAL_OP_SUPPORTED
| BLE_SRV_SC_CTRLPT_SENSOR_LOCATIONS_OP_SUPPORTED
| BLE_SRV_SC_CTRLPT_START_CALIB_OP_SUPPORTED;
cscs_init.ctrlpt_evt_handler = sc_ctrlpt_event_handler;
cscs_init.list_supported_locations = supported_locations;
cscs_init.size_list_supported_locations = sizeof(supported_locations) /
sizeof(ble_sensor_location_t);
sensor_location = BLE_SENSOR_LOCATION_FRONT_WHEEL; // initializes the sensor location to add the sensor location characteristic.
cscs_init.sensor_location = &sensor_location;
err_code = ble_cscs_init(&m_cscs, &cscs_init);
APP_ERROR_CHECK(err_code);
*/
// Initialize Battery Service.
memset(&bas_init, 0, sizeof(bas_init));
// Here the sec level for the Battery Service can be changed/increased.
bas_init.bl_rd_sec = SEC_OPEN;
bas_init.bl_cccd_wr_sec = SEC_OPEN;
bas_init.bl_report_rd_sec = SEC_OPEN;
bas_init.evt_handler = NULL;
bas_init.support_notification = true;
bas_init.p_report_ref = NULL;
bas_init.initial_batt_level = 100;
err_code = ble_bas_init(&m_bas, &bas_init);
APP_ERROR_CHECK(err_code);
// Initialize Device Information Service.
memset(&dis_init, 0, sizeof(dis_init));
ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, MANUFACTURER_NAME);
dis_init.dis_char_rd_sec = SEC_OPEN;
err_code = ble_dis_init(&dis_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the sensor simulators.
*/
static void sensor_simulator_init(void)
{
m_battery_sim_cfg.min = MIN_BATTERY_LEVEL;
m_battery_sim_cfg.max = MAX_BATTERY_LEVEL;
m_battery_sim_cfg.incr = BATTERY_LEVEL_INCREMENT;
m_battery_sim_cfg.start_at_max = true;
sensorsim_init(&m_battery_sim_state, &m_battery_sim_cfg);
m_speed_kph_sim_cfg.min = MIN_SPEED_KPH;
m_speed_kph_sim_cfg.max = MAX_SPEED_KPH;
m_speed_kph_sim_cfg.incr = SPEED_KPH_INCREMENT;
m_speed_kph_sim_cfg.start_at_max = false;
sensorsim_init(&m_speed_kph_sim_state, &m_speed_kph_sim_cfg);
m_crank_rpm_sim_cfg.min = MIN_CRANK_RPM;
m_crank_rpm_sim_cfg.max = MAX_CRANK_RPM;
m_crank_rpm_sim_cfg.incr = CRANK_RPM_INCREMENT;
m_crank_rpm_sim_cfg.start_at_max = false;
sensorsim_init(&m_crank_rpm_sim_state, &m_crank_rpm_sim_cfg);
m_cumulative_wheel_revs = 0;
m_auto_calibration_in_progress = false;
}
/**@brief Function for starting application timers.
*/
static void application_timers_start(void)
{
ret_code_t err_code;
uint32_t cps_meas_timer_ticks;
// uint32_t csc_meas_timer_ticks;
// Start application timers.
err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
/*
csc_meas_timer_ticks = APP_TIMER_TICKS(SPEED_AND_CADENCE_MEAS_INTERVAL);
err_code = app_timer_start(m_csc_meas_timer_id, csc_meas_timer_ticks, NULL);
APP_ERROR_CHECK(err_code);
*/
cps_meas_timer_ticks = APP_TIMER_TICKS(SPEED_AND_CADENCE_MEAS_INTERVAL);
err_code = app_timer_start(m_cps_timer_id, cps_meas_timer_ticks, NULL);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the Connection Parameter events.
*
* @details This function will be called for all events in the Connection Parameters Module which
* are passed to the application.
* @note All this function does is to disconnect. This could have been done by simply
* setting the disconnect_on_fail configuration parameter, but instead we use the
* event handler mechanism to demonstrate its use.
*
* @param[in] p_evt Event received from the Connection Parameters Module.
*/
static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
ret_code_t err_code;
if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
{
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
APP_ERROR_CHECK(err_code);
}
}
/**@brief Function for handling a Connection Parameters error.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void conn_params_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for initializing the Connection Parameters module.
*/
static void conn_params_init(void)
{
uint32_t err_code;
ble_conn_params_init_t connection_params_init;
memset(&connection_params_init, 0, sizeof(connection_params_init));
connection_params_init.p_conn_params = NULL;
connection_params_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
connection_params_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
connection_params_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
connection_params_init.start_on_notify_cccd_handle = m_cscs.meas_handles.cccd_handle;
connection_params_init.disconnect_on_fail = false;
connection_params_init.evt_handler = on_conn_params_evt;
connection_params_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&connection_params_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for putting the chip into sleep mode.
*
* @note This function will not return.
*/
static void sleep_mode_enter(void)
{
ret_code_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
// Prepare wakeup buttons.
err_code = bsp_btn_ble_sleep_mode_prepare();
APP_ERROR_CHECK(err_code);
// Go to system-off mode (this function will not return; wakeup will cause a reset).
err_code = sd_power_system_off();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
ret_code_t err_code;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_FAST:
NRF_LOG_INFO("Fast advertising");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break;
default:
break;
}
}
/**@brief Function for handling BLE events.
*
* @param[in] p_ble_evt Bluetooth stack event.
* @param[in] p_context Unused.
*/
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
ret_code_t err_code = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected");
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break;
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
NRF_LOG_DEBUG("PHY update request.");
ble_gap_phys_t const phys =
{
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
} break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
ret_code_t err_code;
err_code = nrf_sdh_enable_request();
APP_ERROR_CHECK(err_code);
// Configure the BLE stack using the default settings.
// Fetch the start address of the application RAM.
uint32_t ram_start = 0;
err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
APP_ERROR_CHECK(err_code);
// Enable BLE stack.
err_code = nrf_sdh_ble_enable(&ram_start);
APP_ERROR_CHECK(err_code);
// Register a handler for BLE events.
NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}
/**@brief Function for handling events from the BSP module.
*
* @param[in] event Event generated by button press.
*/
static void bsp_event_handler(bsp_event_t event)
{
ret_code_t err_code;
switch (event)
{
case BSP_EVENT_SLEEP:
sleep_mode_enter();
break;
case BSP_EVENT_DISCONNECT:
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
break;
case BSP_EVENT_WHITELIST_OFF:
if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
{
err_code = ble_advertising_restart_without_whitelist(&m_advertising);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
}
break;
default:
break;
}
}
/**@brief Function for the Peer Manager initialization.
*/
static void peer_manager_init(void)
{
ble_gap_sec_params_t sec_param;
ret_code_t err_code;
err_code = pm_init();
APP_ERROR_CHECK(err_code);
memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));
// Security parameters to be used for all security procedures.
sec_param.bond = SEC_PARAM_BOND;
sec_param.mitm = SEC_PARAM_MITM;
sec_param.lesc = SEC_PARAM_LESC;
sec_param.keypress = SEC_PARAM_KEYPRESS;
sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES;
sec_param.oob = SEC_PARAM_OOB;
sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
sec_param.kdist_own.enc = 1;
sec_param.kdist_own.id = 1;
sec_param.kdist_peer.enc = 1;
sec_param.kdist_peer.id = 1;
err_code = pm_sec_params_set(&sec_param);
APP_ERROR_CHECK(err_code);
err_code = pm_register(pm_evt_handler);
APP_ERROR_CHECK(err_code);
}
/**@brief Clear bond information from persistent storage.
*/
static void delete_bonds(void)
{
ret_code_t err_code;
NRF_LOG_INFO("Erase bonds!");
err_code = pm_peers_delete();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Advertising functionality.
*/
static void advertising_init(void)
{
ret_code_t err_code;
ble_advertising_init_t init;
memset(&init, 0, sizeof(init));
init.advdata.name_type = BLE_ADVDATA_FULL_NAME;
init.advdata.include_appearance = true;
init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.advdata.uuids_complete.p_uuids = m_adv_uuids;
init.config.ble_adv_fast_enabled = true;
init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
init.config.ble_adv_fast_timeout = APP_ADV_DURATION;
init.evt_handler = on_adv_evt;
err_code = ble_advertising_init(&m_advertising, &init);
APP_ERROR_CHECK(err_code);
ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}
/**@brief Function for initializing buttons and leds.
*
* @param[out] p_erase_bonds Will be true if the clear bonding button was pressed to wake the application up.
*/
static void buttons_leds_init(bool * p_erase_bonds)
{
ret_code_t err_code;
bsp_event_t startup_event;
err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, bsp_event_handler);
APP_ERROR_CHECK(err_code);
err_code = bsp_btn_ble_init(NULL, &startup_event);
APP_ERROR_CHECK(err_code);
*p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);
}
/**@brief Function for initializing the nrf log module.
*/
static void log_init(void)
{
ret_code_t err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
}
/**@brief Function for initializing power management.
*/
static void power_management_init(void)
{
ret_code_t err_code;
err_code = nrf_pwr_mgmt_init();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the idle state (main loop).
*
* @details If there is no pending log operation, then sleep until next the next event occurs.
*/
static void idle_state_handle(void)
{
if (NRF_LOG_PROCESS() == false)
{
nrf_pwr_mgmt_run();
}
}
/**@brief Function for starting advertising.
*/
static void advertising_start(bool erase_bonds)
{
ret_code_t err_code;
if (erase_bonds == true)
{
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
}
else
{
err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
}
}
/**@brief Function for application main entry.
*/
int main(void)
{
bool erase_bonds;
// Initialize.
log_init();
timers_init();
buttons_leds_init(&erase_bonds);
power_management_init();
ble_stack_init();
gap_params_init();
gatt_init();
advertising_init();
services_init();
sensor_simulator_init();
conn_params_init();
peer_manager_init();
// Start execution.
NRF_LOG_INFO("Cycling Speed and Cadence example started.");
application_timers_start();
advertising_start(erase_bonds);
// Enter main loop.
for (;;)
{
idle_state_handle();
}
}
/**
* @}
*/
