/**@brief Function for stack interrupt handling.
*
* Implemented to clear the pending flag when receiving
* an interrupt from the stack.
*/
void SD_EVT_IRQHandler(void)
{
uint32_t ulEvent;
while (sd_evt_get(&ulEvent) != NRF_ERROR_NOT_FOUND) // read out SOC events
{
ant_boot_settings_event(ulEvent);
}
}
static void uart_init(void)
{
#ifdef USE_UART_LOGGING
int status = NRF_SUCCESS;
const app_uart_comm_params_t uart_params = {
.rx_pin_no = RX_PIN_NUMBER,
.tx_pin_no = TX_PIN_NUMBER,
.rts_pin_no = RTS_PIN_NUMBER,
.cts_pin_no = CTS_PIN_NUMBER,
.flow_control = APP_UART_FLOW_CONTROL_ENABLED,
.use_parity = false,
.baud_rate = UART_BAUDRATE_BAUDRATE_Baud38400
};
APP_UART_FIFO_INIT(&uart_params, UART_RX_BUF_SIZE, UART_TX_BUF_SIZE, uart_event_handler, APP_IRQ_PRIORITY_LOW, status);
APP_ERROR_CHECK(status);
#endif
}
static void uart_putstring(const uint8_t * string)
{
#ifdef USE_UART_LOGGING
for(int i = 0; string[i] != 0; ++i)
app_uart_put(string[i]);
#endif
}
/**
* Interrupt handler for Softdevice events
*/
void SD_EVT_IRQHandler(void)
{
uint32_t evt;
ble_evt_t ble_evt;
uint16_t len;
while(sd_evt_get(&evt) == NRF_SUCCESS)
{
btle_hci_adv_sd_evt_handler(evt);
}
while (sd_ble_evt_get((uint8_t *) &evt, &len) == NRF_SUCCESS)
{
nrf_adv_conn_evt_handler(&ble_evt);
}
}
void SD_EVT_IRQHandler(void)
{
uint8_t evt_buf[sizeof(ble_evt_t) + BLE_L2CAP_MTU_DEF];
uint16_t evt_len;
ble_evt_t *p_ble_evt = (ble_evt_t *) evt_buf;
uint32_t event;
while ( sd_evt_get(&event) == NRF_SUCCESS )
{
sys_evt_dispatch(event);
}
evt_len = sizeof(evt_buf);
while (sd_ble_evt_get(evt_buf, &evt_len) == NRF_SUCCESS)
{
ble_evt_dispatch(p_ble_evt);
evt_len = sizeof(evt_buf);
}
}
/**@brief BLE Stack event interrupt
* Triggered whenever an event is ready to be pulled
*/
void SD_EVT_IRQHandler (void)
{
uint32_t evt;
ble_evt_t ble_evt;
uint16_t len;
while (sd_evt_get(&evt) == NRF_SUCCESS)
{
g_evt = evt;
switch (evt)
{
case NRF_EVT_RADIO_SESSION_IDLE:
case NRF_EVT_RADIO_BLOCKED:
/* Request a new timeslot */
ASSERT (btle_scan_enable_set (scan_enable) == BTLE_STATUS_CODE_SUCCESS);
break;
case NRF_EVT_RADIO_SESSION_CLOSED:
break;
case NRF_EVT_RADIO_SIGNAL_CALLBACK_INVALID_RETURN:
ASSERT(false);
break;
case NRF_EVT_RADIO_CANCELED:
ASSERT (btle_scan_enable_set (scan_enable) == BTLE_STATUS_CODE_SUCCESS);
break;
default:
/* This should not happen */
__LOG ("%s: Program failure, undefined event = %d", __FUNCTION__, evt);
ASSERT(false);
}
}
while (sd_ble_evt_get((uint8_t *) &evt, &len) == NRF_SUCCESS)
{
nrf_adv_conn_evt_handler(&ble_evt);
}
}
/**
* @brief Timeslot related events callback
* Called whenever the softdevice tries to change the original course of actions
* related to the timeslots
*/
void ts_sd_event_handler(void)
{
uint32_t evt;
SET_PIN(6);
while (sd_evt_get(&evt) == NRF_SUCCESS)
{
PIN_OUT(evt, 32);
switch (evt)
{
case NRF_EVT_RADIO_SESSION_IDLE:
timeslot_order_earliest(TIMESLOT_SLOT_LENGTH, true);
break;
case NRF_EVT_RADIO_SESSION_CLOSED:
APP_ERROR_CHECK(NRF_ERROR_INVALID_DATA);
break;
case NRF_EVT_RADIO_BLOCKED:
/* something in the softdevice is blocking our requests,
go into emergency mode, where slots are short, in order to
avoid complete lockout */
timeslot_order_earliest(TIMESLOT_SLOT_EMERGENCY_LENGTH, true);
break;
case NRF_EVT_RADIO_SIGNAL_CALLBACK_INVALID_RETURN:
APP_ERROR_CHECK(NRF_ERROR_INVALID_DATA);
break;
case NRF_EVT_RADIO_CANCELED:
timeslot_order_earliest(TIMESLOT_SLOT_LENGTH, true);
break;
default:
APP_ERROR_CHECK(NRF_ERROR_INVALID_STATE);
}
}
CLEAR_PIN(6);
}
void intern_softdevice_events_execute(void)
{
if (!m_softdevice_enabled)
{
// SoftDevice not enabled. This can be possible if the SoftDevice was enabled by the
// application without using this module's API (i.e softdevice_handler_init)
return;
}
bool no_more_soc_evts = (m_sys_evt_handler == NULL);
#ifdef BLE_STACK_SUPPORT_REQD
bool no_more_ble_evts = (m_ble_evt_handler == NULL);
#endif
#ifdef ANT_STACK_SUPPORT_REQD
bool no_more_ant_evts = (m_ant_evt_handler == NULL);
#endif
for (;;)
{
uint32_t err_code;
if (!no_more_soc_evts)
{
uint32_t evt_id;
// Pull event from SOC.
#if (defined(BLE_STACK_SUPPORT_REQD) && defined(ANT_STACK_SUPPORT_REQD)) || defined(ANT_STACK_SUPPORT_REQD)
// Experimental: The S310 and S210 SoftDevices APIs have a differnt name for the
// function to fetch the event.
err_code = sd_event_get(&evt_id);
#else
err_code = sd_evt_get(&evt_id);
#endif
if (err_code == NRF_ERROR_NOT_FOUND)
{
no_more_soc_evts = true;
}
else if (err_code != NRF_SUCCESS)
{
APP_ERROR_HANDLER(err_code);
}
else
{
// Call application's SOC event handler.
m_sys_evt_handler(evt_id);
}
}
#ifdef BLE_STACK_SUPPORT_REQD
// Fetch BLE Events.
if (!no_more_ble_evts)
{
// Pull event from stack
uint16_t evt_len = m_ble_evt_buffer_size;
err_code = sd_ble_evt_get(m_evt_buffer, &evt_len);
if (err_code == NRF_ERROR_NOT_FOUND)
{
no_more_ble_evts = true;
}
else if (err_code != NRF_SUCCESS)
{
APP_ERROR_HANDLER(err_code);
}
else
{
// Call application's BLE stack event handler.
m_ble_evt_handler((ble_evt_t *)m_evt_buffer);
}
}
#endif
#ifdef ANT_STACK_SUPPORT_REQD
// Fetch ANT Events.
if (!no_more_ant_evts)
{
// Pull event from stack
err_code = sd_ant_event_get(&((ant_evt_t *)m_evt_buffer)->channel,
&((ant_evt_t *)m_evt_buffer)->event,
((ant_evt_t *)m_evt_buffer)->evt_buffer);
if (err_code == NRF_ERROR_NOT_FOUND)
{
no_more_ant_evts = true;
}
else if (err_code != NRF_SUCCESS)
{
APP_ERROR_HANDLER(err_code);
}
else
{
// Call application's ANT stack event handler.
m_ant_evt_handler((ant_evt_t *)m_evt_buffer);
}
}
#endif
if (no_more_soc_evts)
{
// There are no remaining System (SOC) events to be fetched from the SoftDevice.
#if defined(ANT_STACK_SUPPORT_REQD) && defined(BLE_STACK_SUPPORT_REQD)
// Check if there are any remaining BLE and ANT events.
if (no_more_ble_evts && no_more_ant_evts)
{
break;
}
#elif defined(BLE_STACK_SUPPORT_REQD)
// Check if there are any remaining BLE events.
if (no_more_ble_evts)
{
break;
}
#elif defined(ANT_STACK_SUPPORT_REQD)
// Check if there are any remaining ANT events.
if (no_more_ant_evts)
{
break;
}
#else
// No need to check for BLE or ANT events since there is no support for BLE and ANT
// required.
break;
#endif
}
}
}
void intern_softdevice_events_execute(void)
{
if (!m_softdevice_enabled)
{
// SoftDevice not enabled. This can be possible if the SoftDevice was enabled by the
// application without using this module's API (i.e softdevice_handler_init)
return;
}
#if NRF_MODULE_ENABLED(CLOCK)
bool no_more_soc_evts = false;
#else
bool no_more_soc_evts = (m_sys_evt_handler == NULL);
#endif
#ifdef BLE_STACK_SUPPORT_REQD
bool no_more_ble_evts = (m_ble_evt_handler == NULL);
#endif
#ifdef ANT_STACK_SUPPORT_REQD
bool no_more_ant_evts = (m_ant_evt_handler == NULL);
#endif
for (;;)
{
uint32_t err_code;
if (!no_more_soc_evts)
{
if (m_suspended)
{
// Cancel pulling next event if event handler was suspended by user.
return;
}
uint32_t evt_id;
// Pull event from SOC.
err_code = sd_evt_get(&evt_id);
if (err_code == NRF_ERROR_NOT_FOUND)
{
no_more_soc_evts = true;
}
else if (err_code != NRF_SUCCESS)
{
APP_ERROR_HANDLER(err_code);
}
else
{
// Call application's SOC event handler.
#if (NRF_MODULE_ENABLED(CLOCK) && defined(SOFTDEVICE_PRESENT))
nrf_drv_clock_on_soc_event(evt_id);
if (m_sys_evt_handler)
{
m_sys_evt_handler(evt_id);
}
#else
m_sys_evt_handler(evt_id);
#endif
}
}
#ifdef BLE_STACK_SUPPORT_REQD
// Fetch BLE Events.
if (!no_more_ble_evts)
{
if (m_suspended)
{
// Cancel pulling next event if event handler was suspended by user.
return;
}
// Pull event from stack
uint16_t evt_len = m_ble_evt_buffer_size;
err_code = sd_ble_evt_get(mp_ble_evt_buffer, &evt_len);
if (err_code == NRF_ERROR_NOT_FOUND)
{
no_more_ble_evts = true;
}
else if (err_code != NRF_SUCCESS)
{
APP_ERROR_HANDLER(err_code);
}
else
{
// Call application's BLE stack event handler.
m_ble_evt_handler((ble_evt_t *)mp_ble_evt_buffer);
}
}
#endif
#ifdef ANT_STACK_SUPPORT_REQD
// Fetch ANT Events.
if (!no_more_ant_evts)
{
if (m_suspended)
{
// Cancel pulling next event if event handler was suspended by user.
return;
}
// Pull event from stack
err_code = sd_ant_event_get(&m_ant_evt_buffer.channel,
&m_ant_evt_buffer.event,
m_ant_evt_buffer.msg.evt_buffer);
if (err_code == NRF_ERROR_NOT_FOUND)
{
no_more_ant_evts = true;
}
else if (err_code != NRF_SUCCESS)
{
APP_ERROR_HANDLER(err_code);
}
else
{
// Call application's ANT stack event handler.
m_ant_evt_handler(&m_ant_evt_buffer);
}
}
#endif
if (no_more_soc_evts)
{
// There are no remaining System (SOC) events to be fetched from the SoftDevice.
#if defined(ANT_STACK_SUPPORT_REQD) && defined(BLE_STACK_SUPPORT_REQD)
// Check if there are any remaining BLE and ANT events.
if (no_more_ble_evts && no_more_ant_evts)
{
break;
}
#elif defined(BLE_STACK_SUPPORT_REQD)
// Check if there are any remaining BLE events.
if (no_more_ble_evts)
{
break;
}
#elif defined(ANT_STACK_SUPPORT_REQD)
// Check if there are any remaining ANT events.
if (no_more_ant_evts)
{
break;
}
#else
// No need to check for BLE or ANT events since there is no support for BLE and ANT
// required.
break;
#endif
}
}
}
