/**@brief IAS Client event handler.
*
* @details This function will be called for all IAS Client events which are passed to the
* application.
*
* @param[in] p_ias_c IAS Client stucture.
* @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)
{
uint32_t err_code = NRF_SUCCESS;
switch (p_evt->evt_type)
{
case BLE_IAS_C_EVT_SRV_DISCOVERED:
// IAS is found on peer. The Find Me Locator functionality of this app will work.
break;
case BLE_IAS_C_EVT_SRV_NOT_FOUND:
// IAS is not found on peer. The Find Me Locator functionality of this app will NOT work.
break;
case BLE_IAS_C_EVT_DISCONN_COMPLETE:
// Stop detecting button presses when not connected
err_code = app_button_disable();
break;
default:
break;
}
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)
{
uint32_t err_code;
#ifdef DEBUG
nrf_delay_ms(100);
#endif
// Stop all sensor timers
sensors_timers_stop();
// TODO: Put all sensors in deep sleep
// TODO: Stop all relevant timers?
// Prepare wakeup buttons.
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
// Configure buttons with sense level low as wakeup source.
// Should already have been done, but just to make sure
nrf_gpio_cfg_sense_input(BUTTON1, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW);
// Wait 1s for things to finish
nrf_delay_ms(1000);
// 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);
}
uint32_t bsp_buttons_disable()
{
#if (BUTTONS_NUMBER > 0) && !defined(BSP_SIMPLE)
return app_button_disable();
#else
return NRF_ERROR_NOT_SUPPORTED;
#endif
}
/**@brief Function for handling the Application's BLE stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_clear(LED_CONNECTED_PIN);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
user_connected = true;
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_set(LED_CONNECTED_PIN);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
user_connected = false;
advertising_start();
twi_clear_motorshield();
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
// Pairing not supported
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP,
NULL,
NULL);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
// No system attributes have been stored.
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code = NRF_SUCCESS;
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
led_stop();
err_code = app_button_enable();
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
m_conn_handle = BLE_CONN_HANDLE_INVALID;
// Stop detecting button presses when not connected.
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
err_code = ble_ams_c_service_store();
APP_ERROR_CHECK(err_code);
advertising_start();
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
advertising_start();
}
break;
case BLE_GATTC_EVT_TIMEOUT:
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server and Client timeout events.
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling button events.
*
* Provides the user input regarding pairing request to the ANT-FS module.
*
* @param[in] pin_no The pin number of the button pressed.
*/
void button_event_handler(uint8_t pin_no, uint8_t button_action)
{
const uint32_t err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
if (button_action == APP_BUTTON_PUSH)
{
switch (pin_no)
{
case BUTTON_0:
m_pairing_state = PAIRING_ACCEPT;
break;
case BUTTON_1:
m_pairing_state = PAIRING_DENY;
break;
default:
APP_ERROR_HANDLER(pin_no);
break;
}
}
}
void ble_hrs_app_stop(void)
{
uint32_t err_code;
// Stop any impending connection parameters update.
err_code = ble_conn_params_stop();
APP_ERROR_CHECK(err_code);
// Stop application timers.
err_code = app_timer_stop(m_battery_timer_id);
APP_ERROR_CHECK(err_code);
err_code = app_timer_stop(m_heart_rate_timer_id);
APP_ERROR_CHECK(err_code);
err_code = app_timer_stop(m_rr_interval_timer_id);
APP_ERROR_CHECK(err_code);
err_code = app_timer_stop(m_sensor_contact_timer_id);
APP_ERROR_CHECK(err_code);
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
}
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code;
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_set(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
nrf_gpio_pin_clear(ADV_INTERVAL_SLOW_LED_PIN_NO);
nrf_gpio_pin_clear(ADV_WHITELIST_LED_PIN_NO);
// Start handling button presses
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
m_advertising_mode = BLE_NO_ADV;
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
if (!m_is_link_loss_alerting)
{
nrf_gpio_pin_clear(ALERT_LEVEL_MILD_LED_PIN_NO);
nrf_gpio_pin_clear(ALERT_LEVEL_HIGH_LED_PIN_NO);
}
m_conn_handle = BLE_CONN_HANDLE_INVALID;
// Since we are not in a connection and have not started advertising, store bonds.
err_code = ble_bondmngr_bonded_centrals_store();
APP_ERROR_CHECK(err_code);
// Stop detecting button presses when not connected.
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
advertising_start();
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_SUCCESS,
&m_sec_params);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
if (m_advertising_mode == BLE_SLEEP)
{
m_advertising_mode = BLE_NO_ADV;
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
nrf_gpio_pin_clear(ADV_WHITELIST_LED_PIN_NO);
nrf_gpio_pin_clear(ADV_INTERVAL_SLOW_LED_PIN_NO);
// Configure buttons with sense level low as wakeup source.
nrf_gpio_cfg_sense_input(SIGNAL_ALERT_BUTTON,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(BONDMNGR_DELETE_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
// 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);
}
else
{
advertising_start();
}
}
break;
case BLE_GATTC_EVT_TIMEOUT:
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server and Client timeout events.
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
/**@brief Function for handling BLE Stack events concerning central applications.
*
* @details This function keeps the connection handles of central applications up-to-date. It
* parses scanning reports, initiating a connection attempt to peripherals when a
* target UUID is found, and manages connection parameter update requests. Additionally,
* it updates the status of LEDs used to report central applications activity.
*
* @note Since this function updates connection handles, @ref BLE_GAP_EVT_DISCONNECTED events
* should be dispatched to the target application before invoking this function.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(const ble_evt_t * const p_ble_evt)
{
// For readability.
const ble_gap_evt_t * const p_gap_evt = &p_ble_evt->evt.gap_evt;
switch (p_ble_evt->header.evt_id)
{
// Upon connection, check which peripheral has connected, initiate DB
// discovery, update LEDs status and resume scanning if necessary.
case BLE_GAP_EVT_CONNECTED:
{
uint32_t err_code;
NRF_LOG_PRINTF("[APP]: link 0x%x established, start discovery on it\r\n",
p_gap_evt->conn_handle);
APP_ERROR_CHECK_BOOL(p_gap_evt->conn_handle < TOTAL_LINK_COUNT);
err_code = ble_lbs_c_handles_assign(&m_ble_lbs_c[p_gap_evt->conn_handle],
p_gap_evt->conn_handle,
NULL);
APP_ERROR_CHECK(err_code);
err_code = ble_db_discovery_start(&m_ble_db_discovery[p_gap_evt->conn_handle],
p_gap_evt->conn_handle);
if (err_code != NRF_ERROR_BUSY)
{
APP_ERROR_CHECK(err_code);
}
// Update LEDs status, and check if we should be looking for more
// peripherals to connect to.
LEDS_ON(CENTRAL_CONNECTED_LED);
if (ble_conn_state_n_centrals() == CENTRAL_LINK_COUNT)
{
LEDS_OFF(CENTRAL_SCANNING_LED);
}
else
{
// Resume scanning.
LEDS_ON(CENTRAL_SCANNING_LED);
scan_start();
}
}
break; // BLE_GAP_EVT_CONNECTED
// Upon disconnection, reset the connection handle of the peer which disconnected, update
// the LEDs status and start scanning again.
case BLE_GAP_EVT_DISCONNECTED:
{
uint32_t central_link_cnt; // Number of central links.
NRF_LOG_PRINTF("LBS central link 0x%x disconnected (reason: %d)\r\n",
p_gap_evt->conn_handle,
p_gap_evt->params.disconnected.reason);
uint32_t err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
// Start scanning
scan_start();
// Update LEDs status.
LEDS_ON(CENTRAL_SCANNING_LED);
central_link_cnt = ble_conn_state_n_centrals();
if (central_link_cnt == 0)
{
LEDS_OFF(CENTRAL_CONNECTED_LED);
}
}
break; // BLE_GAP_EVT_DISCONNECTED
case BLE_GAP_EVT_ADV_REPORT:
on_adv_report(p_ble_evt);
break; // BLE_GAP_ADV_REPORT
case BLE_GAP_EVT_TIMEOUT:
{
// We have not specified a timeout for scanning, so only connection attemps can timeout.
if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
{
APPL_LOG("[APPL]: Connection Request timed out.\r\n");
}
}
break; // BLE_GAP_EVT_TIMEOUT
case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
{
// Accept parameters requested by peer.
ret_code_t err_code;
err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
&p_gap_evt->params.conn_param_update_request.conn_params);
APP_ERROR_CHECK(err_code);
}
break; // BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST
default:
// No implementation needed.
break;
}
}
/**@brief Application's BLE Stack event handler.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_set(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
// Start detecting button presses
err_code = app_button_enable();
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
m_bps_meas_ind_conf_pending = false;
// Stop detecting button presses when not connected
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
// Since we are not in a connection and have not started advertising, store bonds
err_code = ble_bondmngr_bonded_masters_store();
APP_ERROR_CHECK(err_code);
advertising_start();
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_SUCCESS,
&m_sec_params);
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
// Go to system-off mode (this function will not return; wakeup will cause a reset)
GPIO_WAKEUP_BUTTON_CONFIG(SEND_MEAS_BUTTON_PIN_NO);
err_code = sd_power_system_off();
}
break;
case BLE_GATTS_EVT_TIMEOUT:
if (p_ble_evt->evt.gatts_evt.params.timeout.src == BLE_GATT_TIMEOUT_SRC_PROTOCOL)
{
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
}
break;
default:
break;
}
APP_ERROR_CHECK(err_code);
}
/**@brief Function for disabling button input.
*/
static void buttons_disable(void)
{
ret_code_t err_code;
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
}
/**@brief Application's BLE Stack event handler.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code = NRF_SUCCESS;
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_set(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
err_code = app_button_enable();
m_advertising_mode = BLE_NO_ADVERTISING;
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
// Since we are not in a connection and have not start to advertise either, store bonds.
err_code = ble_bondmngr_bonded_masters_store();
APP_ERROR_CHECK(err_code);
// Stop detecting button presses when not connected
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
// Stop detecting button presses when not connected
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
err_code = ble_ans_c_service_store();
advertising_start();
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_SUCCESS,
&m_sec_params);
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
if (m_advertising_mode == BLE_FAST_ADVERTISING)
{
advertising_start();
}
else
{
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
m_advertising_mode = BLE_NO_ADVERTISING;
// Go to system-off mode (function will not return; wakeup will cause a reset)
GPIO_WAKEUP_BUTTON_CONFIG(WAKEUP_BUTTON_PIN);
err_code = sd_power_system_off();
}
}
break;
case BLE_GATTC_EVT_TIMEOUT:
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server and Client timeout events.
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
break;
default:
break;
}
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code;
static ble_gap_evt_auth_status_t m_auth_status;
ble_gap_enc_info_t * p_enc_info;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_set(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
advertising_start();
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_SUCCESS,
&m_sec_params);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_AUTH_STATUS:
m_auth_status = p_ble_evt->evt.gap_evt.params.auth_status;
break;
case BLE_GAP_EVT_SEC_INFO_REQUEST:
p_enc_info = &m_auth_status.periph_keys.enc_info;
if (p_enc_info->div == p_ble_evt->evt.gap_evt.params.sec_info_request.div)
{
err_code = sd_ble_gap_sec_info_reply(m_conn_handle, p_enc_info, NULL);
APP_ERROR_CHECK(err_code);
}
else
{
// No keys found for this device
err_code = sd_ble_gap_sec_info_reply(m_conn_handle, NULL, NULL);
APP_ERROR_CHECK(err_code);
}
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
// Configure buttons with sense level low as wakeup source.
nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
// 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);
}
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code;
static uint16_t s_conn_handle = BLE_CONN_HANDLE_INVALID;
static ble_gap_sec_keyset_t s_sec_keyset;
ble_gap_enc_info_t * p_enc_info;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
s_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
advertising_start();
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
s_sec_keyset.keys_central.p_enc_key = NULL;
s_sec_keyset.keys_central.p_id_key = NULL;
s_sec_keyset.keys_central.p_enc_key = NULL;
err_code = sd_ble_gap_sec_params_reply(s_conn_handle,
BLE_GAP_SEC_STATUS_SUCCESS,
&m_sec_params,
&s_sec_keyset);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_AUTH_STATUS:
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
err_code = sd_ble_gatts_sys_attr_set(s_conn_handle, NULL, 0, 0);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_SEC_INFO_REQUEST:
if (s_sec_keyset.keys_periph.p_enc_key != NULL)
{
p_enc_info = &s_sec_keyset.keys_periph.p_enc_key->enc_info;
err_code = sd_ble_gap_sec_info_reply(s_conn_handle, p_enc_info, NULL, NULL);
APP_ERROR_CHECK(err_code);
}
else
{
// No keys found for this device.
err_code = sd_ble_gap_sec_info_reply(s_conn_handle, NULL, NULL, NULL);
APP_ERROR_CHECK(err_code);
}
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING)
{
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
if (err_code == NRF_SUCCESS)
{
// Configure buttons with sense level low as wakeup source.
// err_code = bsp_buttons_enable((1 << BLE_BUTTON_ID) | (1 << GZLL_BUTTON_ID));
// nrf_gpio_cfg_sense_input(BLE_BUTTON_PIN_NO,
// BUTTON_PULL,
// NRF_GPIO_PIN_SENSE_LOW);
//
// nrf_gpio_cfg_sense_input(GZLL_BUTTON_PIN_NO,
// BUTTON_PULL,
// NRF_GPIO_PIN_SENSE_LOW);
// 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);
}
}
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt) {
uint32_t err_code = NRF_SUCCESS;
static ble_gap_evt_auth_status_t m_auth_status;
ble_gap_enc_info_t * p_enc_info;
switch (p_ble_evt->header.evt_id) {
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_set(CONNECTED_LED_PIN_N);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_N);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = app_button_enable();
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_N);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
err_code = app_button_disable();
if (err_code == NRF_SUCCESS) {
advertising_start();
}
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
err_code = sd_ble_gap_sec_params_reply(m_conn_handle,
BLE_GAP_SEC_STATUS_SUCCESS, &m_sec_params);
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0);
break;
case BLE_GAP_EVT_AUTH_STATUS:
m_auth_status = p_ble_evt->evt.gap_evt.params.auth_status;
break;
case BLE_GAP_EVT_SEC_INFO_REQUEST:
p_enc_info = &m_auth_status.periph_keys.enc_info;
if (p_enc_info->div
== p_ble_evt->evt.gap_evt.params.sec_info_request.div) {
err_code = sd_ble_gap_sec_info_reply(m_conn_handle, p_enc_info,
NULL);
} else {
// No keys found for this device
err_code = sd_ble_gap_sec_info_reply(m_conn_handle, NULL, NULL);
}
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src
== BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT) {
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_N);
// Go to system-off mode (this function will not return; wakeup will cause a reset)
GPIO_WAKEUP_BUTTON_CONFIG(WAKEUP_BUTTON_PIN);
uart_tx_str("reset by timeout");
err_code = sd_power_system_off();
}
break;
case BLE_GATTS_EVT_WRITE:
break;
case BLE_GAP_EVT_CONN_PARAM_UPDATE:
nrf_gpio_pin_toggle (LEDBUTTON_LED_PIN_NO);
break;
default:
break;
}
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the Application's BLE Stack events.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
static void on_ble_evt(ble_evt_t * p_ble_evt)
{
uint32_t err_code = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
nrf_gpio_pin_set(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
// Start detecting button presses.
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
m_hts_meas_ind_conf_pending = false;
// Stop detecting button presses when not connected.
err_code = app_button_disable();
APP_ERROR_CHECK(err_code);
advertising_start();
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
// Configure buttons with sense level low as wakeup source.
nrf_gpio_cfg_sense_input(SEND_MEAS_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(BOND_DELETE_ALL_BUTTON_ID,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
// 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);
}
break;
case BLE_GATTS_EVT_TIMEOUT:
if (p_ble_evt->evt.gatts_evt.params.timeout.src == BLE_GATT_TIMEOUT_SRC_PROTOCOL)
{
err_code = sd_ble_gap_disconnect(m_conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
}
break;
default:
// No implementation needed.
break;
}
}