/**@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 } } }