Can i ask if thingy 52 is able to use Immediate Alert Client Application (https://infocenter.nordicsemi.com/index.jsp?topic=%2Fsdk_nrf5_v17.1.0%2Fble_sdk_app_ias_c.html) ? Which allows sending of alerts to the remote device (for example, a smartphone).
Hi, yes you can run the nRF5 SDK examples on the Thingy52!
Best regards,
Stian
Hello ! thank you for your reply.
can i ask something else at here or do i need to open a new ticket?
my question will be can thingy 52 itself be used as a location tracker, from Received Signal Strength Indicator(RSSI) . Does it have this function ? If it does, may i check is there any example for this ?
Thank you so much!!!
Hi, the Thingy52 is just a development platform for the nRF52 series SoCs. So whatever feature is present on the nRF52 will also be present on the Thingy52. The nRF52 can read the RSSI, and this is exposed to the user through the SoftDevice API (sd_ble_gap_rssi_get). Whether or not this value can be used to track the location of the device depends on the application, and the required accuracy. Maybe you can check out the proximity application?
Hello !! THANK YOU SO MUCH FOR YOUR REPLY.
I managed to did RSSI on PCA10040 using this : https://devzone.nordicsemi.com/f/nordic-q-a/38457/can-a-peripheral-device-know-the-rssi-for-a-connected-central .
But i am thinking if i am able to apply this code into thingy52. Because I really need this function in thingy.
proximity application also able to combine with thingy FW ? I do have the example of the proximity example which is only for PCA10040 :
/**
* Copyright (c) 2014 - 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.
*
*/
/** @file
*
* @defgroup ble_sdk_app_proximity_main main.c
* @{
* @ingroup ble_sdk_app_proximity_eval
* @brief Proximity Application main file.
*
* This file contains is the source code for a sample proximity application using the
* Immediate Alert, Link Loss and Tx Power services.
*
* This application would accept pairing requests from any peer device.
*
* It demonstrates the use of fast and slow advertising intervals.
*/
#include <stdint.h>
#include <string.h>
#include "ble_advertising.h"
#include "nordic_common.h"
#include "nrf.h"
#include "nrf_soc.h"
#include "nrf_drv_saadc.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_tps.h"
#include "ble_ias.h"
#include "ble_lls.h"
#include "ble_bas.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 "ble_ias_c.h"
#include "app_util.h"
#include "bsp_btn_ble.h"
#include "ble_db_discovery.h"
#include "peer_manager.h"
#include "peer_manager_handler.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 "Nordic_Prox" /**< Name of device. Will be included in the advertising data. */
#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 BATTERY_LEVEL_MEAS_INTERVAL APP_TIMER_TICKS(120000) /**< Battery level measurement interval (ticks). This value corresponds to 120 seconds. */
#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 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 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 INITIAL_LLS_ALERT_LEVEL BLE_CHAR_ALERT_LEVEL_NO_ALERT /**< Initial value for the Alert Level characteristic in the Link Loss service. */
#define TX_POWER_LEVEL (-8) /**< TX Power Level value. This will be set both in the TX Power service, in the advertising data, and also used to set the radio transmit power. */
#define ADC_REF_VOLTAGE_IN_MILLIVOLTS 600 /**< Reference voltage (in milli volts) used by ADC while doing conversion. */
#define ADC_PRE_SCALING_COMPENSATION 6 /**< The ADC is configured to use VDD with 1/3 prescaling as input. And hence the result of conversion is to be multiplied by 3 to get the actual value of the battery voltage.*/
#define DIODE_FWD_VOLT_DROP_MILLIVOLTS 270 /**< Typical forward voltage drop of the diode . */
#define ADC_RES_10BIT 1024 /**< Maximum digital value for 10-bit ADC conversion. */
#define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
/**@brief Macro to convert the result of ADC conversion in millivolts.
*
* @param[in] ADC_VALUE ADC result.
*
* @retval Result converted to millivolts.
*/
#define ADC_RESULT_IN_MILLI_VOLTS(ADC_VALUE)\
((((ADC_VALUE) * ADC_REF_VOLTAGE_IN_MILLIVOLTS) / ADC_RES_10BIT) * ADC_PRE_SCALING_COMPENSATION)
APP_TIMER_DEF(m_battery_timer_id); /**< Battery measurement timer. */
BLE_TPS_DEF(m_tps); /**< TX Power service instance. */
BLE_IAS_DEF(m_ias, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< Immediate Alert service instance. */
BLE_LLS_DEF(m_lls); /**< Link Loss service instance. */
BLE_BAS_DEF(m_bas); /**< Battery service instance. */
BLE_IAS_C_DEF(m_ias_c); /**< Immediate Alert Service client 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. */
BLE_DB_DISCOVERY_DEF(m_ble_db_discovery); /**< DB discovery module instance. */
NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */
NRF_SDH_BLE_PERIPHERAL_LINK_COUNT,
NRF_BLE_GQ_QUEUE_SIZE);
static volatile bool m_is_high_alert_signalled; /**< Variable to indicate whether a high alert has been signalled to the peer. */
static volatile bool m_is_ias_present = false; /**< Variable to indicate whether the immediate alert service has been discovered at the connected peer. */
static nrf_saadc_value_t adc_buf[2];
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifiers. */
{
{BLE_UUID_IMMEDIATE_ALERT_SERVICE, BLE_UUID_TYPE_BLE},
{BLE_UUID_BATTERY_SERVICE, BLE_UUID_TYPE_BLE},
{BLE_UUID_TX_POWER_SERVICE, BLE_UUID_TYPE_BLE},
{BLE_UUID_LINK_LOSS_SERVICE, BLE_UUID_TYPE_BLE}
};
static void on_ias_evt(ble_ias_t * p_ias, ble_ias_evt_t * p_evt);
static void on_lls_evt(ble_lls_t * p_lls, ble_lls_evt_t * p_evt);
static void on_ias_c_evt(ble_ias_c_t * p_lls, ble_ias_c_evt_t * p_evt);
static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt);
static void advertising_init(void);
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 Service 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 service_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@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 handling the ADC interrupt.
*
* @details This function will fetch the conversion result from the ADC, convert the value into
* percentage and send it to peer.
*/
void saadc_event_handler(nrf_drv_saadc_evt_t const * p_event)
{
if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
{
nrf_saadc_value_t adc_result;
uint16_t batt_lvl_in_milli_volts;
uint8_t percentage_batt_lvl;
uint32_t err_code;
adc_result = p_event->data.done.p_buffer[0];
err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, 1);
APP_ERROR_CHECK(err_code);
batt_lvl_in_milli_volts = ADC_RESULT_IN_MILLI_VOLTS(adc_result) +
DIODE_FWD_VOLT_DROP_MILLIVOLTS;
percentage_batt_lvl = battery_level_in_percent(batt_lvl_in_milli_volts);
err_code = ble_bas_battery_level_update(&m_bas, percentage_batt_lvl, 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 database discovery events.
*
* @details This function is callback function to handle events from the database discovery module.
* Depending on the UUIDs that are discovered, this function should forward the events
* to their respective services.
*
* @param[in] p_event Pointer to the database discovery event.
*/
static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
ble_ias_c_on_db_disc_evt(&m_ias_c, p_evt);
}
/**@brief Function for configuring ADC to do battery level conversion.
*/
static void adc_configure(void)
{
ret_code_t err_code = nrf_drv_saadc_init(NULL, saadc_event_handler);
APP_ERROR_CHECK(err_code);
nrf_saadc_channel_config_t config =
NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_VDD);
err_code = nrf_drv_saadc_channel_init(0, &config);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(&adc_buf[0], 1);
APP_ERROR_CHECK(err_code);
err_code = nrf_drv_saadc_buffer_convert(&adc_buf[1], 1);
APP_ERROR_CHECK(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.
* This function will start the ADC.
*
* @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);
ret_code_t err_code;
err_code = nrf_drv_saadc_sample();
APP_ERROR_CHECK(err_code);
}
/**@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 battery timer.
err_code = app_timer_create(&m_battery_timer_id,
APP_TIMER_MODE_REPEATED,
battery_level_meas_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_GENERIC_KEYRING);
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 putting the chip into sleep mode.
*
* @note This function will not return.
*/
static void sleep_mode_enter(void)
{
ret_code_t err_code;
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.
*
* @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; // BLE_ADV_EVT_FAST
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break; // BLE_ADV_EVT_IDLE
default:
break;
}
}
/**@brief Function for initializing the Advertising functionality.
*
* @details Encodes the required advertising data and passes it to the stack.
* Also builds a structure to be passed to the stack when starting advertising.
*/
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_LIMITED_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 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 initializing the Queued Write module.
*/
static void qwr_init(void)
{
ret_code_t err_code;
nrf_ble_qwr_init_t qwr_init_obj = {0};
// Initialize Queued Write Module.
qwr_init_obj.error_handler = nrf_qwr_error_handler;
err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the TX Power Service.
*/
static void tps_init(void)
{
ret_code_t err_code;
ble_tps_init_t tps_init_obj;
memset(&tps_init_obj, 0, sizeof(tps_init_obj));
tps_init_obj.initial_tx_power_level = TX_POWER_LEVEL;
tps_init_obj.tpl_rd_sec = SEC_JUST_WORKS;
err_code = ble_tps_init(&m_tps, &tps_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Immediate Alert Service.
*/
static void ias_init(void)
{
ret_code_t err_code;
ble_ias_init_t ias_init_obj;
memset(&ias_init_obj, 0, sizeof(ias_init_obj));
ias_init_obj.evt_handler = on_ias_evt;
ias_init_obj.alert_wr_sec = SEC_JUST_WORKS;
err_code = ble_ias_init(&m_ias, &ias_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Link Loss Service.
*/
static void lls_init(void)
{
ret_code_t err_code;
ble_lls_init_t lls_init_obj;
// Initialize Link Loss Service
memset(&lls_init_obj, 0, sizeof(lls_init_obj));
lls_init_obj.evt_handler = on_lls_evt;
lls_init_obj.error_handler = service_error_handler;
lls_init_obj.initial_alert_level = INITIAL_LLS_ALERT_LEVEL;
lls_init_obj.alert_level_rd_sec = SEC_JUST_WORKS;
lls_init_obj.alert_level_wr_sec = SEC_JUST_WORKS;
err_code = ble_lls_init(&m_lls, &lls_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the Battery Service.
*/
static void bas_init(void)
{
ret_code_t err_code;
ble_bas_init_t bas_init_obj;
memset(&bas_init_obj, 0, sizeof(bas_init_obj));
bas_init_obj.evt_handler = on_bas_evt;
bas_init_obj.support_notification = true;
bas_init_obj.p_report_ref = NULL;
bas_init_obj.initial_batt_level = 100;
bas_init_obj.bl_rd_sec = SEC_OPEN;
bas_init_obj.bl_cccd_wr_sec = SEC_OPEN;
bas_init_obj.bl_report_rd_sec = SEC_OPEN;
err_code = ble_bas_init(&m_bas, &bas_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the immediate alert service client.
*
* @details This will initialize the client side functionality of the Find Me profile.
*/
static void ias_client_init(void)
{
ret_code_t err_code;
ble_ias_c_init_t ias_c_init_obj;
memset(&ias_c_init_obj, 0, sizeof(ias_c_init_obj));
m_is_high_alert_signalled = false;
ias_c_init_obj.evt_handler = on_ias_c_evt;
ias_c_init_obj.error_handler = service_error_handler;
ias_c_init_obj.p_gatt_queue = &m_ble_gatt_queue;
err_code = ble_ias_c_init(&m_ias_c, &ias_c_init_obj);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the services that will be used by the application.
*/
static void services_init(void)
{
qwr_init();
tps_init();
ias_init();
lls_init();
bas_init();
ias_client_init();
}
/** @brief Database discovery module initialization.
*/
static void db_discovery_init(void)
{
ble_db_discovery_init_t db_init;
memset(&db_init, 0, sizeof(ble_db_discovery_init_t));
db_init.evt_handler = db_disc_handler;
db_init.p_gatt_queue = &m_ble_gatt_queue;
ret_code_t err_code = ble_db_discovery_init(&db_init);
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)
{
ret_code_t err_code;
ble_conn_params_init_t cp_init;
memset(&cp_init, 0, sizeof(cp_init));
cp_init.p_conn_params = NULL;
cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID;
cp_init.disconnect_on_fail = true;
cp_init.evt_handler = NULL;
cp_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for the Signals alert event from Immediate Alert or Link Loss services.
*
* @param[in] alert_level Requested alert level.
*/
static void alert_signal(uint8_t alert_level)
{
ret_code_t err_code;
switch (alert_level)
{
case BLE_CHAR_ALERT_LEVEL_NO_ALERT:
NRF_LOG_INFO("No Alert.");
err_code = bsp_indication_set(BSP_INDICATE_ALERT_OFF);
APP_ERROR_CHECK(err_code);
break; // BLE_CHAR_ALERT_LEVEL_NO_ALERT
case BLE_CHAR_ALERT_LEVEL_MILD_ALERT:
NRF_LOG_INFO("Mild Alert.");
err_code = bsp_indication_set(BSP_INDICATE_ALERT_0);
APP_ERROR_CHECK(err_code);
break; // BLE_CHAR_ALERT_LEVEL_MILD_ALERT
case BLE_CHAR_ALERT_LEVEL_HIGH_ALERT:
NRF_LOG_INFO("HIGH Alert.");
err_code = bsp_indication_set(BSP_INDICATE_ALERT_3);
APP_ERROR_CHECK(err_code);
break; // BLE_CHAR_ALERT_LEVEL_HIGH_ALERT
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling Immediate Alert events.
*
* @details This function will be called for all Immediate Alert events which are passed to the
* application.
*
* @param[in] p_ias Immediate Alert structure.
* @param[in] p_evt Event received from the Immediate Alert service.
*/
static void on_ias_evt(ble_ias_t * p_ias, ble_ias_evt_t * p_evt)
{
switch (p_evt->evt_type)
{
case BLE_IAS_EVT_ALERT_LEVEL_UPDATED:
if (p_evt->p_link_ctx != NULL)
{
alert_signal(p_evt->p_link_ctx->alert_level);
}
break; // BLE_IAS_EVT_ALERT_LEVEL_UPDATED
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling Link Loss events.
*
* @details This function will be called for all Link Loss events which are passed to the
* application.
*
* @param[in] p_lls Link Loss structure.
* @param[in] p_evt Event received from the Link Loss service.
*/
static void on_lls_evt(ble_lls_t * p_lls, ble_lls_evt_t * p_evt)
{
switch (p_evt->evt_type)
{
case BLE_LLS_EVT_LINK_LOSS_ALERT:
alert_signal(p_evt->params.alert_level);
break; // BLE_LLS_EVT_LINK_LOSS_ALERT
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling IAS Client events.
*
* @details This function will be called for all IAS Client events which are passed to the
* application.
*
* @param[in] p_ias_c IAS Client structure.
* @param[in] p_evt Event received.
*/
static void on_ias_c_evt(ble_ias_c_t * p_ias_c, ble_ias_c_evt_t * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_type)
{
case BLE_IAS_C_EVT_DISCOVERY_COMPLETE:
// IAS is found on peer. The Find Me Locator functionality of this app will work.
err_code = ble_ias_c_handles_assign(&m_ias_c,
p_evt->conn_handle,
p_evt->alert_level.handle_value);
APP_ERROR_CHECK(err_code);
m_is_ias_present = true;
break; // BLE_IAS_C_EVT_DISCOVERY_COMPLETE
case BLE_IAS_C_EVT_DISCOVERY_FAILED:
// IAS is not found on peer. The Find Me Locator functionality of this app will NOT work.
break; // BLE_IAS_C_EVT_DISCOVERY_FAILED
case BLE_IAS_C_EVT_DISCONN_COMPLETE:
// Disable alert buttons
m_is_ias_present = false;
break; // BLE_IAS_C_EVT_DISCONN_COMPLETE
default:
break;
}
}
/**@brief Function for handling the Battery Service events.
*
* @details This function will be called for all Battery Service events which are passed to the
| application.
*
* @param[in] p_bas Battery Service structure.
* @param[in] p_evt Event received from the Battery Service.
*/
static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_type)
{
case BLE_BAS_EVT_NOTIFICATION_ENABLED:
// Start battery timer
err_code = app_timer_start(m_battery_timer_id, BATTERY_LEVEL_MEAS_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
break; // BLE_BAS_EVT_NOTIFICATION_ENABLED
case BLE_BAS_EVT_NOTIFICATION_DISABLED:
err_code = app_timer_stop(m_battery_timer_id);
APP_ERROR_CHECK(err_code);
break; // BLE_BAS_EVT_NOTIFICATION_DISABLED
default:
// No implementation needed.
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_DISCONNECTED:
NRF_LOG_INFO("Disconnected.");
// LED indication will be changed when advertising starts.
break;
case BLE_GAP_EVT_CONNECTED:
{
NRF_LOG_INFO("Connected.");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
// Assign connection handle to the Queued Write module.
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, p_ble_evt->evt.gap_evt.conn_handle);
APP_ERROR_CHECK(err_code);
// Discover peer's services.
err_code = ble_db_discovery_start(&m_ble_db_discovery,
p_ble_evt->evt.gap_evt.conn_handle);
APP_ERROR_CHECK(err_code);
} 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 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 Function for handling events from the BSP module.
*
* @param[in] event Event generated when button is pressed.
*/
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_ias_c.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
break;
case BSP_EVENT_KEY_0:
{
if (m_is_ias_present)
{
if (!m_is_high_alert_signalled)
{
err_code =
ble_ias_c_send_alert_level(&m_ias_c, BLE_CHAR_ALERT_LEVEL_HIGH_ALERT);
}
else
{
err_code = ble_ias_c_send_alert_level(&m_ias_c, BLE_CHAR_ALERT_LEVEL_NO_ALERT);
}
if (err_code == NRF_SUCCESS)
{
m_is_high_alert_signalled = !m_is_high_alert_signalled;
}
else if (
(err_code != NRF_ERROR_RESOURCES)
&&
(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
&&
(err_code != NRF_ERROR_NOT_FOUND)
)
{
APP_ERROR_HANDLER(err_code);
}
}
} break;
case BSP_EVENT_KEY_1:
NRF_LOG_INFO("Alert Off.");
err_code = bsp_indication_set(BSP_INDICATE_ALERT_OFF);
APP_ERROR_CHECK(err_code);
break;
default:
break;
}
}
/**@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 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 starting advertising.
*/
static void advertising_start(bool erase_bonds)
{
if (erase_bonds == true){
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETE_SUCEEDED event.
}
else
{
uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
}
}
/**@brief Function for changing the tx power.
*/
static void tx_power_set(void)
{
ret_code_t err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_ADV, m_advertising.adv_handle, TX_POWER_LEVEL);
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();
adc_configure();
gap_params_init();
gatt_init();
advertising_init();
db_discovery_init();
services_init();
conn_params_init();
peer_manager_init();
// Start execution.
NRF_LOG_INFO("Proximity example started.");
advertising_start(erase_bonds);
tx_power_set();
// Enter main loop.
for (;;)
{
idle_state_handle();
}
}
/**
* @}
*/
Hi, the FW should run on both the pca10040 and the Thingy, you just need to map the right GPIOs to the buttons and LEDs you are using (if any). Are you able to flash anything to the Thingy52 at all? Do you need help with programming the FW in general, or is it just this specific FW that you can't get to work on the thingy?