/**
****************************************************************************************
* @brief Enable pad's and peripheral clocks assuming that peripherals' power domain is down. The Uart and SPi clocks are set.
*
* @return void
****************************************************************************************
*/
void periph_init(void) // set i2c, spi, uart, uart2 serial clks
{
// Power up peripherals' power domain
SetBits16(PMU_CTRL_REG, PERIPH_SLEEP, 0);
while (!(GetWord16(SYS_STAT_REG) & PER_IS_UP)) ;
SetBits16(CLK_16M_REG,XTAL16_BIAS_SH_DISABLE, 1);
//rom patch
patch_func();
//Init pads
set_pad_functions();
#if (BLE_APP_PRESENT)
#if BLE_PROX_MONITOR
app_proxm_port_reinit(XCY_LED0_GPIO);
app_button_enable();
#elif BLE_FINDME_LOCATOR
app_button_enable();
#endif //BLE_PROX_REPORTER
#if BLE_BATTERY_SERVER
app_batt_port_reinit();
#endif //BLE_BATTERY_SERVER
#endif //BLE_APP_PRESENT
// Enable the pads
SetBits16(SYS_CTRL_REG, PAD_LATCH_EN, 1);
}
/**
* Function for application main entry.
*/
int main(void)
{
init_leds();
init_clock();
uint32_t err_code;
// Button configuration structure.
static app_button_cfg_t p_button[] = { {BUTTON_1, APP_BUTTON_ACTIVE_LOW, NRF_GPIO_PIN_PULLUP, button_handler},
{BUTTON_2, APP_BUTTON_ACTIVE_LOW, NRF_GPIO_PIN_PULLUP, button_handler},
{BUTTON_3, APP_BUTTON_ACTIVE_LOW, NRF_GPIO_PIN_PULLUP, button_handler},
{BUTTON_4, APP_BUTTON_ACTIVE_LOW, NRF_GPIO_PIN_PULLUP, button_handler}};
// Macro for initializing the application timer module.
// It will handle dimensioning and allocation of the memory buffer required by the timer, making sure that the buffer is correctly aligned. It will also connect the timer module to the scheduler (if specified).
APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, NULL);
// Macro for initializing the GPIOTE module.
// It will handle dimensioning and allocation of the memory buffer required by the module, making sure that the buffer is correctly aligned.
APP_GPIOTE_INIT(APP_GPIOTE_MAX_USERS);
// Initializing the buttons.
err_code = app_button_init(p_button, sizeof(p_button) / sizeof(p_button[0]), BUTTON_DEBOUNCE_DELAY);
APP_ERROR_CHECK(err_code);
// Enabling the buttons.
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
while(true)
{
// Do nothing.
}
}
void nsec_buttons_init(void) {
ret_code_t err_code;
/*
* The array must be static because a pointer to it will be saved in the
* button handler module.
*/
static
app_button_cfg_t buttons[] =
{
{INPUT_UP, false, NRF_GPIO_PIN_PULLUP, nsec_button_event_handler},
{INPUT_DOWN, false, NRF_GPIO_PIN_PULLUP, nsec_button_event_handler},
{INPUT_BACK, false, NRF_GPIO_PIN_PULLUP, nsec_button_event_handler},
{INPUT_ENTER, false, NRF_GPIO_PIN_PULLUP, nsec_button_event_handler}
};
/*
* Configure the button library
*/
err_code = app_button_init(buttons,
sizeof(buttons) / sizeof(buttons[0]),
BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
/*
* Enable the buttons
*/
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
uint32_t bsp_buttons_enable()
{
#if (BUTTONS_NUMBER > 0) && !defined(BSP_SIMPLE)
return app_button_enable();
#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 = 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();
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();
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_masters_store();
APP_ERROR_CHECK(err_code);
// 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);
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT)
{
led_stop();
GPIO_WAKEUP_BUTTON_CONFIG(HR_INC_BUTTON_PIN_NO);
GPIO_WAKEUP_BUTTON_CONFIG(HR_DEC_BUTTON_PIN_NO);
system_off_mode_enter();
}
break;
default:
break;
}
APP_ERROR_CHECK(err_code);
}
/**@brief Function for processing ANTFS pairing request event.
*/
static __INLINE void event_pairing_request_handle(void)
{
const char * p_name = antfs_hostname_get();
const uint32_t err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
if (p_name != NULL)
{
printf("host name: %s\n", p_name);
}
}
void buttons_init(void) {
uint32_t err_code;
err_code = app_button_init(buttons, BUTTONS_NO, BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
err_code = app_timer_create(&m_button_long_press_timer_id,
APP_TIMER_MODE_SINGLE_SHOT,
button_long_press_timeout_handler);
APP_ERROR_CHECK(err_code);
app_button_enable();
}
/**@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 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 the Button initialization.
*
* @details Initializes all Buttons used by this application.
*/
static void buttons_init(void)
{
uint32_t err_code;
static app_button_cfg_t buttons[] =
{
{BUTTON_ONE, false, BUTTON_PULL, button_event_handler}
};
err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]), BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the button module.
*/
static void buttons_init(void)
{
uint32_t err_code;
// Configure HR_INC_BUTTON_PIN_NO and HR_DEC_BUTTON_PIN_NO as wake up buttons and also configure
// for 'pull up' because the eval board does not have external pull up resistors connected to
// the buttons.
static app_button_cfg_t buttons[] =
{
{BUTTON_CLEAN_LIST, false, BUTTON_PULL, button_event_handler} // Note: This pin is also BONDMNGR_DELETE_BUTTON_PIN_NO
};
APP_BUTTON_INIT(buttons, sizeof (buttons) / sizeof (buttons[0]), BUTTON_DETECTION_DELAY, false);
err_code = app_button_enable();
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;
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 initializing the button handler module.
*/
void buttons_init(void)
{
uint32_t err_code;
// Configure buttons.
static app_button_cfg_t buttons[] =
{
{BLE_BUTTON_PIN_NO, false, BUTTON_PULL, button_event_handler},
{GZLL_BUTTON_PIN_NO, false, BUTTON_PULL, button_event_handler}
};
APP_BUTTON_INIT(buttons, sizeof(buttons) / sizeof(buttons[0]), BUTTON_DETECTION_DELAY, false);
// Start handling button presses immediately.
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
/**@brief Function for the Button initialization.
*
* @details Initializes all Buttons used by this application.
*/
static void button_init(void)
{
uint32_t err_code;
static app_button_cfg_t buttons[] =
{
{BSP_BUTTON_0, false, BUTTON_PULL, button_event_handler},
{BSP_BUTTON_1, false, BUTTON_PULL, button_event_handler}
};
#define BUTTON_DETECTION_DELAY APP_TIMER_TICKS(50, APP_TIMER_PRESCALER)
err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]), BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
/**@brief Handles events coming from the LED Button central module.
*
* @param[in] p_lbs_c The instance of LBS_C that triggered the event.
* @param[in] p_lbs_c_evt The LBS_C event.
*/
static void lbs_c_evt_handler(ble_lbs_c_t * p_lbs_c, ble_lbs_c_evt_t * p_lbs_c_evt)
{
const uint16_t conn_handle = p_lbs_c_evt->conn_handle;
switch (p_lbs_c_evt->evt_type)
{
case BLE_LBS_C_EVT_DISCOVERY_COMPLETE:
{
ret_code_t err_code;
NRF_LOG_PRINTF("[APP]: LED Button service discovered on conn_handle 0x%x\r\n",
conn_handle);
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
// LED Button service discovered. Enable notification of Button.
err_code = ble_lbs_c_button_notif_enable(p_lbs_c);
APP_ERROR_CHECK(err_code);
}
break; // BLE_LBS_C_EVT_DISCOVERY_COMPLETE
case BLE_LBS_C_EVT_BUTTON_NOTIFICATION:
{
NRF_LOG_PRINTF("[APP]: Link 0x%x, Button state changed on peer to 0x%x\r\n",
conn_handle,
p_lbs_c_evt->params.button.button_state);
if (p_lbs_c_evt->params.button.button_state)
{
LEDS_ON(LEDBUTTON_LED);
}
else
{
LEDS_OFF(LEDBUTTON_LED);
}
}
break; // BLE_LBS_C_EVT_BUTTON_NOTIFICATION
default:
// No implementation needed.
break;
}
}
/**@brief Function for initializing buttons.
*/
void button_init(void)
{
// Initialize timer module.
APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, NULL);
// Initialize and enable button handler module.
static app_button_cfg_t buttons[] =
{
{BSP_BUTTON_0, false, BUTTON_PULL, button_event_handler},
{BSP_BUTTON_1, false, BUTTON_PULL, button_event_handler},
};
uint32_t err_code = app_button_init(buttons,
sizeof(buttons) / sizeof(buttons[0]),
BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
int main (void)
{
spi_hci_pad.pin = SPI_CS_PIN;
spi_hci_pad.port = SPI_GPIO_PORT;
// peripherals init
periph_init();
// App Initialization
app_env.slave_on_sleep = SLAVE_NOT_ACTIVE;
app_env.size_tx_queue = 0;
app_env.size_rx_queue = 0;
#ifdef SPI_BOOTER
spi_send_image();
#endif
spi_init(&spi_hci_pad, SPI_WORD_MODE, SPI_ROLE, SPI_POL_MODE, SPI_PHA_MODE, SPI_MINT_MODE, SPI_FREQ_MODE);
dready_irq_enable();
app_button_enable();
while(1)
{
if (app_env.slave_on_sleep == SLAVE_ACTIVE)
{
if (app_env.size_tx_queue > 0)
{
struct QueueElement *q = DeQueue(&SPITxQueue);
spi_send_hci_msg((uint16_t)(q->bLength), (uint8_t *) (q->Data));
free(q->Data);
app_env.size_tx_queue--;
}
}
if (app_env.size_rx_queue > 0)
{
BleReceiveMsg();
app_env.size_rx_queue--;
}
}
}
/**@brief Function for the Button initialization.
*
* @details Initializes all Buttons used by this application.
*/
static void buttons_init(void)
{
uint32_t err_code;
static app_button_cfg_t buttons[] =
{
{START_BUTTON_PIN_NO, false, BUTTON_PULL, button_event_handler},
{STOP_BUTTON_PIN_NO, false, BUTTON_PULL, button_event_handler},
#ifdef COMMISSIONING_ENABLED
{ERASE_BUTTON_PIN_NO, false, BUTTON_PULL, button_event_handler}
#endif // COMMISSIONING_ENABLED
};
#define BUTTON_DETECTION_DELAY APP_TIMER_TICKS(50, APP_TIMER_PRESCALER)
err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]), BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
/**@brief Application main function.
*/
int main(void)
{
uint32_t err_code;
connected = false;
mlog_init();
timers_init();
gpiote_init();
buttons_init();
step_counter_init();
motor_init();
led1_init();
mlog_str("Starting MAIN...\r\n");
bond_manager_init();
ble_stack_init();
radio_notification_init();
// Initialize Bluetooth Stack parameters
gap_params_init();
advertising_init();
services_init();
conn_params_init();
sec_params_init();
// Actually start advertising
//advertising_start();
app_button_enable();
// Enter main loop
for (;;)
{
// Switch to a low power state until an event is available for the application
err_code = sd_app_event_wait();
APP_ERROR_CHECK(err_code);
}
}
static void button_init(void)
{
uint32_t err_code;
// Configure HR_INC_BUTTON_PIN_NO and HR_DEC_BUTTON_PIN_NO as wake up buttons and also configure
// for 'pull up' because the eval board does not have external pull up resistors connected to
// the buttons.
static app_button_cfg_t buttons[] =
{
{BSP_BUTTON_0, false, BUTTON_PULL, button_event_handler},
{BSP_BUTTON_1, false, BUTTON_PULL, button_event_handler},
{BSP_BUTTON_2, false, BUTTON_PULL, button_event_handler}
};
#define BUTTON_DETECTION_DELAY APP_TIMER_TICKS(50, APP_TIMER_PRESCALER)
err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]), BUTTON_DETECTION_DELAY);
APP_ERROR_CHECK(err_code);
err_code = app_button_enable();
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;
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 application main entry.
*/
int main(void)
{
// Initialize
// nrf_gpio_cfg_output(23);
// nrf_gpio_pin_write(23, 0);
// nrf_gpio_pin_write(23, 1);
// nrf_delay_ms(1000);
// nrf_gpio_pin_write(23, 0);
uart_init();
leds_init();
timers_init();
gpiote_init();
buttons_init();
app_button_enable();
wdt_init();
#ifdef DEBUG_LOG
printf("uart_init\r\n");
printf("leds_init\r\n");
printf("timers_init\r\n");
printf("gpiote_init\r\n");
printf("buttons_init\r\n");
printf("wdt_init\r\n");
#endif
bond_manager_init();
ble_stack_init();
gap_params_init();
#ifdef DEBUG_LOG
printf("bond_manager_init\r\n");
printf("ble_stack_init\r\n");
printf("gap_params_init\r\n");
#endif
advertising_init(BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE);
services_init();
conn_params_init();
sec_params_init();
radio_notification_init();
#ifdef DEBUG_LOG
printf("advertising_init\r\n");
printf("services_init\r\n");
printf("conn_params_init\r\n");
printf("radio_notification_init\r\n");
#endif
advertising_start();
#ifdef DEBUG_LOG
printf("advertising_start\r\n");
#endif
HTU21D_Init();
#ifdef DEBUG_LOG
printf("HTU21D_Init\r\n");
printf("OLED_Init\r\n");
#endif
my_timer_init();
Auto_Time_Set();
#ifdef DEBUG_LOG
printf("rtc my_timer_init\r\n");
printf("Auto_Time_Set\r\n");
#endif
wdt_start();
#ifdef DEBUG_LOG
printf("wdt_start\r\n");
printf("Enter main loop\r\n");
#endif
OLED_POWER_CONTROL(1);
nrf_delay_ms(2000);
OLED_POWER_CONTROL(0);
for (;;)
{
updata_by_min();
updata_by_hour();
power_manage();
}
}
*/
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 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 Application's BLE Stack event handler.
*
* @param[in] p_ble_evt Bluetooth stack event.
*/
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:
adv_led_blink_stop();
if (m_is_link_loss_alerting)
{
alert_led_blink_stop();
}
m_advertising_mode = BLE_NO_ADV;
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
// Start handling button presses
err_code = app_button_enable(); // enable the button
#if OLED096_Func
OLED_ShowString(0,16, (uint8_t*)"BT:CON");
OLED_Refresh_Gram();
#endif
break;
case BLE_GAP_EVT_DISCONNECTED:
if (!m_is_link_loss_alerting)
{
alert_led_blink_stop();
}
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_masters_store();
APP_ERROR_CHECK(err_code);
advertising_start();
#if OLED096_Func
OLED_ShowString(0,16, (uint8_t*)"BT:DIS");
OLED_Refresh_Gram();
#endif
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_SLEEP)
{
m_advertising_mode = BLE_NO_ADV;
adv_led_blink_stop();
alert_led_blink_stop();
GPIO_WAKEUP_BUTTON_CONFIG(SIGNAL_ALERT_BUTTON);
GPIO_WAKEUP_BUTTON_CONFIG(BONDMNGR_DELETE_BUTTON_PIN_NO);
// Go to system-off mode
// (this function will not return; wakeup will cause a reset)
#if 0
err_code = sd_power_system_off();
#endif
#if OLED096_Func
OLED_ShowString(0,16, (uint8_t*)"BT:Tout");
OLED_Refresh_Gram();
#endif
}
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);
break;
default:
break;
}
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;
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 enabling button input.
*/
static void buttons_enable(void)
{
ret_code_t err_code;
err_code = app_button_enable();
APP_ERROR_CHECK(err_code);
}
void app_findl_init(void)
{
app_button_enable();
}
uint32_t bsp_init(uint32_t type, uint32_t ticks_per_100ms, bsp_event_callback_t callback)
{
uint32_t err_code = NRF_SUCCESS;
#if LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
m_app_ticks_per_100ms = ticks_per_100ms;
m_indication_type = type;
#else
UNUSED_VARIABLE(ticks_per_100ms);
#endif // LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
#if (BUTTONS_NUMBER > 0) && !(defined BSP_SIMPLE)
m_registered_callback = callback;
// BSP will support buttons and generate events
if (type & BSP_INIT_BUTTONS)
{
uint32_t num;
for (num = 0; ((num < BUTTONS_NUMBER) && (err_code == NRF_SUCCESS)); num++)
{
err_code = bsp_event_to_button_action_assign(num, BSP_BUTTON_ACTION_PUSH, BSP_EVENT_DEFAULT);
}
if (err_code == NRF_SUCCESS)
{
err_code = app_button_init((app_button_cfg_t *)app_buttons,
BUTTONS_NUMBER,
ticks_per_100ms / 2);
}
if (err_code == NRF_SUCCESS)
{
err_code = app_button_enable();
}
if (err_code == NRF_SUCCESS)
{
err_code = app_timer_create(&m_button_timer_id,
APP_TIMER_MODE_SINGLE_SHOT,
button_timer_handler);
}
}
#elif (BUTTONS_NUMBER > 0) && (defined BSP_SIMPLE)
if (type & BSP_INIT_BUTTONS)
{
uint32_t cnt;
uint32_t buttons[] = BUTTONS_LIST;
for (cnt = 0; cnt < BUTTONS_NUMBER; cnt++)
{
nrf_gpio_cfg_input(buttons[cnt], BUTTON_PULL);
}
}
#endif // (BUTTONS_NUMBER > 0) && !(defined BSP_SIMPLE)
#if LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
if (type & BSP_INIT_LED)
{
LEDS_OFF(LEDS_MASK);
NRF_GPIO->DIRSET = LEDS_MASK;
}
// timers module must be already initialized!
if (err_code == NRF_SUCCESS)
{
err_code =
app_timer_create(&m_leds_timer_id, APP_TIMER_MODE_SINGLE_SHOT, leds_timer_handler);
}
if (err_code == NRF_SUCCESS)
{
err_code =
app_timer_create(&m_alert_timer_id, APP_TIMER_MODE_REPEATED, alert_timer_handler);
}
#endif // LEDS_NUMBER > 0 && !(defined BSP_SIMPLE)
return 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);
}