/**@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:
debug_printf("Connected :)\r\n");
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
app_beacon_stop();
app_timer_start(m_temperature_timer_id, TEMPERATURE_MEAS_INTERVAL, NULL);
app_timer_start(m_door_timer_id, DOOR_MEAS_INTERVAL, NULL);
break;
case BLE_GAP_EVT_DISCONNECTED:
app_beacon_start();
// when not using the timeslot implementation, it is necessary to initialize the advertizing data again.
advertising_init();
err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
app_timer_stop(m_temperature_timer_id);
app_timer_stop(m_door_timer_id);
debug_printf("Disconnected, Advertising peripheral again \r\n");
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling write events to the si7021 characteristic.
*
* @param[in] p_si7021 Instance of si7021 Service to which the write applies.
* @param[in] led_state Written/desired state of the LED.
*/
static void blesi7021_write_handler(ble_si7021_t * p_si7021, ble_si7021_evt_t *evt) {
uint32_t err_code;
if (evt->evt_type == BLE_si7021_EVT_NOTIFICATION_ENABLED) {
NRF_LOG_INFO("BLE_si7021_EVT_NOTIFICATION_ENABLED\r\n");
err_code = app_timer_start(m_si7021_timer_id, APP_TIMER_TICKS(p_si7021->interval, APP_TIMER_PRESCALER), NULL);
APP_ERROR_CHECK(err_code);
p_si7021->running=1;
} else if (evt->evt_type == BLE_si7021_EVT_INTERVAL_CHANGE) {
NRF_LOG_INFO("BLE_si7021_EVT_INTERVAL_CHANGE %d\r\n",p_si7021->interval);
if (p_si7021->running==1) {
err_code = app_timer_stop(m_si7021_timer_id);
APP_ERROR_CHECK(err_code);
p_si7021->running=0;
err_code = app_timer_start(m_si7021_timer_id, APP_TIMER_TICKS(p_si7021->interval, APP_TIMER_PRESCALER), NULL);
APP_ERROR_CHECK(err_code);
p_si7021->running=1;
}
} else { // BLE_si7021_EVT_NOTIFICATION_DISABLED | BLE_si7021_EVT_DISCONNECTED
NRF_LOG_INFO("BLE_si7021_EVT_NOTIFICATION_DISABLED\r\n");
err_code = app_timer_stop(m_si7021_timer_id);
APP_ERROR_CHECK(err_code);
p_si7021->running=0;
}
}
/**@brief Function for stopping all advertising and all running timers */
void all_advertising_halt(void)
{
sd_ble_gap_adv_stop();
app_timer_stop(m_eddystone_adv_interval_timer);
app_timer_stop(m_eddystone_adv_slot_timer);
app_timer_stop(m_eddystone_etlm_cycle_timer);
}
/**@brief Function for Stopping application timers.
*/
static void application_timers_stop(void)
{
uint32_t err_code;
err_code = app_timer_stop(m_notif_timer_id);
APP_ERROR_CHECK(err_code);
err_code = app_timer_stop(m_conn_int_timer_id);
APP_ERROR_CHECK(err_code);
}
static void sensor_timer_stop(void)
{
uint32_t err_code;
err_code = app_timer_stop(iss_struct_h.meas_timer);
APP_ERROR_CHECK(err_code);
iss_struct_h.timer_running = false;
}
/**@brief Function for handling the GPIOTE event.
*
* @details Saves the current status of the button pins, and starts a timer. If the timer is already
* running, it will be restarted.
*
* @param[in] event_pins_low_to_high Mask telling which pin(s) had a low to high transition.
* @param[in] event_pins_high_to_low Mask telling which pin(s) had a high to low transition.
*/
static void gpiote_event_handler(uint32_t event_pins_low_to_high, uint32_t event_pins_high_to_low)
{
uint32_t err_code;
// Start detection timer. If timer is already running, the detection period is restarted.
// NOTE: Using the p_context parameter of app_timer_start() to transfer the pin states to the
// timeout handler (by casting event_pins_mask into the equally sized void * p_context
// parameter).
STATIC_ASSERT(sizeof(void *) == sizeof(uint32_t));
err_code = app_timer_stop(m_detection_delay_timer_id);
if (err_code != NRF_SUCCESS)
{
// The impact in app_button of the app_timer queue running full is losing a button press.
// The current implementation ensures that the system will continue working as normal.
return;
}
m_pin_transition.low_to_high = event_pins_low_to_high;
m_pin_transition.high_to_low = event_pins_high_to_low;
err_code = app_timer_start(m_detection_delay_timer_id,
m_detection_delay,
(void *)(event_pins_low_to_high | event_pins_high_to_low));
if (err_code != NRF_SUCCESS)
{
// The impact in app_button of the app_timer queue running full is losing a button press.
// The current implementation ensures that the system will continue working as normal.
}
}
/*---------------------------------------------------------------------------*/
void buzzer_stop(void)
{
app_timer_stop(m_buzzer_timer_id);
BUZZ_TIMER->TASKS_STOP = 1;
buzzer_gpiote_unconfig();
}
static void lock_control_handler(ble_doorlock_t * p_doorlock, uint8_t state)
{
uint32_t err_code;
if (state)
{
// Open door
LEDS_ON((BSP_LED_3_MASK));
// Start timer
if (m_lock_timer_id != 0xFFFFFFFF) {
err_code = app_timer_stop(m_lock_timer_id);
APP_ERROR_CHECK(err_code);
} else {
err_code = app_timer_create(&m_lock_timer_id,
APP_TIMER_MODE_SINGLE_SHOT,
lock_timeout_handler);
APP_ERROR_CHECK(err_code);
}
err_code = app_timer_start(m_lock_timer_id, APP_TIMER_TICKS(APP_CFG_CHAR_LOCK_TIMEOUT, APP_TIMER_PRESCALER), NULL);
APP_ERROR_CHECK(err_code);
}
else
{
// Lock door
LEDS_OFF((BSP_LED_3_MASK));
}
}
static void on_write(ble_evt_t * p_ble_evt)
{
ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;
// Check if this the correct CCCD
if (
(p_evt_write->handle == m_conn_params_config.start_on_notify_cccd_handle)
&&
(p_evt_write->len == 2)
)
{
// Check if this is a 'start notification'
if (ble_srv_is_notification_enabled(p_evt_write->data))
{
// Do connection parameter negotiation if necessary
conn_params_negotiation();
}
else
{
#ifdef USE_APP_TIMER
uint32_t err_code;
// Stop timer if running
err_code = app_timer_stop(m_conn_params_timer_id);
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
{
m_conn_params_config.error_handler(err_code);
}
#else /* #if !USE_APP_TIMER */
m_conn_params_timer.detach();
#endif /* #if !USE_APP_TIMER */
}
}
}
/** @brief Function for executing method for entering calibration not active state.
*
* Execute method for entering calibration not active state, meaning notifying the application of
* the state entry event. Additionally, if the timeout handler is running, it will be stopped.
*/
static __INLINE void calibration_not_active_execute(void)
{
const uint32_t err_code = app_timer_stop(m_timer_id);
APP_ERROR_CHECK(err_code);
APP_ERROR_CHECK_BOOL(m_calibration_process_callback != NULL);
m_calibration_process_callback(CALIBRATION_NOT_ACTIVE_STATE_ENTER);
}
uint32_t ble_conn_params_stop(void)
{
#ifdef USE_APP_TIMER
return app_timer_stop(m_conn_params_timer_id);
#else /* #if !USE_APP_TIMER */
m_conn_params_timer.detach();
return NRF_SUCCESS;
#endif /* #if !USE_APP_TIMER */
}
static void ip_app_handler(iot_interface_t * p_interface, ipv6_event_t * p_event)
{
uint32_t err_code;
ipv6_addr_t src_addr;
APPL_LOG("[APPL]: Got IP Application Handler Event on interface 0x%p\r\n", p_interface);
switch (p_event->event_id)
{
case IPV6_EVT_INTERFACE_ADD:
#ifdef COMMISSIONING_ENABLED
commissioning_joining_mode_timer_ctrl(JOINING_MODE_TIMER_STOP_RESET);
#endif // COMMISSIONING_ENABLED
APPL_LOG("[APPL]: New interface added!\r\n");
mp_interface = p_interface;
m_display_state = LEDS_IPV6_IF_UP;
APPL_LOG("[APPL]: Sending Router Solicitation to all routers!\r\n");
// Create Link Local addresses
IPV6_CREATE_LINK_LOCAL_FROM_EUI64(&src_addr, p_interface->local_addr.identifier);
// Delay first solicitation due to possible restriction on other side.
nrf_delay_ms(APP_RTR_SOLICITATION_DELAY);
// Send Router Solicitation to all routers.
err_code = icmp6_rs_send(p_interface,
&src_addr,
&m_local_routers_multicast_addr);
APP_ERROR_CHECK(err_code);
break;
case IPV6_EVT_INTERFACE_DELETE:
#ifdef COMMISSIONING_ENABLED
commissioning_joining_mode_timer_ctrl(JOINING_MODE_TIMER_START);
#endif // COMMISSIONING_ENABLED
APPL_LOG("[APPL]: Interface removed!\r\n");
mp_interface = NULL;
m_display_state = LEDS_IPV6_IF_DOWN;
// Stop application state machine timer.
m_app_state = APP_STATE_IDLE;
err_code = app_timer_stop(m_app_timer);
APP_ERROR_CHECK(err_code);
break;
case IPV6_EVT_INTERFACE_RX_DATA:
APPL_LOG("[APPL]: Got unsupported protocol data!\r\n");
break;
default:
// Unknown event. Should not happen.
break;
}
}
/**@brief Function for handling button events.
*
* @param[in] pin_no The pin number of the button pressed.
* @param[in] button_action The action performed on button.
*/
static void button_event_handler(uint8_t pin_no, uint8_t button_action)
{
uint32_t err_code;
#ifdef COMMISSIONING_ENABLED
if ((button_action == APP_BUTTON_PUSH) && (pin_no == ERASE_BUTTON_PIN_NO))
{
APPL_LOG("[APPL]: Erasing all commissioning settings from persistent storage... \r\n");
commissioning_settings_clear();
return;
}
#endif // COMMISSIONING_ENABLED
// Check if interface is UP.
if(mp_interface == NULL)
{
return;
}
if (button_action == APP_BUTTON_PUSH)
{
switch (pin_no)
{
case START_BUTTON_PIN_NO:
{
APPL_LOG("[APPL]: Start button has been pushed.\r\n");
// Change application state in case being in IDLE state.
if(m_app_state == APP_STATE_IDLE)
{
m_app_state = APP_STATE_QUERYING;
// Start application state machine timer.
err_code = app_timer_start(m_app_timer, APP_STATE_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
}
break;
}
case STOP_BUTTON_PIN_NO:
{
APPL_LOG("[APPL]: Stop button has been pushed.\r\n");
LEDS_OFF((LED_THREE | LED_FOUR));
// Back to IDLE state.
m_app_state = APP_STATE_IDLE;
// Stop application state machine timer.
err_code = app_timer_stop(m_app_timer);
APP_ERROR_CHECK(err_code);
break;
}
default:
break;
}
}
}
static void update_measurement_samp_freq(){
if(iss_struct.timer_running){
uint32_t err_code;
err_code = app_timer_stop(iss_struct.meas_timer);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(iss_struct.meas_timer, APP_TIMER_TICKS(iss_struct.samp_freq_in_m_sec, APP_TIMER_PRESCALER), &iss_struct);
APP_ERROR_CHECK(err_code);
advertising_init();
}
}
/**@brief Function to stop the blinking of the Alert LED.
*/
static void alert_led_blink_stop(void)
{
uint32_t err_code;
err_code = app_timer_stop(m_alert_led_blink_timer_id);
APP_ERROR_CHECK(err_code);
m_is_alert_led_blinking = false;
nrf_gpio_pin_clear(ALERT_PIN_NO);
}
uint32_t app_timer_stop_all(void)
{
for (int i = 0; i < app_timer_control.max_timers; i++)
{
if (app_timer_control.app_timers[i].id)
{
(void)app_timer_stop((app_timer_id_t)app_timer_control.app_timers[i].id);
}
}
return 0;
}
static void lock_timeout_handler(void * p_context)
{
uint32_t err_code;
UNUSED_PARAMETER(p_context);
// Lock door
LEDS_OFF((BSP_LED_3_MASK));
err_code = app_timer_stop(m_lock_timer_id);
APP_ERROR_CHECK(err_code);
}
uint32_t dfu_image_activate (void)
{
uint32_t err_code = NRF_SUCCESS;
dfu_update_status_t update_status;
switch (m_dfu_state)
{
case DFU_STATE_WAIT_4_ACTIVATE:
// Stop the DFU Timer because the peer activity need not be monitored any longer.
err_code = app_timer_stop(m_dfu_timer_id);
APP_ERROR_CHECK(err_code);
if (IS_UPDATING_SD()) //lint !e655 suppress Lint Warning 655: Bit-wise operations
{
update_status.sd_image_size = m_start_packet.sd_image_size;
}
else
{
update_status.sd_image_size = NEW_IMAGE_SIZE_EMPTY;
}
if (IS_UPDATING_BL()) //lint !e655 suppress Lint Warning 655: Bit-wise operations
{
update_status.bl_image_size = m_start_packet.bl_image_size;
}
else
{
update_status.bl_image_size = NEW_IMAGE_SIZE_EMPTY;
}
if (IS_UPDATING_APP()) //lint !e655 suppress Lint Warning 655: Bit-wise operations
{
update_status.ap_image_size = m_start_packet.app_image_size;
}
else
{
update_status.ap_image_size = NEW_IMAGE_SIZE_EMPTY;
}
update_status.status_code = DFU_UPDATE_NEW_IMAGES;
update_status.bank_used = m_active_bank;
update_status.src_image_address = dfu_storage_start_address_get();
bootloader_dfu_update_process(update_status);
break;
default:
err_code = NRF_ERROR_INVALID_STATE;
break;
}
return err_code;
}
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);
}
/**@brief Function to handle interface down event. */
void nrf51_driver_interface_down(void)
{
uint32_t err_code;
APPL_LOG ("[APPL]: IPv6 interface down.\r\n");
err_code = app_timer_stop(m_sys_timer_id);
APP_ERROR_CHECK(err_code);
LEDS_ON(ADVERTISING_LED);
LEDS_OFF(CONNECTED_LED);
}
/**@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:
printf("@Connected\n\r");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(m_sec_ping, PING_DELAY, &m_notification_latest);
APP_ERROR_CHECK(err_code);
// BSP_LED_0_MASK BSP_LED_1_MASK BSP_LED_2_MASK
LEDS_ON(BSP_LED_1_MASK);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
printf("@Disconnected\n\r");
m_conn_handle = BLE_CONN_HANDLE_INVALID;
// BSP_LED_0_MASK BSP_LED_1_MASK BSP_LED_2_MASK
LEDS_OFF(BSP_LED_1_MASK);
err_code = app_timer_stop(m_sec_ping);
APP_ERROR_CHECK(err_code);
while (1) {
nrf_delay_ms(200);
LEDS_INVERT(BSP_LED_1_MASK);
}
break;
case BLE_GATTC_EVT_TIMEOUT:
case BLE_GATTS_EVT_TIMEOUT:
LOG("Timeout.\n\r");
// Disconnect on GATT Server and Client time-out 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 IP stack event handler.
*
* @details Callback registered with the ICMP6 to receive asynchronous events from the module.
*/
void ip_app_handler(iot_interface_t * p_interface, ipv6_event_t * p_event)
{
uint32_t err_code;
APPL_LOG("[APPL]: Got IP Application Handler Event on interface 0x%p\r\n", p_interface);
switch(p_event->event_id)
{
case IPV6_EVT_INTERFACE_ADD:
APPL_LOG("[APPL]: New interface added!\r\n");
err_code = udp6_socket_allocate(&m_udp_socket);
APP_ERROR_CHECK(err_code);
err_code = udp6_socket_bind(&m_udp_socket, IPV6_ADDR_ANY, HTONS(UDP_PORT));
APP_ERROR_CHECK(err_code);
err_code = udp6_socket_recv(&m_udp_socket, rx_udp_port_app_handler);
APP_ERROR_CHECK(err_code);
memset(&m_packet_buffer[0][0], 0x00, sizeof(m_packet_buffer));
m_node_state = APP_STATE_IPV6_IF_UP;
m_display_state = LEDS_TX_ECHO_REQUEST;
// IPv6 interface is up, start sending Echo Requests to peer.
err_code = app_timer_start(m_tx_node_timer, APP_PING_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
break;
case IPV6_EVT_INTERFACE_DELETE:
err_code = app_timer_stop(m_tx_node_timer);
APP_ERROR_CHECK(err_code);
APPL_LOG("[APPL]: Interface removed!\r\n");
err_code = udp6_socket_free(&m_udp_socket);
APP_ERROR_CHECK(err_code);
memset(&m_packet_buffer[0][0], 0x00, sizeof(m_packet_buffer));
m_node_state = APP_STATE_IPV6_IF_DOWN;
m_display_state = LEDS_IPV6_IF_DOWN;
break;
case IPV6_EVT_INTERFACE_RX_DATA:
APPL_LOG("[APPL]: Got unsupported protocol data!\r\n");
break;
default:
//Unknown event. Should not happen.
break;
}
}
uint32_t app_button_disable(void)
{
ASSERT(mp_buttons);
uint32_t i;
for (i = 0; i < m_button_count; i++)
{
nrf_drv_gpiote_in_event_disable(mp_buttons[i].pin_no);
}
// Make sure polling timer is not running.
return app_timer_stop(m_detection_delay_timer_id);
}
void message_deinit() {
uint32_t err_code;
if (!initialized) {
return;
}
if (messageTimerID != TIMER_NULL) {
err_code = app_timer_stop(messageTimerID);
APP_ERROR_CHECK(err_code);
}
initialized = false;
}
/**@brief Function for handling the Notification timeout.
*
* @details This function will be called when the notification timer expires. This will stop the
* timer for connection interval and disconnect from the peer.
*
* @param[in] p_context Pointer used for passing some arbitrary information (context) from the
* app_start_timer() call to the timeout handler.
*/
static void notif_timeout_handler(void * p_context)
{
uint32_t err_code;
UNUSED_PARAMETER(p_context);
// Stop all notifications (by stopping the timer for connection interval that triggers
// notifications and disconnecting from peer).
err_code = app_timer_stop(m_conn_int_timer_id);
APP_ERROR_CHECK(err_code);
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
}
static void timer_0_stop(uint8_t timer)
{
uint32_t err_code;
app_timer_id_t timer_id;
if (timer == 0) {
timer_id = led_0_timer_id;
} else if (timer == 1) {
timer_id = led_1_timer_id;
}
err_code = app_timer_stop(timer_id);
APP_ERROR_CHECK(err_code);
}
/**@brief Timeout handler for the etlm_cycle_timer*/
static void etlm_cycle_timeout(void * p_context)
{
sd_ble_gap_adv_stop();
if (m_etlm_adv_counter.eid_slot_counter >= eddystone_adv_slot_num_of_current_eids(NULL, NULL))
{
m_etlm_adv_counter.eid_slot_counter = 0;
app_timer_stop(m_eddystone_etlm_cycle_timer);
}
else
{
etlm_adv(m_temporary_slot_no);
//this will incremement eid_slot_counter
}
}
void stopwatch_fn_stop(void) {
if (!ms_counter_active) {
return;
}
uint32_t err_code = app_timer_stop(stopwatch_timer_id);
APP_ERROR_CHECK(err_code);
uint32_t current_ticks;
uint32_t diff;
ms_counter_active = false;
app_timer_cnt_get(¤t_ticks);
app_timer_cnt_diff_compute(current_ticks, ms_counter_last_ticks, &diff);
ms_counter += 1000*diff/APP_TIMER_CLOCK_FREQ;
}
static void on_disconnect(ble_evt_t * p_ble_evt)
{
uint32_t err_code;
m_conn_handle = BLE_CONN_HANDLE_INVALID;
// Stop timer if running
m_update_count = 0; // Connection parameters updates should happen during every connection
err_code = app_timer_stop(m_conn_params_timer_id);
if ((err_code != NRF_SUCCESS) && (m_conn_params_config.error_handler != NULL))
{
m_conn_params_config.error_handler(err_code);
}
}
/**@brief Function for the Application's S110 SoftDevice event handler.
*
* @param[in] p_ble_evt S110 SoftDevice 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_set(CONNECTED_LED_PIN_NO);
nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO);
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;
advertising_start();
break;
case BLE_GAP_EVT_PASSKEY_DISPLAY:
// Don't send delayed Security Request if security procedure is already in progress.
err_code = app_timer_stop(m_sec_req_timer_id);
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;
}
}
