/**@brief Function for the application's SoftDevice event handler.
*
* @param[in] p_ble_evt 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:
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_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);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
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 advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
uint32_t err_code;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_DIRECTED:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_DIRECTED);
APP_ERROR_CHECK(err_code);
break;//BLE_ADV_EVT_DIRECTED
case BLE_ADV_EVT_FAST:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;//BLE_ADV_EVT_FAST
case BLE_ADV_EVT_SLOW:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_SLOW);
APP_ERROR_CHECK(err_code);
break;//BLE_ADV_EVT_SLOW
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break;//BLE_ADV_EVT_IDLE
default:
break;
}
}
/**@brief Function for lighting up the LED corresponding to the notification received.
*
* @param[in] p_evt Event containing the notification.
*/
static void handle_alert_notification(ble_ans_c_evt_t * p_evt)
{
uint32_t err_code;
if (p_evt->uuid.uuid == BLE_UUID_UNREAD_ALERT_CHAR)
{
if (m_unread_alert_state == ALERT_NOTIFICATION_ENABLED)
{
err_code = bsp_indication_set(BSP_INDICATE_ALERT_1);
APP_ERROR_CHECK(err_code);
m_unread_alert_state = ALERT_NOTIFICATION_ON;
}
}
else if (p_evt->uuid.uuid == BLE_UUID_NEW_ALERT_CHAR)
{
if (m_new_alert_state == ALERT_NOTIFICATION_ENABLED)
{
err_code = bsp_indication_set(BSP_INDICATE_ALERT_0);
APP_ERROR_CHECK(err_code);
m_new_alert_state = ALERT_NOTIFICATION_ON;
}
}
else
{
// Only Unread and New Alerts exists, thus do nothing.
}
}
/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
uint32_t err_code;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_DIRECTED:
NRF_LOG_INFO("Directed advertising\r\n");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_DIRECTED);
APP_ERROR_CHECK(err_code);
break; // BLE_ADV_EVT_DIRECTED
case BLE_ADV_EVT_FAST:
NRF_LOG_INFO("Fast advertising\r\n");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break; // BLE_ADV_EVT_FAST
case BLE_ADV_EVT_SLOW:
NRF_LOG_INFO("Slow advertising\r\n");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_SLOW);
APP_ERROR_CHECK(err_code);
break; // BLE_ADV_EVT_SLOW
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break; // BLE_ADV_EVT_IDLE
default:
break;
}
}
/**@brief Function for the Signals alert event from Immediate Alert or Link Loss services.
*
* @param[in] alert_level Requested alert level.
*/
static void alert_signal(uint8_t alert_level)
{
uint32_t err_code;
switch (alert_level)
{
case BLE_CHAR_ALERT_LEVEL_NO_ALERT:
err_code = bsp_indication_set(BSP_INDICATE_ALERT_OFF);
APP_ERROR_CHECK(err_code);
break;
case BLE_CHAR_ALERT_LEVEL_MILD_ALERT:
err_code = bsp_indication_set(BSP_INDICATE_ALERT_0);
APP_ERROR_CHECK(err_code);
break;
case BLE_CHAR_ALERT_LEVEL_HIGH_ALERT:
err_code = bsp_indication_set(BSP_INDICATE_ALERT_3);
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;
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);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
app_beacon_start();
break;
case BLE_GAP_EVT_DISCONNECTED:
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
app_beacon_stop();
// 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);
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:
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_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);
err_code = bsp_indication_set(BSP_INDICATE_ALERT_OFF);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
int main(void)
{
uint32_t err_code;
// Initialize.
timers_init();
err_code = bsp_init(BSP_INIT_LED, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), NULL);
APP_ERROR_CHECK(err_code);
uart_init();
ble_stack_init();
twi_master_init();
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
nrf_delay_ms(200);
bsp_indication_set(BSP_INDICATE_IDLE);
nrf_delay_ms(200);
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
update_sensor(0);
start_advertising();
timers_start();
// Enter main loop.
for (;; )
{
power_manage();
}
}
/**
* @brief Function for application main entry.
* @return 0. int return type required by ANSI/ISO standard.
*/
int main(void)
{
uint32_t err_code = NRF_SUCCESS;
clock_initialization();
APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, NULL);
err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
err_code = bsp_init(BSP_INIT_LED, APP_TIMER_TICKS(100, APP_TIMER_PRESCALER), NULL);
APP_ERROR_CHECK(err_code);
// Set radio configuration parameters
radio_configure();
NRF_RADIO->PACKETPTR = (uint32_t)&packet;
err_code = bsp_indication_set(BSP_INDICATE_USER_STATE_OFF);
NRF_LOG_INFO("Wait for first packet\r\n");
APP_ERROR_CHECK(err_code);
NRF_LOG_FLUSH();
while (true)
{
uint32_t received = read_packet();
err_code = bsp_indication_set(BSP_INDICATE_RCV_OK);
NRF_LOG_INFO("Packet was received\r\n");
APP_ERROR_CHECK(err_code);
NRF_LOG_INFO("The contents of the package is %u\r\n", (unsigned int)received);
NRF_LOG_FLUSH();
}
}
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
for (;;) {
bsp_indication_set(BSP_INDICATE_FATAL_ERROR);
nrf_delay_ms(500);
bsp_indication_set(BSP_INDICATE_IDLE);
nrf_delay_ms(500);
}
app_error_handler(0xDEADBEEF, line_num, p_file_name);
}
/**@brief Thread for handling the Application's BLE Stack events.
*
* @details This thread is responsible for handling BLE Stack events sended from on_ble_evt().
*
* @param[in] arg Pointer used for passing some arbitrary information (context) from the
* osThreadCreate() call to the thread.
*/
void ble_stack_thread(void const * arg)
{
uint32_t err_code;
osEvent evt;
ble_evt_t * p_ble_evt;
UNUSED_PARAMETER(arg);
while (1)
{
evt = osMessageGet(ble_stack_msg_box, osWaitForever); // wait for message
if (evt.status == osEventMessage)
{
p_ble_evt = evt.value.p;
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);
m_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_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);
// enable buttons to wake-up from power off
bsp_buttons_enable( (1 <<
WAKEUP_BUTTON_ID) | (1 << BOND_DELETE_ALL_BUTTON_ID) );
// 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;
}
(void)osPoolFree(ble_evt_pool, p_ble_evt);
}
}
}
/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
uint32_t err_code;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_DIRECTED:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_DIRECTED);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_FAST:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_SLOW:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_SLOW);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_FAST_WHITELIST:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_WHITELIST);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_SLOW_WHITELIST:
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING_WHITELIST);
APP_ERROR_CHECK(err_code);
err_code = ble_advertising_restart_without_whitelist();
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break;
case BLE_ADV_EVT_WHITELIST_REQUEST:
{
ble_gap_whitelist_t whitelist;
ble_gap_addr_t * p_whitelist_addr[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t * p_whitelist_irk[BLE_GAP_WHITELIST_IRK_MAX_COUNT];
whitelist.addr_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
whitelist.irk_count = BLE_GAP_WHITELIST_IRK_MAX_COUNT;
whitelist.pp_addrs = p_whitelist_addr;
whitelist.pp_irks = p_whitelist_irk;
err_code = dm_whitelist_create(&m_app_handle, &whitelist);
APP_ERROR_CHECK(err_code);
err_code = ble_advertising_whitelist_reply(&whitelist);
APP_ERROR_CHECK(err_code);
break;
}
default:
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;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected\r\n");
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
break; // BLE_GAP_EVT_DISCONNECTED
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected\r\n");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_cur_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = ble_db_discovery_start(&m_ble_db_discovery, m_cur_conn_handle);
APP_ERROR_CHECK(err_code);
err_code = app_timer_start(m_sec_req_timer_id, SECURITY_REQUEST_DELAY, NULL);
APP_ERROR_CHECK(err_code);
break; // BLE_GAP_EVT_CONNECTED
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.\r\n");
m_cur_conn_handle = BLE_CONN_HANDLE_INVALID;
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break; // BLE_GATTC_EVT_TIMEOUT
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.\r\n");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break; // BLE_GATTS_EVT_TIMEOUT
#if (NRF_SD_BLE_API_VERSION == 3)
case BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST:
err_code = sd_ble_gatts_exchange_mtu_reply(p_ble_evt->evt.gatts_evt.conn_handle,
NRF_BLE_MAX_MTU_SIZE);
APP_ERROR_CHECK(err_code);
break; // BLE_GATTS_EVT_EXCHANGE_MTU_REQUEST
#endif
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;
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);
m_advertising_mode = BLE_NO_ADV;
m_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);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
advertising_start();
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING)
{
if (m_advertising_mode == BLE_SLEEP)
{
sleep_mode_enter();
}
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 events coming from the S132 SoftDevice
* @param[in] p_ble_evt Pointer to the ble event
*/
void eddystone_advertising_manager_on_ble_evt( ble_evt_t * p_ble_evt )
{
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
bsp_indication_set(BSP_INDICATE_IDLE);
LEDS_ON(1<<LED_2);
LEDS_OFF(1<<LED_3);
m_is_connectable_adv = false;
m_is_connected = true;
slots_advertising_start();
break;
case BLE_GAP_EVT_DISCONNECTED:
bsp_indication_set(BSP_INDICATE_IDLE);
LEDS_OFF(1<<LED_2);
LEDS_OFF(1<<LED_3);
m_is_connected = false;
m_is_connectable_adv = false;
all_advertising_halt();
adv_interval_timer_start();
//Essentially gives 1 advertising interval's time for flash to write
break;
case BLE_GAP_EVT_TIMEOUT:
if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING)
{
//When connectable advertising times out, switch back to Non-connectable
bsp_indication_set(BSP_INDICATE_IDLE);
LEDS_OFF(1<<LED_3);
m_is_connectable_adv = false;
slots_advertising_start();
}
break;
case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
if (p_ble_evt->evt.gatts_evt.params.authorize_request.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
{
DEBUG_PRINTF(0,"Stop Advertising For A bit!! \r\n",0);
all_advertising_halt();
adv_interval_timer_start();
}
default:
// No implementation needed.
break;
}
}
/**@brief Callback function for Gazell Transmit fail. Resends the current packet.
*/
void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info)
{
bool push_ok;
uint8_t dummy[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH];
uint32_t dummy_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH;
uint32_t err_code;
// If the transmission failed, send a new packet.
err_code = bsp_indication_set(BSP_INDICATE_SEND_ERROR);
APP_ERROR_CHECK(err_code);
if (tx_info.payload_received_in_ack)
{
// if data received attached to the ack, pop them.
push_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, dummy, &dummy_length);
if (!push_ok)
{
GET_GAZELL_ERROR();
}
}
push_ok = nrf_gzll_add_packet_to_tx_fifo(0, m_gzll_packet, PAYLOAD_SIZE);
if (!push_ok)
{
GET_GAZELL_ERROR();
}
}
/**@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 = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
err_code = bsp_indication_set(BSP_INDICATE_ALERT_OFF);
APP_ERROR_CHECK(err_code);
// Prepare wakeup buttons.
err_code = bsp_btn_ble_sleep_mode_prepare();
APP_ERROR_CHECK(err_code);
// Go to system-off mode (this function will not return; wakeup will cause a reset).
err_code = sd_power_system_off();
APP_ERROR_CHECK(err_code);
}
/**@brief Handler for SPI1 master events.
*
* @param[in] spi_master_evt SPI master event.
*/
void spi_master_1_event_handler(spi_master_evt_t spi_master_evt)
{
uint32_t err_code = NRF_SUCCESS;
bool result = false;
switch (spi_master_evt.evt_type)
{
case SPI_MASTER_EVT_TRANSFER_COMPLETED:
// Check if received data is correct.
result = check_buf_equal(m_tx_data_spi, m_rx_data_spi, TX_RX_MSG_LENGTH);
APP_ERROR_CHECK_BOOL(result);
// Close SPI master.
spi_master_close(SPI_MASTER_1);
err_code = bsp_indication_set(BSP_INDICATE_RCV_OK);
APP_ERROR_CHECK(err_code);
m_transfer_completed = true;
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;
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);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
m_conn_handle = BLE_CONN_HANDLE_INVALID;
m_bps_meas_ind_conf_pending = false;
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;
}
}
/*lint -save -e14 */
__WEAK void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name)
{
// On assert, the system can only recover with a reset.
#ifndef DEBUG
NVIC_SystemReset();
#else
#ifdef BSP_DEFINES_ONLY
LEDS_ON(LEDS_MASK);
#else
UNUSED_VARIABLE(bsp_indication_set(BSP_INDICATE_FATAL_ERROR));
// This call can be used for debug purposes during application development.
// @note CAUTION: Activating this code will write the stack to flash on an error.
// This function should NOT be used in a final product.
// It is intended STRICTLY for development/debugging purposes.
// The flash write will happen EVEN if the radio is active, thus interrupting
// any communication.
// Use with care. Uncomment the line below to use.
//ble_debug_assert_handler(error_code, line_num, p_file_name);
#endif // BSP_DEFINES_ONLY
m_error_code = error_code;
m_line_num = line_num;
m_p_file_name = p_file_name;
UNUSED_VARIABLE(m_error_code);
UNUSED_VARIABLE(m_line_num);
UNUSED_VARIABLE(m_p_file_name);
__disable_irq();
while(1) ;
#endif // DEBUG
}
/**@brief Function for SPI master event callback.
*
* Upon receiving an SPI transaction complete event, checks if received data are valid.
*
* @param[in] spi_master_evt SPI master driver event.
*/
static void spi_master_event_handler(spi_master_evt_t spi_master_evt)
{
uint32_t err_code = NRF_SUCCESS;
bool result = false;
switch (spi_master_evt.evt_type)
{
case SPI_MASTER_EVT_TRANSFER_COMPLETED:
// Check if data are vaild.
result = buf_check(m_rx_data, spi_master_evt.data_count);
APP_ERROR_CHECK_BOOL(result);
err_code = bsp_indication_set(BSP_INDICATE_RCV_OK);
APP_ERROR_CHECK(err_code);
// Inform application that transfer is completed.
m_transfer_completed = true;
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:
APPL_LOG("BLE_GAP_EVT_CONNECTED : %u\n", p_ble_evt->header.evt_id);
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
//err_code = app_timer_start(m_app_timer_id, APP_TIMER_ADC_INTERVAL, NULL);
//APP_ERROR_CHECK(err_code);
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
APPL_LOG("BLE_GAP_EVT_DISCONNECTED : %u\n", p_ble_evt->header.evt_id);
m_conn_handle = BLE_CONN_HANDLE_INVALID;
//nrf_adc_stop();
//app_timer_stop(m_app_timer_id);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Thread for handling the Application's BLE Stack events.
*
* @details This thread is responsible for handling BLE Stack events sent from on_ble_evt().
*
* @param[in] arg Pointer used for passing some arbitrary information (context) from the
* osThreadCreate() call to the thread.
*/
void ble_stack_thread(void const * arg)
{
uint32_t err_code;
osEvent evt;
ble_evt_t * p_ble_evt;
UNUSED_PARAMETER(arg);
while (1)
{
evt = osMessageGet(ble_stack_msg_box, osWaitForever); // wait for message
if (evt.status == osEventMessage)
{
p_ble_evt = evt.value.p;
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);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break;
default:
// No implementation needed.
break;
}
(void)osPoolFree(ble_evt_pool, p_ble_evt);
}
}
}
/**@brief Function for handling the key of the Unread Alert button.
*
* @details This function check the current state of unread alert and then, enable, disable or
* clear the alert depending on the state.
*/
static void unread_alert_state_toggle(void)
{
uint32_t err_code = NRF_SUCCESS;
if (m_unread_alert_state == ALERT_NOTIFICATION_ON)
{
m_unread_alert_state = ALERT_NOTIFICATION_ENABLED;
err_code = bsp_indication_set(BSP_INDICATE_ALERT_OFF);
}
else if (m_unread_alert_state == ALERT_NOTIFICATION_ENABLED)
{
m_unread_alert_state = ALERT_NOTIFICATION_DISABLED;
err_code = ble_ans_c_disable_notif_unread_alert(&m_ans_c);
}
else
{
m_unread_alert_state = ALERT_NOTIFICATION_ENABLED;
err_code = ble_ans_c_enable_notif_unread_alert(&m_ans_c);
}
// If the user presses the button while we are not connected,
// we will have NRF_ERROR_INVALID_STATE, thus we just ignore the error code.
if (err_code != NRF_SUCCESS && err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_HANDLER(err_code);
}
}
/**@brief Function for dispatching a ANT stack event to all modules with an ANT stack event handler.
*
* @details This function is called from the ANT stack event interrupt handler after an ANT stack
* event has been received.
*
* @param[in] p_ant_evt ANT stack event.
*/
void ant_evt_dispatch(ant_evt_t * p_ant_evt)
{
uint32_t err_code;
if (p_ant_evt->channel == ANT_BROADCAST_CHANNEL_NUMBER)
{
ANT_MESSAGE * p_message = (ANT_MESSAGE *)p_ant_evt->msg.evt_buffer;
switch (p_ant_evt->event)
{
case EVENT_RX:
if (p_message->ANT_MESSAGE_ucMesgID == MESG_BROADCAST_DATA_ID
|| p_message->ANT_MESSAGE_ucMesgID == MESG_ACKNOWLEDGED_DATA_ID
|| p_message->ANT_MESSAGE_ucMesgID == MESG_BURST_DATA_ID)
{
err_code = bsp_indication_set(BSP_INDICATE_RCV_OK);
APP_ERROR_CHECK(err_code);
}
break;
default:
break;
}
}
}
/**@brief Function for initializing the DTM mode.
*/
static void dtm_init(void)
{
uint32_t err_code;
app_uart_stream_comm_params_t uart_params;
uart_params.baud_rate = UART_BAUD_RATE_19200;
uart_params.rx_pin_no = DTM_RX_PIN_NO;
uart_params.tx_pin_no = DTM_TX_PIN_NO;
err_code = ble_dtm_init(&uart_params);
if (err_code == NRF_SUCCESS)
{
err_code = bsp_indication_set(BSP_INDICATE_USER_STATE_OFF);
APP_ERROR_CHECK(err_code);
// Close serialization transport layer.
err_code = sd_softdevice_disable();
APP_ERROR_CHECK(err_code);
// Enter to infinite loop.
for (;;)
{
err_code = sd_app_evt_wait();
APP_ERROR_CHECK(err_code);
}
}
APP_ERROR_CHECK(err_code);
}
/**@breif Function to start scanning.
*/
static void scan_start(void)
{
ble_gap_whitelist_t whitelist;
ble_gap_addr_t * p_whitelist_addr[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t * p_whitelist_irk[BLE_GAP_WHITELIST_IRK_MAX_COUNT];
uint32_t err_code;
uint32_t count;
// Verify if there is any flash access pending, if yes delay starting scanning until
// it's complete.
err_code = pstorage_access_status_get(&count);
APP_ERROR_CHECK(err_code);
if (count != 0)
{
m_memory_access_in_progress = true;
return;
}
// Initialize whitelist parameters.
whitelist.addr_count = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
whitelist.irk_count = 0;
whitelist.pp_addrs = p_whitelist_addr;
whitelist.pp_irks = p_whitelist_irk;
// Request creating of whitelist.
err_code = dm_whitelist_create(&m_dm_app_id,&whitelist);
APP_ERROR_CHECK(err_code);
if (((whitelist.addr_count == 0) && (whitelist.irk_count == 0)) ||
(m_scan_mode != BLE_WHITELIST_SCAN))
{
// No devices in whitelist, hence non selective performed.
m_scan_param.active = 0; // Active scanning set.
m_scan_param.selective = 0; // Selective scanning not set.
m_scan_param.interval = SCAN_INTERVAL;// Scan interval.
m_scan_param.window = SCAN_WINDOW; // Scan window.
m_scan_param.p_whitelist = NULL; // No whitelist provided.
m_scan_param.timeout = 0x0000; // No timeout.
}
else
{
// Selective scanning based on whitelist first.
m_scan_param.active = 0; // Active scanning set.
m_scan_param.selective = 1; // Selective scanning not set.
m_scan_param.interval = SCAN_INTERVAL;// Scan interval.
m_scan_param.window = SCAN_WINDOW; // Scan window.
m_scan_param.p_whitelist = &whitelist; // Provide whitelist.
m_scan_param.timeout = 0x001E; // 30 seconds timeout.
// Set whitelist scanning state.
m_scan_mode = BLE_WHITELIST_SCAN;
}
err_code = sd_ble_gap_scan_start(&m_scan_param);
APP_ERROR_CHECK(err_code);
err_code = bsp_indication_set(BSP_INDICATE_SCANNING);
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:
printf("Connected.\n\r");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
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;
break;
case BLE_GATTC_EVT_TIMEOUT:
case BLE_GATTS_EVT_TIMEOUT:
printf("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 Function for application main entry.
*/
int main(void)
{
uint32_t err_code;
radio_mode_t previous_mode = running_mode;
ble_stack_start();
timers_init();
bsp_init_app();
ble_hrs_app_start();
// Enter main loop.
for (;;)
{
power_manage();
if (running_mode != previous_mode)
{
previous_mode = running_mode;
if (running_mode == GAZELL)
{
// Stop all heart rate functionality before disabling the SoftDevice.
ble_hrs_app_stop();
nrf_drv_gpiote_uninit();
// Disable the S110 stack.
ble_stack_stop();
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
// Enable Gazell.
gzll_app_start();
timers_init();
bsp_init_app();
}
else if (running_mode == BLE)
{
// Disable Gazell.
gzll_app_stop();
err_code = bsp_indication_set(BSP_INDICATE_IDLE);
APP_ERROR_CHECK(err_code);
// Re-enable the S110 stack.
ble_stack_start();
timers_init();
bsp_init_app();
ble_hrs_app_start();
}
}
}
}
/**@brief Function for handling BLE events.
*
* @param[in] p_ble_evt Bluetooth stack event.
* @param[in] p_context Unused.
*/
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
ret_code_t err_code = NRF_SUCCESS;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected.");
// LED indication will be changed when advertising starts.
break;
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("Connected.");
err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
NRF_LOG_DEBUG("PHY update request.");
ble_gap_phys_t const phys =
{
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
} break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
