/**@brief Function for initializing buttons.
*/
static void buttons_init(void)
{
// Set Wakeup and Bonds Delete buttons as wakeup sources
nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(BOND_DELETE_ALL_BUTTON_ID,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
}
/**@brief Function for using the GPIO module to configure the required buttons.
*/
static void buttons_init(void)
{
// Configure buttons with sense level low as wakeup source.
nrf_gpio_cfg_sense_input(NOTIF_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(NON_CONN_ADV_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
}
/**@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:
led_stop();
// Initialize the current heart rate to the average of max and min values. So that
// everytime a new connection is made, the heart rate starts from the same value.
m_cur_heart_rate = (MAX_HEART_RATE + MIN_HEART_RATE) / 2;
// Start timers used to generate battery and HR measurements.
application_timers_start();
// Start handling button presses
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
// @note Flash access may not be complete on return of this API. System attributes are now
// stored to flash when they are updated to ensure flash access on disconnect does not
// result in system powering off before data was successfully written.
// Go to system-off mode, should not return from this function, wakeup will trigger
// a reset.
system_off_mode_enter();
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
led_stop();
nrf_gpio_cfg_sense_input(HR_INC_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(HR_DEC_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
system_off_mode_enter();
}
break;
default:
// No implementation needed.
break;
}
}
/**@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);
}
/**@brief Function for initializing the button module.
*/
static void buttons_init(void)
{
nrf_gpio_cfg_sense_input(BOOTLOADER_BUTTON,
BOOTLOADER_BUTTON_ONSTATE ? NRF_GPIO_PIN_PULLDOWN : NRF_GPIO_PIN_PULLUP,
BOOTLOADER_BUTTON_ONSTATE ? NRF_GPIO_PIN_SENSE_HIGH : NRF_GPIO_PIN_SENSE_LOW);
}
/**
* @brief Function for application main entry.
*/
int main(void)
{
uint32_t err_code;
// Configure LED-pins as outputs
nrf_gpio_cfg_output(LED_0);
nrf_gpio_cfg_output(LED_1);
nrf_gpio_cfg_sense_input(BUTTON_0, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW);
APP_GPIOTE_INIT(APP_GPIOTE_MAX_USERS);
err_code = app_gpiote_user_register(&m_app_gpiote_my_id, (1 << BUTTON_0), (1 << BUTTON_0), gpiote_event_handler);
APP_ERROR_CHECK(err_code);
err_code = app_gpiote_user_enable(m_app_gpiote_my_id);
APP_ERROR_CHECK(err_code);
while(true)
{
nrf_gpio_pin_set(LED_1);
nrf_delay_ms(500);
nrf_gpio_pin_clear(LED_1);
nrf_delay_ms(500);
}
}
/**@brief Function for initializing the button module.
*/
static void buttons_init(void)
{
nrf_gpio_cfg_sense_input(BOOTLOADER_BUTTON,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
}
int main(void) {
uint32_t err_code;
nrf_drv_gpiote_in_config_t temp_t = {NRF_GPIOTE_POLARITY_HITOLO, NRF_GPIO_PIN_NOPULL, false, false};
// Initialization
led_init(LED_0);
//led_on(LED_0);
led_init(LED_1);
led_init(LED_2);
//led_on(LED_1);
// Setup clock
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_8000MS_CALIBRATION, false);
//nrf_gpio_cfg_input(22, NRF_GPIO_PIN_NOPULL);
//nrf_gpio_cfg_input(21, NRF_GPIO_PIN_NOPULL);
if (!nrf_drv_gpiote_is_init())
{
err_code = nrf_drv_gpiote_init();
if (err_code != NRF_SUCCESS)
{
return err_code;
}
}
nrf_drv_gpiote_in_init(21, &temp_t, &pin_handler);
nrf_gpio_cfg_sense_input(21, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_LOW);
nrf_drv_gpiote_in_init(22, &temp_t, &pin_handler);
nrf_gpio_cfg_sense_input(22, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_LOW);
// nrf_drv_gpiote_in_init(0, &temp_t, &pin_handler);
NRF_GPIOTE->INTENSET = 0x8000000F;
NVIC_EnableIRQ(GPIOTE_IRQn);
// Setup and start timer
//timers_init();
//timers_start();
while (1) {
power_manage();
}
}
void sleep_mode_prepare(void)
{
for (uint_fast8_t i = KEYBOARD_NUM_OF_COLUMNS; i--;){
nrf_gpio_pin_clear((uint32_t)column_pin_array[i]);
}
nrf_gpio_pin_set((uint32_t)column_pin_array[wakeup_button_column_index]);
nrf_gpio_cfg_sense_input(row_pin_array[wakeup_button_row_index], NRF_GPIO_PIN_PULLDOWN, NRF_GPIO_PIN_SENSE_HIGH);
}
/**
* Configures LEDs and buttons from boards.h as outputs and inputs.
*/
static void gpio_init(void)
{
nrf_gpio_cfg_input(WATCHDOG_RELOAD_BUTTON, NRF_GPIO_PIN_NOPULL);
nrf_gpio_cfg_input(SOFTWARE_RESET_BUTTON, NRF_GPIO_PIN_NOPULL);
nrf_gpio_cfg_input(SYSTEM_OFF_BUTTON, NRF_GPIO_PIN_NOPULL);
nrf_gpio_cfg_sense_input(WAKEUP_BUTTON, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_range_cfg_output(LED_0, LED_7);
}
/**@brief Function for initializing the button handler module.
*/
static void buttons_init(void)
{
#ifdef BOND_DELETE_ALL_BUTTON_PIN
// Set Wakeup and Bonds Delete buttons as wakeup sources.
nrf_gpio_cfg_sense_input(BOND_DELETE_ALL_BUTTON_PIN,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
#endif
}
uint32_t gpio_init(gpio_cfg_t *gpio_cfgs,
uint8_t gpio_count) {
// assert(gpio_count < NUM_GPIO_PINS);
uint32_t err_code;
// TODO: WE MIGHT OR MIGHT NOT NEED THIS!! probably do tho
if (!nrf_drv_gpiote_is_init())
{
err_code = nrf_drv_gpiote_init();
if (err_code != NRF_SUCCESS)
{
return err_code;
}
_pin_direction_reset();
}
// Save configuration.
_gpio_cfgs = gpio_cfgs;
_gpio_count = gpio_count;
while (gpio_count--) {
gpio_cfg_t* curr_input = &_gpio_cfgs[gpio_count];
// assert(curr_input->pin_no < NUM_GPIO_PINS && _pin_direction[curr_input->pin_no] == PIN_UNDEFINED);
// assert(curr_input->pin_direction != PIN_UNDEFINED);
if (curr_input->pin_direction == PIN_OUT) {
nrf_gpio_cfg_output(curr_input->pin_no);
} else { // (PIN_GPIOTE_IN || PIN_PORT_IN)
nrf_drv_gpiote_in_config_t p_config =
{curr_input->polarity, curr_input->pull_cfg,
false, (curr_input->pin_direction == PIN_GPIOTE_IN) ? true : false};
err_code = nrf_drv_gpiote_in_init(curr_input->pin_no,
&p_config,
curr_input->gpio_handler);
if (curr_input->pin_direction == PIN_PORT_IN) {
nrf_gpio_cfg_sense_input(curr_input->pin_no, curr_input->pull_cfg,
curr_input->polarity);
}
}
if (err_code != NRF_SUCCESS)
{
return err_code;
}
_pin_direction[curr_input->pin_no] = curr_input->pin_direction;
}
return NRF_SUCCESS;
}
/**@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;
}
}
/** @brief Function for initializing the GPIO Tasks/Events peripheral.
*/
static void gpiote_init(void)
{
// Configure port1 (pins 8-15) as outputs for showing duty cycle.
nrf_gpio_range_cfg_output(LED_START, LED_STOP);
nrf_gpio_cfg_sense_input(INPUT_PIN_NUMBER, BUTTON_PULL, NRF_GPIO_PIN_SENSE_LOW);
// Enable interrupt on input 1 event.
NRF_GPIOTE->INTENSET = (GPIOTE_INTENSET_IN1_Enabled << GPIOTE_INTENSET_IN1_Pos);
// Configure GPIOTE channel 0 to generate event on input pin high-to-low transition.
// Note that we can connect multiple GPIOTE events to a single input pin.
nrf_gpiote_event_config(0, INPUT_PIN_NUMBER, NRF_GPIOTE_POLARITY_HITOLO);
// Configure GPIOTE channel 1 to generate event on input pin low-to-high transition.
// Note that we can connect multiple GPIOTE events to a single input pin.
nrf_gpiote_event_config(1, INPUT_PIN_NUMBER, NRF_GPIOTE_POLARITY_LOTOHI);
}
static void __event_init(void)
{
struct event_manage* manage = __event_manage_get();
/**************************Timer Event******************************************/
manage->timer_common.mode = APP_TIMER_MODE_REPEATED;
manage->timer_common.timer_timeout = TIMER_COMMENT_TICKS;
manage->timer_common.handler = __timer_common;
/***************************GPIO Event********************************************/
#ifdef MODULE_TOUCH_KEYBOARD_ENABLE
#if ((TOUCH_KEYBOARD_TYPE == TOUCH_KEYBOARD_TTY6952) || (TOUCH_KEYBOARD_TYPE == TOUCH_KEYBOARD_BS8112A3))
nrf_gpio_cfg_sense_input(TOUCH_TTY6952_IRQ, GPIO_PIN_CNF_PULL_Disabled, GPIO_PIN_CNF_SENSE_Low);
manage->tty6952.user_info.pins_high_to_low_mask = (1 << TOUCH_TTY6952_IRQ);
manage->tty6952.user_info.pins_low_to_high_mask = (1 << TOUCH_TTY6952_IRQ);
manage->tty6952.user_info.pin_mask = manage->tty6952.user_info.pins_high_to_low_mask | manage->tty6952.user_info.pins_low_to_high_mask;
manage->tty6952.user_info.pin_number = TOUCH_TTY6952_IRQ;
manage->tty6952.user_info._callback = __gpio_touch_callback;
#endif
#endif
}
*/
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 configuring the buttons.
*/
static void buttons_init(void)
{
nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
}
/**@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;
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;
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_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;
case BLE_EVT_TX_COMPLETE:
if(!ble_buffer_available) tx_complete = true;
break;
default:
// No implementation needed.
break;
}
}
uint32_t ser_phy_open(ser_phy_events_handler_t events_handler)
{
if (events_handler == NULL)
{
return NRF_ERROR_NULL;
}
//Check if function was not called before
if (m_ser_phy_event_handler != NULL)
{
return NRF_ERROR_INVALID_STATE;
}
//GPIO Setup
nrf_gpio_cfg_input(SER_PHY_UART_RTS, NRF_GPIO_PIN_NOPULL);
NRF_GPIO->OUTSET = 1 << SER_PHY_UART_TX;
nrf_gpio_cfg_output(SER_PHY_UART_TX);
//Setup the gpiote to handle pin events on cts-pin.
//For the UART we want to detect both low->high and high->low transitions in order to
//know when to activate/de-activate the TX/RX in the UART.
//Configure pin.
m_pin_cts_mask = (1 << SER_PHY_UART_CTS);
nrf_gpio_cfg_sense_input(SER_PHY_UART_CTS,
NRF_GPIO_PIN_PULLUP,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(SER_PHY_UART_RX,
NRF_GPIO_PIN_PULLUP,
NRF_GPIO_PIN_NOSENSE);
(void)app_gpiote_input_event_handler_register(0,
SER_PHY_UART_CTS,
GPIOTE_CONFIG_POLARITY_Toggle,
gpiote_evt_handler);
(void)app_gpiote_enable_interrupts();
NVIC_ClearPendingIRQ(PendSV_IRQn);
m_rx_state = UART_IDLE;
m_tx_state = UART_IDLE;
//Set header flag
m_rx_stream_header = true;
//UART setup
NRF_UART0->PSELRXD = SER_PHY_UART_RX;
NRF_UART0->PSELTXD = SER_PHY_UART_TX;
NRF_UART0->PSELCTS = UART_PIN_DISCONNECTED;
NRF_UART0->PSELRTS = UART_PIN_DISCONNECTED;
NRF_UART0->BAUDRATE = SER_PHY_UART_BAUDRATE;
NRF_UART0->CONFIG = (UART_CONFIG_HWFC_Enabled << UART_CONFIG_HWFC_Pos);
NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Disabled << UART_ENABLE_ENABLE_Pos);
//Enable UART interrupt
NRF_UART0->INTENCLR = 0xFFFFFFFF;
NRF_UART0->INTENSET = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos) |
(UART_INTENSET_RXDRDY_Set << UART_INTENSET_RXDRDY_Pos) |
(UART_INTENSET_ERROR_Set << UART_INTENSET_ERROR_Pos);
NVIC_ClearPendingIRQ(UART0_IRQn);
NVIC_SetPriority(UART0_IRQn, APP_IRQ_PRIORITY_MID);
NVIC_EnableIRQ(UART0_IRQn);
m_ser_phy_event_handler = events_handler;
return NRF_SUCCESS;
}
/**@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;
/* YOUR_JOB: Uncomment this part if you are using the app_button module to handle button
events (assuming that the button events are only needed in connected
state). If this is uncommented out here,
1. Make sure that app_button_disable() is called when handling
BLE_GAP_EVT_DISCONNECTED below.
2. Make sure the app_button module is initialized.
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;
/* YOUR_JOB: Uncomment this part if you are using the app_button module to handle button
events. This should be done to save power when not connected
to a peer.
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 m_conn_handle = BLE_CONN_HANDLE_INVALID;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
led_stop();
nrf_gpio_pin_set(CONNECTED_LED_PIN_NO); //GreenLED
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
// Initialize the current heart rate to the average of max and min values. So that
// everytime a new connection is made, the heart rate starts from the same value.
m_cur_heart_rate = (MAX_HEART_RATE + MIN_HEART_RATE) / 2;
// Start timers used to generate battery and HR measurements.
application_timers_start();
// Start handling button presses
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
// 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);
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO); //GreenLED
m_storage_in_progress = true;
// @note Flash access may not be complete on return of this API. System attributes are now
// stored to flash when they are updated to ensure flash access on disconnect does not
// result in system powering off before data was successfully written.
// Go to system-off mode, should not return from this function, wakeup will trigger
// a reset.
system_off_mode_enter();
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)
{
led_stop();
nrf_gpio_cfg_sense_input(HR_INC_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(HR_DEC_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
system_off_mode_enter();
}
break;
default:
// No implementation needed.
break;
}
}
*/
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);
// 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);
// 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);
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)
{
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(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);
}
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;
}
/**@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:
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_AUTH_STATUS:
apple_notification_setup();
break;
case BLE_GAP_EVT_DISCONNECTED:
nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
// 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 start to advertise either, store bonds.
err_code = ble_bondmngr_bonded_centrals_store();
APP_ERROR_CHECK(err_code);
err_code = ble_ans_c_service_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)
{
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).
nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
nrf_gpio_cfg_sense_input(BONDMNGR_DELETE_BUTTON_PIN_NO,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
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:
//No implementation needed
break;
}
APP_ERROR_CHECK(err_code);
}