Events#

RAIL_Events_t#

RAIL_Events_t

RAIL events passed to the event callback.

More than one event may be indicated due to interrupt latency.

DeprecatedRAIL 2.x synonym of sl_rail_events_t.

sl_rail_events_t#

sl_rail_events_t

RAIL events passed to the event callback.

More than one event may be indicated due to interrupt latency.

RAIL_ConfigEvents#

RAIL_Status_t RAIL_ConfigEvents (RAIL_Handle_t railHandle, RAIL_Events_t mask, RAIL_Events_t events)

Configure radio events.

Returns

• Status code indicating success of the function call.

Sets up which radio interrupts generate a RAIL event. The full list of events is in RAIL_Events_t.

DeprecatedRAIL 2.x synonym of sl_rail_config_events().

sl_rail_config_events#

sl_rail_status_t sl_rail_config_events (sl_rail_handle_t rail_handle, sl_rail_events_t mask, sl_rail_events_t events)

Configure radio events.

Returns

• Status code indicating success of the function call.

Sets up which radio interrupts generate a RAIL event. The full list of events is in sl_rail_events_t.

sl_rail_get_events_config#

sl_rail_events_t sl_rail_get_events_config (sl_rail_handle_t rail_handle)

Get configured events.

Returns

• A sl_rail_events_t with bits set for enabled events and clear for disabled events.

RAIL_EVENTS_NONE#

#define RAIL_EVENTS_NONE

0ULL

A value representing no events.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENTS_NONE.

RAIL_EVENT_RSSI_AVERAGE_DONE#

#define RAIL_EVENT_RSSI_AVERAGE_DONE

(1ULL << RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT)

Occurs when the hardware-averaged RSSI is done in response to RAIL_StartAverageRssi() to indicate that the hardware has completed averaging.

Call RAIL_GetAverageRssi() to get the result.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RSSI_AVERAGE_DONE.

RAIL_EVENT_RX_ACK_TIMEOUT#

#define RAIL_EVENT_RX_ACK_TIMEOUT

(1ULL << RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT)

Occurs when the Ack timeout expires while waiting to receive the sync word of an expected Ack.

If the timeout occurs within packet reception, this event won't be signaled until after packet completion has determined the packet wasn't the expected Ack. See RAIL_RxPacketDetails_t::isAck for the definition of an expected Ack.

This event only occurs after calling RAIL_ConfigAutoAck() and after transmitting a packet with RAIL_TX_OPTION_WAIT_FOR_ACK set.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_ACK_TIMEOUT.

RAIL_EVENT_RX_FIFO_ALMOST_FULL#

#define RAIL_EVENT_RX_FIFO_ALMOST_FULL

(1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)

Keeps occurring as long as the number of bytes in the receive FIFO exceeds the configured threshold value.

Call RAIL_GetRxFifoBytesAvailable() to get the number of bytes available. When using this event, the threshold should be set via RAIL_SetRxFifoThreshold().

How to avoid sticking in the event handler (even in idle state):

1. Disable the event (via the config events API or the RAIL_FIFO_THRESHOLD_DISABLED parameter)

2. Increase FIFO threshold

3. Read the FIFO (that's not an option in RAIL_DataMethod_t::PACKET_MODE) in the event handler

   DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL.

RAIL_EVENT_RX_PACKET_RECEIVED#

#define RAIL_EVENT_RX_PACKET_RECEIVED

(1ULL << RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT)

Occurs whenever a packet is received with RAIL_RX_PACKET_READY_SUCCESS or RAIL_RX_PACKET_READY_CRC_ERROR.

Call RAIL_GetRxPacketInfo() to get basic information about the packet along with a handle to this packet for subsequent use with RAIL_PeekRxPacket(), RAIL_GetRxPacketDetails(), RAIL_HoldRxPacket(), and RAIL_ReleaseRxPacket() as needed.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_PACKET_RECEIVED.

RAIL_EVENT_RX_PREAMBLE_LOST#

#define RAIL_EVENT_RX_PREAMBLE_LOST

(1ULL << RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT)

Occurs when the radio has lost a preamble.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a RAIL_EVENT_RX_PREAMBLE_DETECT event has already occurred.

Note

• See warning for RAIL_EVENT_RX_PREAMBLE_DETECT.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_PREAMBLE_LOST.

RAIL_EVENT_RX_PREAMBLE_DETECT#

#define RAIL_EVENT_RX_PREAMBLE_DETECT

(1ULL << RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT)

Occurs when the radio has detected a preamble.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a RAIL_EVENT_RX_TIMING_DETECT event has already occurred.

Warnings

• This event, along with RAIL_EVENT_RX_PREAMBLE_LOST, may not work on some demodulators. Some demodulators usurped the signals on which these events are based for another purpose. These demodulators in particular are available on the EFR32xG23, EFR32xG25, and the EFR32xG28 platforms. Enabling these events on these platforms may cause the events to fire infinitely and possibly freeze the application.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_PREAMBLE_DETECT.

RAIL_EVENT_RX_SYNC1_DETECT#

#define RAIL_EVENT_RX_SYNC1_DETECT

(1ULL << RAIL_EVENT_RX_SYNC1_DETECT_SHIFT)

Occurs when the first sync word is detected.

After this event occurs, one of the events in the RAIL_EVENTS_RX_COMPLETION mask will occur.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_SYNC_0_DETECT.

RAIL_EVENT_RX_SYNC2_DETECT#

#define RAIL_EVENT_RX_SYNC2_DETECT

(1ULL << RAIL_EVENT_RX_SYNC2_DETECT_SHIFT)

Occurs when the second sync word is detected.

After this event occurs, one of the events in the RAIL_EVENTS_RX_COMPLETION mask will occur.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_SYNC_1_DETECT.

RAIL_EVENT_RX_FRAME_ERROR#

#define RAIL_EVENT_RX_FRAME_ERROR

(1ULL << RAIL_EVENT_RX_FRAME_ERROR_SHIFT)

Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_CRC_ERROR which only happens after any filtering has passed.

For EFR32 parts, this event includes CRC errors, block decoding errors, and illegal frame length – when detected after filtering. (When such errors are detected during filtering, they're signaled as RAIL_EVENT_RX_PACKET_ABORTED instead.)

If RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event will not occur for CRC errors, but could still occur for the other errors.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_FRAME_ERROR.

RAIL_EVENT_RX_FIFO_FULL#

#define RAIL_EVENT_RX_FIFO_FULL

(1ULL << RAIL_EVENT_RX_FIFO_FULL_SHIFT)

When using RAIL_RxDataSource_t::RX_PACKET_DATA this event occurs coincident to a receive packet completion event in which the receive FIFO or any supplemental packet metadata FIFO (see Data Management) are full and further packet reception is jeopardized.

It signals that an overflow is imminent (and may already have occurred) telling the application it should release the oldest packet(s) as soon as possible. This event may may be posted multiple times with subsequent receive completion events if the FIFO(s) remain full, and should also occur coincident with RAIL_EVENT_RX_FIFO_OVERFLOW.

When not using RAIL_RxDataSource_t::RX_PACKET_DATA this event is not tied to packet completion and will occur coincident with RAIL_EVENT_RX_FIFO_OVERFLOW when the receive FIFO has filled and overflowed. The application should consume receive FIFO data via RAIL_ReadRxFifo() as soon as possible to minimize lost raw data.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_FIFO_FULL.

RAIL_EVENT_RX_FIFO_OVERFLOW#

#define RAIL_EVENT_RX_FIFO_OVERFLOW

(1ULL << RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT)

When using RAIL_RxDataSource_t::RX_PACKET_DATA this event occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_OVERFLOW due to overflowing the receive FIFO or any supplemental packet metadata FIFO (see Data Management).

The radio suspends receiving packets until this event is posted and the receive FIFO(s) have been fully processed (drained and released or reset). It is not guaranteed that a RAIL_EVENT_RX_FIFO_FULL will precede this event, but both events should be coincident.

When not using RAIL_RxDataSource_t::RX_PACKET_DATA this event is not tied to packet completion and will occur coincident with RAIL_EVENT_RX_FIFO_FULL when the receive FIFO has filled and overflowed. The application should consume receive FIFO data via RAIL_ReadRxFifo() as soon as possible to minimize lost raw data.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_FIFO_OVERFLOW.

RAIL_EVENT_RX_ADDRESS_FILTERED#

#define RAIL_EVENT_RX_ADDRESS_FILTERED

(1ULL << RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT)

Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_FILTERED because its address does not match the filtering settings.

This event can only occur after calling RAIL_EnableAddressFilter().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_ADDRESS_FILTERED.

RAIL_EVENT_RX_TIMEOUT#

#define RAIL_EVENT_RX_TIMEOUT

(1ULL << RAIL_EVENT_RX_TIMEOUT_SHIFT)

Occurs when an RX event times out.

This event can only occur if the RAIL_StateTiming_t::rxSearchTimeout passed to RAIL_SetStateTiming() is not zero.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_TIMEOUT.

RAIL_EVENT_SCHEDULED_RX_STARTED#

#define RAIL_EVENT_SCHEDULED_RX_STARTED

(1ULL << RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT)

Occurs when a scheduled RX begins turning on the receiver.

This event has the same numerical value as RAIL_EVENT_SCHEDULED_TX_STARTED because one cannot schedule both RX and TX simultaneously.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED.

RAIL_EVENT_RX_SCHEDULED_RX_END#

#define RAIL_EVENT_RX_SCHEDULED_RX_END

(1ULL << RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT)

Occurs when the scheduled RX window ends.

This event only occurs in response to a scheduled receive timeout after calling RAIL_ScheduleRx(). If RAIL_ScheduleRxConfig_t::rxTransitionEndSchedule was passed as false, this event will occur unless the receive is aborted (due to a call to RAIL_Idle() or a scheduler preemption, for instance). If RAIL_ScheduleRxConfig_t::rxTransitionEndSchedule was passed as true, any of the RAIL_EVENTS_RX_COMPLETION events occurring will also cause this event not to occur, since the scheduled receive will end with the transition at the end of the packet. However, if the application has not enabled the specific RAIL_EVENTS_RX_COMPLETION event which implicitly ended the scheduled receive, this event will be posted instead.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_SCHEDULED_RX_END.

RAIL_EVENT_RX_SCHEDULED_RX_MISSED#

#define RAIL_EVENT_RX_SCHEDULED_RX_MISSED

(1ULL << RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT)

Occurs when start of a scheduled receive is missed.

This can occur if the radio is put to sleep and not woken up with enough time to configure the scheduled receive event.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED.

RAIL_EVENT_RX_PACKET_ABORTED#

#define RAIL_EVENT_RX_PACKET_ABORTED

(1ULL << RAIL_EVENT_RX_PACKET_ABORTED_SHIFT)

Occurs when a receive is aborted during filtering with RAIL_RX_PACKET_ABORT_FORMAT or after filtering with RAIL_RX_PACKET_ABORT_ABORTED for reasons other than address filtering mismatch (which triggers RAIL_EVENT_RX_ADDRESS_FILTERED instead).

For EFR32 parts, this event includes CRC errors, block decoding errors, illegal frame length, and other RAIL built-in protocol-specific packet content errors – when detected during filtering. (When such errors are detected after filtering, they're signaled as RAIL_EVENT_RX_FRAME_ERROR instead.) It also includes application or multiprotocol scheduler aborting a receive after filtering has passed.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_PACKET_ABORTED.

RAIL_EVENT_RX_FILTER_PASSED#

#define RAIL_EVENT_RX_FILTER_PASSED

(1ULL << RAIL_EVENT_RX_FILTER_PASSED_SHIFT)

Occurs when the packet has passed any configured address and frame filtering options.

This event will only occur between the start of the packet, indicated by RAIL_EVENT_RX_SYNC1_DETECT or RAIL_EVENT_RX_SYNC2_DETECT and one of the events in the RAIL_EVENTS_RX_COMPLETION mask. It will always occur before or concurrently with RAIL_EVENT_RX_PACKET_RECEIVED. If IEEE 802.15.4 frame and address filtering are enabled, this event will occur immediately after destination address filtering.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_FILTER_PASSED.

RAIL_EVENT_RX_TIMING_LOST#

#define RAIL_EVENT_RX_TIMING_LOST

(1ULL << RAIL_EVENT_RX_TIMING_LOST_SHIFT)

Occurs when the modem timing is lost.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a RAIL_EVENT_RX_TIMING_DETECT event has already occurred.

Note

• See warning for RAIL_EVENT_RX_TIMING_DETECT.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_TIMING_LOST.

RAIL_EVENT_RX_TIMING_DETECT#

#define RAIL_EVENT_RX_TIMING_DETECT

(1ULL << RAIL_EVENT_RX_TIMING_DETECT_SHIFT)

Occurs when the modem timing is detected.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes.

Warnings

• This event, along with RAIL_EVENT_RX_TIMING_LOST, may not work on some demodulators. Some demodulators usurped the signals on which these events are based for another purpose. These demodulators in particular are available on the EFR32xG23, EFR32xG25, and the EFR32xG28 platforms. Enabling these events on these platforms may cause the events to fire infinitely and possibly freeze the application.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_TIMING_DETECT.

RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE#

#define RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE

(1ULL << RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT)

Occurs when RX Channel Hopping is enabled and channel hopping finishes receiving on the last channel in its sequence.

The intent behind this event is to allow the user to keep the radio on for as short a time as possible. That is, once the channel sequence is complete, the application will receive this event and can trigger a sleep/idle until it is necessary to cycle through the channels again. If this event is left on indefinitely and not handled it will likely be a fairly noisy event, as it continues to fire each time the hopping algorithm cycles through the channel sequence.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE.

RAIL_EVENT_RX_DUTY_CYCLE_RX_END#

#define RAIL_EVENT_RX_DUTY_CYCLE_RX_END

(1ULL << RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT)

Occurs during RX duty cycle mode when the radio finishes its time in receive mode.

The application can then trigger a sleep/idle until it needs to listen again.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END.

RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND#

#define RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND

(1ULL << RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT)

Indicate a Data Request is received when using IEEE 802.15.4 functionality.

It occurs when the command byte of an incoming Ack-requesting MAC Control frame is for a data request. This callback is called before the packet is fully received to allow the node to have more time to decide whether to indicate a frame is pending in the outgoing Ack. This event only occurs if the RAIL IEEE 802.15.4 functionality is enabled, but will never occur if promiscuous mode is enabled via RAIL_IEEE802154_SetPromiscuousMode().

Call RAIL_IEEE802154_GetAddress() to get the source address of the packet.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND.

RAIL_EVENT_ZWAVE_BEAM#

#define RAIL_EVENT_ZWAVE_BEAM

(1ULL << RAIL_EVENT_ZWAVE_BEAM_SHIFT)

Indicate a Z-Wave Beam Request relevant to the node was received.

This event only occurs if the RAIL Z-Wave functionality is enabled and its RAIL_ZWAVE_OPTION_DETECT_BEAM_FRAMES is enabled. This event is used in lieu of RAIL_EVENT_RX_PACKET_RECEIVED, which is reserved for Z-Wave packets other than Beams.

Call RAIL_ZWAVE_GetBeamNodeId() to get the Node Id to which the Beam was targeted, which would be either the broadcast id 0xFF or the node's own single-cast id.

Note

• All Z-Wave Beam requests are generally discarded, triggering RAIL_EVENT_RX_PACKET_ABORTED.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_ZWAVE_BEAM.

RAIL_EVENT_MFM_TX_BUFFER_DONE#

#define RAIL_EVENT_MFM_TX_BUFFER_DONE

(1ULL << RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT)

Indicate a MFM buffer has completely transmitted.

This event only occurs if the RAIL MFM functionality is enabled and a MFM buffer has completely transmitted.

Following this event, the application can update the MFM buffer that has transmitted to be used for the next transmission.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_MFM_TX_BUFFER_DONE.

RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND#

#define RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND

(1ULL << RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT)

Indicate a request for populating Z-Wave LR Ack packet.

This event only occurs if the RAIL Z-Wave functionality is enabled.

Following this event, the application must call RAIL_ZWAVE_SetLrAckData() to populate noise floor, TX power and receive RSSI fields of the Z-Wave Long Range Ack packet.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND.

RAIL_EVENTS_RX_COMPLETION#

#define RAIL_EVENTS_RX_COMPLETION

The mask representing all events that determine the end of a received packet.

After a RAIL_EVENT_RX_SYNC1_DETECT or a RAIL_EVENT_RX_SYNC2_DETECT, exactly one of the following events will occur. When one of these events occurs, a state transition will take place based on the parameter passed to RAIL_SetRxTransitions(). The RAIL_StateTransitions_t::success transition will be followed only if the RAIL_EVENT_RX_PACKET_RECEIVED event occurs. Any of the other events will trigger the RAIL_StateTransitions_t::error transition.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENTS_RX_COMPLETION.

RAIL_EVENT_TX_FIFO_ALMOST_EMPTY#

#define RAIL_EVENT_TX_FIFO_ALMOST_EMPTY

(1ULL << RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT)

Occurs when the number of bytes in the transmit FIFO falls below the configured threshold value.

This event does not occur on initialization or after resetting the transmit FIFO with RAIL_ResetFifo().

Call RAIL_GetTxFifoSpaceAvailable() to get the number of bytes available in the transmit FIFO at the time of the callback dispatch. When using this event, the threshold should be set via RAIL_SetTxFifoThreshold().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY.

RAIL_EVENT_TX_PACKET_SENT#

#define RAIL_EVENT_TX_PACKET_SENT

(1ULL << RAIL_EVENT_TX_PACKET_SENT_SHIFT)

Occurs after a packet has been transmitted.

Call RAIL_GetTxPacketDetails() to get information about the packet that was transmitted.

Note

• RAIL_GetTxPacketDetails() is only valid to call during the time frame of the RAIL_Config_t::eventsCallback().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_PACKET_SENT.

RAIL_EVENT_TXACK_PACKET_SENT#

#define RAIL_EVENT_TXACK_PACKET_SENT

(1ULL << RAIL_EVENT_TXACK_PACKET_SENT_SHIFT)

Occurs after an Ack packet has been transmitted.

Call RAIL_GetTxPacketDetails() to get information about the packet that was transmitted. This event can only occur after calling RAIL_ConfigAutoAck().

Note

• RAIL_GetTxPacketDetails() is only valid to call during the time frame of the RAIL_Config_t::eventsCallback().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TXACK_PACKET_SENT.

RAIL_EVENT_TX_ABORTED#

#define RAIL_EVENT_TX_ABORTED

(1ULL << RAIL_EVENT_TX_ABORTED_SHIFT)

Occurs when a transmit is aborted by the user.

This can happen due to calling RAIL_Idle() or due to a scheduler preemption.

Note

• The Transmit FIFO is left in an indeterminate state and should be reset prior to reuse for sending a new packet. Contrast this with RAIL_EVENT_TX_BLOCKED.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_ABORTED.

RAIL_EVENT_TXACK_ABORTED#

#define RAIL_EVENT_TXACK_ABORTED

(1ULL << RAIL_EVENT_TXACK_ABORTED_SHIFT)

Occurs when an Ack transmit is aborted by the user.

This event can only occur after calling RAIL_ConfigAutoAck(), which can happen due to calling RAIL_Idle() or due to a scheduler preemption.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TXACK_ABORTED.

RAIL_EVENT_TX_BLOCKED#

#define RAIL_EVENT_TX_BLOCKED

(1ULL << RAIL_EVENT_TX_BLOCKED_SHIFT)

Occurs when a transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called.

Note

• Since the transmit never started, the Transmit FIFO remains intact after this event – no packet data was consumed from it. Contrast this with RAIL_EVENT_TX_ABORTED.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_BLOCKED.

RAIL_EVENT_TXACK_BLOCKED#

#define RAIL_EVENT_TXACK_BLOCKED

(1ULL << RAIL_EVENT_TXACK_BLOCKED_SHIFT)

Occurs when an Ack transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called.

This event can only occur after calling RAIL_ConfigAutoAck().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TXACK_BLOCKED.

RAIL_EVENT_TX_UNDERFLOW#

#define RAIL_EVENT_TX_UNDERFLOW

(1ULL << RAIL_EVENT_TX_UNDERFLOW_SHIFT)

Occurs when the transmit buffer underflows.

This can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to RAIL_WriteTxFifo() calls not keeping up with the transmit rate if the entire packet isn't loaded at once.

Note

• The Transmit FIFO is left in an indeterminate state and should be reset prior to reuse for sending a new packet. Contrast this with RAIL_EVENT_TX_BLOCKED.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_UNDERFLOW.

RAIL_EVENT_TXACK_UNDERFLOW#

#define RAIL_EVENT_TXACK_UNDERFLOW

(1ULL << RAIL_EVENT_TXACK_UNDERFLOW_SHIFT)

Occurs when the Ack transmit buffer underflows.

This can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to RAIL_WriteAutoAckFifo() not being called at all before an Ack transmit.

This event can only occur after calling RAIL_ConfigAutoAck().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TXACK_UNDERFLOW.

RAIL_EVENT_TX_CHANNEL_CLEAR#

#define RAIL_EVENT_TX_CHANNEL_CLEAR

(1ULL << RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT)

Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) succeeds.

This event can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx() or their scheduled equivalent.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_CHANNEL_CLEAR.

RAIL_EVENT_TX_CHANNEL_BUSY#

#define RAIL_EVENT_TX_CHANNEL_BUSY

(1ULL << RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT)

Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) fails.

This event can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx() or their scheduled equivalent.

Note

• Since the transmit never started, the Transmit FIFO remains intact after this event – no packet data was consumed from it.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_CHANNEL_BUSY.

RAIL_EVENT_TX_CCA_RETRY#

#define RAIL_EVENT_TX_CCA_RETRY

(1ULL << RAIL_EVENT_TX_CCA_RETRY_SHIFT)

Occurs during CSMA or LBT when an individual Clear Channel Assessment (CCA) check fails, but there are more tries needed before the overall operation completes.

This event can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx() or their scheduled equivalent.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_CCA_RETRY.

RAIL_EVENT_TX_START_CCA#

#define RAIL_EVENT_TX_START_CCA

(1ULL << RAIL_EVENT_TX_START_CCA_SHIFT)

Occurs when the receiver is enabled to perform a Clear Channel Assessment (CCA) check.

This event generally precedes the actual CCA check activation by roughly the RAIL_StateTiming_t::idleToRx time (subject to RAIL_MINIMUM_TRANSITION_US). It can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx() or their scheduled equivalent.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_START_CCA.

RAIL_EVENT_TX_CCA_ACTIVATED#

#define RAIL_EVENT_TX_CCA_ACTIVATED

(1ULL << RAIL_EVENT_TX_CCA_ACTIVATED_SHIFT)

Occurs when the a Clear Channel Assessment (CCA) check is activated.

This event generally follows RAIL_EVENT_TX_START_CCA by roughly the RAIL_StateTiming_t::idleToRx time (subject to RAIL_MINIMUM_TRANSITION_US). It can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx() or their scheduled equivalent.

Note

• This event requires that RAIL_EVENT_TX_START_CCA also be enabled. It may not occur if the current CCA's backoff is 0.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_CCA_ACTIVATED.

RAIL_EVENT_TX_STARTED#

#define RAIL_EVENT_TX_STARTED

(1ULL << RAIL_EVENT_TX_STARTED_SHIFT)

Occurs when the radio starts transmitting a normal packet on the air.

A start-of-transmit time stamp is captured for this event. It can be retrieved by calling RAIL_GetTxTimePreambleStart() passing RAIL_TX_STARTED_BYTES for its totalPacketBytes parameter.

Note

• This event does not apply to Ack transmits. Currently there is no equivalent event or time stamp captured for the start of an Ack transmit.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_STARTED.

RAIL_TX_STARTED_BYTES#

#define RAIL_TX_STARTED_BYTES

0U

A value to pass as RAIL_GetTxTimePreambleStart() totalPacketBytes parameter to retrieve the RAIL_EVENT_TX_STARTED time stamp.

DeprecatedRAIL 2.x synonym of SL_RAIL_TX_STARTED_BYTES.

RAIL_EVENT_SCHEDULED_TX_STARTED#

#define RAIL_EVENT_SCHEDULED_TX_STARTED

(1ULL << RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT)

Occurs when a scheduled TX begins turning on the transmitter.

This event has the same numerical value as RAIL_EVENT_SCHEDULED_RX_STARTED because one cannot schedule both RX and TX simultaneously.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED.

RAIL_EVENT_TX_SCHEDULED_TX_MISSED#

#define RAIL_EVENT_TX_SCHEDULED_TX_MISSED

(1ULL << RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT)

Occurs when the start of a scheduled transmit is missed.

This can occur if the radio is put to sleep and not woken up with enough time to configure the scheduled transmit event.

Note

• Since the transmit never started, the Transmit FIFO remains intact after this event – no packet data was consumed from it.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED.

RAIL_EVENTS_TX_COMPLETION#

#define RAIL_EVENTS_TX_COMPLETION

A mask representing all events that determine the end of a transmitted packet.

After a RAIL_STATUS_NO_ERROR return value from one of the transmit functions, exactly one of the following events will occur. When one of these events occurs, a state transition takes place based on the parameter passed to RAIL_SetTxTransitions(). The RAIL_StateTransitions_t::success transition will be followed only if the RAIL_EVENT_TX_PACKET_SENT event occurs. Any of the other events will trigger the RAIL_StateTransitions_t::error transition.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENTS_TX_COMPLETION.

RAIL_EVENTS_TXACK_COMPLETION#

#define RAIL_EVENTS_TXACK_COMPLETION

A mask representing all events that determine the end of a transmitted Ack packet.

After an Ack-requesting receive, exactly one of the following events will occur. When one of these events occurs, a state transition takes place based on the RAIL_AutoAckConfig_t::rxTransitions passed to RAIL_ConfigAutoAck(). The receive transitions are used because the transmitted Ack packet is considered a part of the Ack-requesting received packet. The RAIL_StateTransitions_t::success transition will be followed only if the RAIL_EVENT_TXACK_PACKET_SENT event occurs. Any of the other events will trigger the RAIL_StateTransitions_t::error transition.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENTS_TXACK_COMPLETION.

RAIL_EVENT_CONFIG_UNSCHEDULED#

#define RAIL_EVENT_CONFIG_UNSCHEDULED

(1ULL << RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT)

Occurs when the scheduler switches away from this configuration.

This event will occur in dynamic multiprotocol scenarios each time a protocol is shutting down. When it does occur, it will be the only event passed to RAIL_Config_t::eventsCallback(). Therefore, to optimize protocol switch time, this event should be handled among the first in that callback, and then the application can return immediately.

Note

• : To minimize protocol switch time, Silicon Labs recommends this event event being turned off unless it is used.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_CONFIG_UNSCHEDULED.

RAIL_EVENT_CONFIG_SCHEDULED#

#define RAIL_EVENT_CONFIG_SCHEDULED

(1ULL << RAIL_EVENT_CONFIG_SCHEDULED_SHIFT)

Occurs when the scheduler switches to this configuration.

This event will occur in dynamic multiprotocol scenarios each time a protocol is starting up. When it does occur, it will be the only event passed to RAIL_Config_t::eventsCallback(). Therefore, in order to optimize protocol switch time, this event should be handled among the first in that callback, and then the application can return immediately.

Note

• : To minimize protocol switch time, Silicon Labs recommends this event event being turned off unless it is used.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_CONFIG_SCHEDULED.

RAIL_EVENT_SCHEDULER_STATUS#

#define RAIL_EVENT_SCHEDULER_STATUS

(1ULL << RAIL_EVENT_SCHEDULER_STATUS_SHIFT)

Occurs when the scheduler has a status to report.

The exact status can be found with RAIL_GetSchedulerStatus(). See RAIL_SchedulerStatus_t for more details. When this event does occur, it will be the only event passed to RAIL_Config_t::eventsCallback(). Therefore, to optimize protocol switch time, this event should be handled among the first in that callback, and then the application can return immediately.

Note

• RAIL_GetSchedulerStatus() is only valid to call during the time frame of the RAIL_Config_t::eventsCallback().

• : To minimize protocol switch time, Silicon Labs recommends this event event being turned off unless it is used.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_SCHEDULER_STATUS.

RAIL_EVENT_CAL_NEEDED#

#define RAIL_EVENT_CAL_NEEDED

(1ULL << RAIL_EVENT_CAL_NEEDED_SHIFT)

Occurs when the application needs to run a calibration, as determined by the RAIL library.

The application determines the opportune time to call RAIL_Calibrate().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_CAL_NEEDED.

RAIL_EVENT_RF_SENSED#

#define RAIL_EVENT_RF_SENSED

(1ULL << RAIL_EVENT_RF_SENSED_SHIFT)

Occurs when RF energy is sensed from the radio.

This event can be used as an alternative to the callback passed as RAIL_RfSense_CallbackPtr_t() or the application polling with RAIL_IsRfSensed().

Note

• This event will not occur when waking up from EM4. Prefer RAIL_IsRfSensed() when waking from EM4.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_RF_SENSED.

RAIL_EVENT_PA_PROTECTION#

#define RAIL_EVENT_PA_PROTECTION

(1ULL << RAIL_EVENT_PA_PROTECTION_SHIFT)

Occurs when PA protection circuit kicks in.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_PA_PROTECTION.

RAIL_EVENT_SIGNAL_DETECTED#

#define RAIL_EVENT_SIGNAL_DETECTED

(1ULL << RAIL_EVENT_SIGNAL_DETECTED_SHIFT)

Occurs after enabling the signal detection using RAIL_BLE_EnableSignalDetection() or RAIL_IEEE802154_EnableSignalDetection() when a signal is detected.

This is only used on platforms that support signal identifier, where RAIL_BLE_SUPPORTS_SIGNAL_IDENTIFIER or RAIL_IEEE802154_SUPPORTS_SIGNAL_IDENTIFIER is true.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_SIGNAL_DETECTED.

RAIL_EVENT_IEEE802154_MODESWITCH_START#

#define RAIL_EVENT_IEEE802154_MODESWITCH_START

(1ULL << RAIL_EVENT_IEEE802154_MODESWITCH_START_SHIFT)

Occurs when a Wi-SUN mode switch packet has been received, after switching to the new PHY.

It doesn't occur when a mode switch packet is transmitted.

IEEE 802.15.4 option RAIL_IEEE802154_G_OPTION_WISUN_MODESWITCH must be enabled for this event to occur.

Only available on platforms where RAIL_IEEE802154_SUPPORTS_G_MODESWITCH is true.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START.

RAIL_EVENT_IEEE802154_MODESWITCH_END#

#define RAIL_EVENT_IEEE802154_MODESWITCH_END

(1ULL << RAIL_EVENT_IEEE802154_MODESWITCH_END_SHIFT)

Occurs when switching back to the original base PHY in effect prior to the Wi-SUN mode switch reception.

This typically occurs if no packet is seen within some timeframe after the mode switch packet was received or if the first packet received in the new PHY is aborted, filtered, or fails CRC.

IEEE 802.15.4 option RAIL_IEEE802154_G_OPTION_WISUN_MODESWITCH must be enabled for this event to occur.

Only available on platforms where RAIL_IEEE802154_SUPPORTS_G_MODESWITCH is true.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END.

RAIL_EVENT_DETECT_RSSI_THRESHOLD#

#define RAIL_EVENT_DETECT_RSSI_THRESHOLD

(1ULL << RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT)

Occurs when the sampled RSSI is above the threshold set by RAIL_SetRssiDetectThreshold().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD.

RAIL_EVENT_THERMISTOR_DONE#

#define RAIL_EVENT_THERMISTOR_DONE

(1ULL << RAIL_EVENT_THERMISTOR_DONE_SHIFT)

Occurs when the thermistor has finished its measurement in response to RAIL_StartThermistorMeasurement().

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_THERMISTOR_DONE.

RAIL_EVENT_TX_BLOCKED_TOO_HOT#

#define RAIL_EVENT_TX_BLOCKED_TOO_HOT

(1ULL << RAIL_EVENT_TX_BLOCKED_TOO_HOT_SHIFT)

Occurs when a Tx has been blocked because of temperature exceeding the safety threshold.

DeprecatedThis RAIL 2.x event has been eliminated in RAIL 3; its value is reserved for possible future use.

RAIL_EVENT_TEMPERATURE_TOO_HOT#

#define RAIL_EVENT_TEMPERATURE_TOO_HOT

(1ULL << RAIL_EVENT_TEMPERATURE_TOO_HOT_SHIFT)

Occurs when die internal temperature exceeds the temperature threshold subtracted by the cool down parameter from RAIL_ChipTempConfig_t.

Transmits are blocked until temperature has cooled enough, indicated by RAIL_EVENT_TEMPERATURE_COOL_DOWN.

Only occurs on platforms where RAIL_SUPPORTS_THERMAL_PROTECTION is true.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TEMPERATURE_TOO_HOT.

RAIL_EVENT_TEMPERATURE_COOL_DOWN#

#define RAIL_EVENT_TEMPERATURE_COOL_DOWN

(1ULL << RAIL_EVENT_TEMPERATURE_COOL_DOWN_SHIFT)

Occurs when die internal temperature falls below the temperature threshold subtracted by the cool down parameter from RAIL_ChipTempConfig_t.

Transmits are no longer blocked by temperature limitation, indicated by RAIL_EVENT_TEMPERATURE_TOO_HOT.

Only occurs on platforms where RAIL_SUPPORTS_THERMAL_PROTECTION is true.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN.

RAIL_EVENT_USER_MBOX#

#define RAIL_EVENT_USER_MBOX

(1ULL << RAIL_EVENT_USER_MBOX_SHIFT)

Occurs when the user received a mailbox message.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENT_USER_MBOX.

RAIL_EVENTS_ALL#

#define RAIL_EVENTS_ALL

0xFFFFFFFFFFFFFFFFULL

A value representing all possible events.

DeprecatedRAIL 2.x synonym of SL_RAIL_EVENTS_ALL.

SL_RAIL_EVENTS_NONE#

#define SL_RAIL_EVENTS_NONE

0ULL

A value representing no events.

SL_RAIL_EVENT_RSSI_AVERAGE_DONE#

#define SL_RAIL_EVENT_RSSI_AVERAGE_DONE

(1ULL << SL_RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT)

Occurs when the hardware-averaged RSSI is done in response to sl_rail_start_average_rssi() to indicate that the hardware has completed averaging.

Call sl_rail_get_average_rssi() to get the result.

SL_RAIL_EVENT_RX_ACK_TIMEOUT#

#define SL_RAIL_EVENT_RX_ACK_TIMEOUT

(1ULL << SL_RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT)

Occurs when the Ack timeout expires while waiting to receive the sync word of an expected Ack.

If the timeout occurs within packet reception, this event won't be signaled until after packet completion has determined the packet wasn't the expected Ack. See sl_rail_rx_packet_details_t::is_ack for the definition of an expected Ack.

This event only occurs after calling sl_rail_config_auto_ack() and after transmitting a packet with SL_RAIL_TX_OPTION_WAIT_FOR_ACK set.

SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL#

#define SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL

(1ULL << SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)

Keeps occurring as long as the number of bytes in the receive FIFO exceeds the configured threshold value.

Call sl_rail_get_rx_fifo_bytes_available() to get the number of bytes available. When using this event, the threshold should be set via sl_rail_set_rx_fifo_threshold().

How to avoid sticking in the event handler (even in idle state):

1. Disable the event (via the config events API or the SL_RAIL_FIFO_THRESHOLD_DISABLED parameter)

2. Increase FIFO threshold

3. Read the FIFO (that's not an option in sl_rail_data_method_t::SL_RAIL_DATA_METHOD_PACKET_MODE) in the event handler

SL_RAIL_EVENT_RX_PACKET_RECEIVED#

#define SL_RAIL_EVENT_RX_PACKET_RECEIVED

(1ULL << SL_RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT)

Occurs whenever a packet is received with SL_RAIL_RX_PACKET_READY_SUCCESS or SL_RAIL_RX_PACKET_READY_CRC_ERROR.

Call sl_rail_get_rx_packet_info() to get basic information about the packet along with a handle to this packet for subsequent use with sl_rail_peek_rx_packet(), sl_rail_get_rx_packet_details(), sl_rail_hold_rx_packet(), and sl_rail_release_rx_packet() as needed.

SL_RAIL_EVENT_RX_PREAMBLE_LOST#

#define SL_RAIL_EVENT_RX_PREAMBLE_LOST

(1ULL << SL_RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT)

Occurs when the radio has lost a preamble.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a SL_RAIL_EVENT_RX_PREAMBLE_DETECT event has already occurred.

Note

• See warning for SL_RAIL_EVENT_RX_PREAMBLE_DETECT.

SL_RAIL_EVENT_RX_PREAMBLE_DETECT#

#define SL_RAIL_EVENT_RX_PREAMBLE_DETECT

(1ULL << SL_RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT)

Occurs when the radio has detected a preamble.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a SL_RAIL_EVENT_RX_TIMING_DETECT event has already occurred.

Warnings

• This event, along with SL_RAIL_EVENT_RX_PREAMBLE_LOST, may not work on some demodulators. Some demodulators usurped the signals on which these events are based for another purpose. These demodulators in particular are available on the EFR32xG23, EFR32xG25, and the EFR32xG28 platforms. Enabling these events on these platforms may cause the events to fire infinitely and possibly freeze the application.

SL_RAIL_EVENT_RX_SYNC_0_DETECT#

#define SL_RAIL_EVENT_RX_SYNC_0_DETECT

(1ULL << SL_RAIL_EVENT_RX_SYNC_0_DETECT_SHIFT)

Occurs when the primary sync word is detected.

After this event occurs, one of the events in the SL_RAIL_EVENTS_RX_COMPLETION mask will occur.

SL_RAIL_EVENT_RX_SYNC_1_DETECT#

#define SL_RAIL_EVENT_RX_SYNC_1_DETECT

(1ULL << SL_RAIL_EVENT_RX_SYNC_1_DETECT_SHIFT)

Occurs when the alternate sync word is detected.

After this event occurs, one of the events in the SL_RAIL_EVENTS_RX_COMPLETION mask will occur.

SL_RAIL_EVENT_RX_FRAME_ERROR#

#define SL_RAIL_EVENT_RX_FRAME_ERROR

(1ULL << SL_RAIL_EVENT_RX_FRAME_ERROR_SHIFT)

Occurs when a receive is aborted with SL_RAIL_RX_PACKET_ABORT_CRC_ERROR which only happens after any filtering has passed.

For EFR32 parts, this event includes CRC errors, block decoding errors, and illegal frame length – when detected after filtering. (When such errors are detected during filtering, they're signaled as SL_RAIL_EVENT_RX_PACKET_ABORTED instead.)

If SL_RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event will not occur for CRC errors, but could still occur for the other errors.

SL_RAIL_EVENT_RX_FIFO_FULL#

#define SL_RAIL_EVENT_RX_FIFO_FULL

(1ULL << SL_RAIL_EVENT_RX_FIFO_FULL_SHIFT)

When using sl_rail_rx_data_source_t::SL_RAIL_RX_DATA_SOURCE_PACKET_DATA this event occurs coincident to a receive packet completion event in which the receive FIFO or the supplemental receive Packet Queue (see Data Management) are full and further packet reception is jeopardized.

It signals that an overflow is imminent (and may already have occurred) telling the application it should release the oldest packet(s) as soon as possible. This event may may be posted multiple times with subsequent receive completion events if the FIFO(s) remain full, and should also occur coincident with SL_RAIL_EVENT_RX_FIFO_OVERFLOW.

When not using sl_rail_rx_data_source_t::SL_RAIL_RX_DATA_SOURCE_PACKET_DATA this event is not tied to packet completion and will occur coincident with SL_RAIL_EVENT_RX_FIFO_OVERFLOW when the receive FIFO has filled and overflowed. The application should consume receive FIFO data via sl_rail_read_rx_fifo() as soon as possible to minimize lost raw data.

SL_RAIL_EVENT_RX_FIFO_OVERFLOW#

#define SL_RAIL_EVENT_RX_FIFO_OVERFLOW

(1ULL << SL_RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT)

When using sl_rail_rx_data_source_t::SL_RAIL_RX_DATA_SOURCE_PACKET_DATA this event occurs when a receive is aborted with SL_RAIL_RX_PACKET_ABORT_OVERFLOW due to overflowing the receive FIFO or the supplemental receive Packet Queue (see Data Management).

The radio suspends receiving packets until this event is posted and the receive FIFO(s) have been fully processed (drained and released or reset). It is not guaranteed that a SL_RAIL_EVENT_RX_FIFO_FULL will precede this event, but both events should be coincident.

When not using sl_rail_rx_data_source_t::SL_RAIL_RX_DATA_SOURCE_PACKET_DATA this event is not tied to packet completion and will occur coincident with SL_RAIL_EVENT_RX_FIFO_FULL when the receive FIFO has filled and overflowed. The application should consume receive FIFO data via sl_rail_read_rx_fifo() as soon as possible to minimize lost raw data.

SL_RAIL_EVENT_RX_ADDRESS_FILTERED#

#define SL_RAIL_EVENT_RX_ADDRESS_FILTERED

(1ULL << SL_RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT)

Occurs when a receive is aborted with SL_RAIL_RX_PACKET_ABORT_FILTERED because its address does not match the filtering settings.

This event can only occur after calling sl_rail_enable_address_filter().

SL_RAIL_EVENT_RX_TIMEOUT#

#define SL_RAIL_EVENT_RX_TIMEOUT

(1ULL << SL_RAIL_EVENT_RX_TIMEOUT_SHIFT)

Occurs when an RX event times out.

This event can only occur if the sl_rail_state_timing_t::rxsearch_timeout passed to sl_rail_set_state_timing() is not zero.

SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED#

#define SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED

(1ULL << SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED_SHIFT)

Occurs when a scheduled RX begins turning on the receiver.

This event has the same numerical value as SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED because one cannot schedule both RX and TX simultaneously.

SL_RAIL_EVENT_RX_BLOCKED#

#define SL_RAIL_EVENT_RX_BLOCKED

(1ULL << SL_RAIL_EVENT_RX_BLOCKED_SHIFT)

Occurs when the receiver has been blocked due to radio arbitration.

This event will only occur if the receiver is blocked during packet search and no data has been placed into the FIFO. After this event the previous receive operation has been cancelled and must be restarted.

SL_RAIL_EVENT_RX_SCHEDULED_RX_END#

#define SL_RAIL_EVENT_RX_SCHEDULED_RX_END

(1ULL << SL_RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT)

Occurs when the scheduled RX window ends.

This event only occurs in response to a scheduled receive timeout after calling sl_rail_start_scheduled_rx(). It will occur unless receive is explicitly terminated by a call to sl_rail_idle() or a scheduler preemption. If sl_rail_scheduled_rx_config_t::rx_transition_end_schedule was passed as true, any of the SL_RAIL_EVENTS_RX_COMPLETION events occurring will also trigger this event, since the scheduled receive ends with the transition at the end of the packet.

Note

• This event differs from RAIL 2.x behavior: In RAIL 2.x when RAIL_ScheduleRxConfig_t::rxTransitionEndSchedule was passed as true, this event would be suppressed when any of the RAIL_EVENTS_RX_COMPLETION events occurred and are enabled. In RAIL 3 the SL_RAIL_EVENT_RX_SCHEDULED_RX_END is never suppressed.

SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED#

#define SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED

(1ULL << SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT)

Occurs when start of a scheduled receive is missed.

This can occur if the radio is put to sleep and not woken up with enough time to configure the scheduled receive event.

SL_RAIL_EVENT_RX_PACKET_ABORTED#

#define SL_RAIL_EVENT_RX_PACKET_ABORTED

(1ULL << SL_RAIL_EVENT_RX_PACKET_ABORTED_SHIFT)

Occurs when a receive is aborted during filtering with SL_RAIL_RX_PACKET_ABORT_FORMAT or after filtering with SL_RAIL_RX_PACKET_ABORT_ABORTED for reasons other than address filtering mismatch (which triggers SL_RAIL_EVENT_RX_ADDRESS_FILTERED instead).

For EFR32 parts, this event includes CRC errors, block decoding errors, illegal frame length, and other RAIL built-in protocol-specific packet content errors – when detected during filtering. (When such errors are detected after filtering, they're signaled as SL_RAIL_EVENT_RX_FRAME_ERROR instead.) It also includes application or multiprotocol scheduler aborting a receive after filtering has passed.

SL_RAIL_EVENT_RX_FILTER_PASSED#

#define SL_RAIL_EVENT_RX_FILTER_PASSED

(1ULL << SL_RAIL_EVENT_RX_FILTER_PASSED_SHIFT)

Occurs when the packet has passed any configured address and frame filtering options.

This event will only occur between the start of the packet, indicated by SL_RAIL_EVENT_RX_SYNC_0_DETECT or SL_RAIL_EVENT_RX_SYNC_1_DETECT and one of the events in the SL_RAIL_EVENTS_RX_COMPLETION mask. It will always occur before or concurrently with SL_RAIL_EVENT_RX_PACKET_RECEIVED. If IEEE 802.15.4 frame and address filtering are enabled, this event will occur immediately after destination address filtering.

SL_RAIL_EVENT_RX_TIMING_LOST#

#define SL_RAIL_EVENT_RX_TIMING_LOST

(1ULL << SL_RAIL_EVENT_RX_TIMING_LOST_SHIFT)

Occurs when the modem timing is lost.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a SL_RAIL_EVENT_RX_TIMING_DETECT event has already occurred.

Note

• See warning for SL_RAIL_EVENT_RX_TIMING_DETECT.

SL_RAIL_EVENT_RX_TIMING_DETECT#

#define SL_RAIL_EVENT_RX_TIMING_DETECT

(1ULL << SL_RAIL_EVENT_RX_TIMING_DETECT_SHIFT)

Occurs when the modem timing is detected.

This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes.

Warnings

• This event, along with SL_RAIL_EVENT_RX_TIMING_LOST, may not work on some demodulators. Some demodulators usurped the signals on which these events are based for another purpose. These demodulators in particular are available on the EFR32xG23, EFR32xG25, and the EFR32xG28 platforms. Enabling these events on these platforms may cause the events to fire infinitely and possibly freeze the application.

SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE#

#define SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE

(1ULL << SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT)

Occurs when RX Channel Hopping is enabled and channel hopping finishes receiving on the last channel in its sequence.

The intent behind this event is to allow the user to keep the radio on for as short a time as possible. That is, once the channel sequence is complete, the application will receive this event and can trigger a sleep/idle until it is necessary to cycle through the channels again. If this event is left on indefinitely and not handled it will likely be a fairly noisy event, as it continues to fire each time the hopping algorithm cycles through the channel sequence.

SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END#

#define SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END

(1ULL << SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT)

Occurs during RX duty cycle mode when the radio finishes its time in receive mode.

The application can then trigger a sleep/idle until it needs to listen again.

SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND#

#define SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND

(1ULL << SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT)

Indicate a Data Request is received when using IEEE 802.15.4 functionality.

It occurs when the command byte of an incoming Ack-requesting MAC Control frame is for a data request. This callback is called before the packet is fully received to allow the node to have more time to decide whether to indicate a frame is pending in the outgoing Ack. This event only occurs if the RAIL IEEE 802.15.4 functionality is enabled, but will never occur if promiscuous mode is enabled via sl_rail_ieee802154_set_promiscuous_mode().

Call sl_rail_ieee802154_get_address() to get the source address of the packet.

SL_RAIL_EVENT_ZWAVE_BEAM#

#define SL_RAIL_EVENT_ZWAVE_BEAM

(1ULL << SL_RAIL_EVENT_ZWAVE_BEAM_SHIFT)

Indicate a Z-Wave Beam Request relevant to the node was received.

This event only occurs if the RAIL Z-Wave functionality is enabled and its SL_RAIL_ZWAVE_OPTION_DETECT_BEAM_FRAMES is enabled. This event is used in lieu of SL_RAIL_EVENT_RX_PACKET_RECEIVED, which is reserved for Z-Wave packets other than Beams.

Call sl_rail_zwave_get_rx_beam_details() to get the Node Id to which the Beam was targeted, which would be either the broadcast id 0xFF or the node's own single-cast id, as well as other beam packet details.

Note

• All Z-Wave Beam requests are generally discarded, triggering SL_RAIL_EVENT_RX_PACKET_ABORTED.

SL_RAIL_EVENT_MFM_TX_BUFFER_DONE#

#define SL_RAIL_EVENT_MFM_TX_BUFFER_DONE

(1ULL << SL_RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT)

Indicate a MFM buffer has completely transmitted.

This event only occurs if the RAIL MFM functionality is enabled and a MFM buffer has completely transmitted.

Following this event, the application can update the MFM buffer that has transmitted to be used for the next transmission.

SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND#

#define SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND

(1ULL << SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT)

Indicate a request for populating Z-Wave LR Ack packet.

This event only occurs if the RAIL Z-Wave functionality is enabled.

Following this event, the application must call sl_rail_zwave_set_lr_ack_data() to populate noise floor, TX power and receive RSSI fields of the Z-Wave Long Range Ack packet.

SL_RAIL_EVENTS_RX_COMPLETION#

#define SL_RAIL_EVENTS_RX_COMPLETION

The mask representing all events that determine the end of a received packet.

After a SL_RAIL_EVENT_RX_SYNC_0_DETECT or a SL_RAIL_EVENT_RX_SYNC_1_DETECT, exactly one of the following events will occur. When one of these events occurs, a state transition will take place based on the parameter passed to sl_rail_set_rx_transitions(). The sl_rail_state_transitions_t::success transition will be followed only if the SL_RAIL_EVENT_RX_PACKET_RECEIVED event occurs. Any of the other events will trigger the sl_rail_state_transitions_t::error transition.

SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY#

#define SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY

(1ULL << SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT)

Occurs when the number of bytes in the transmit FIFO falls below the configured threshold value.

This event does not occur on initialization or after resetting the transmit FIFO with sl_rail_reset_fifo().

Call sl_rail_get_tx_fifo_space_available() to get the number of bytes available in the transmit FIFO at the time of the callback dispatch. When using this event, the threshold should be set via sl_rail_set_tx_fifo_threshold().

SL_RAIL_EVENT_TX_PACKET_SENT#

#define SL_RAIL_EVENT_TX_PACKET_SENT

(1ULL << SL_RAIL_EVENT_TX_PACKET_SENT_SHIFT)

Occurs after a packet has been transmitted.

Call sl_rail_get_tx_packet_details() to get information about the packet that was transmitted. Note

• sl_rail_get_tx_packet_details() is only valid to call during the time frame of the sl_rail_config_t::events_callback().

SL_RAIL_EVENT_TXACK_PACKET_SENT#

#define SL_RAIL_EVENT_TXACK_PACKET_SENT

(1ULL << SL_RAIL_EVENT_TXACK_PACKET_SENT_SHIFT)

Occurs after an Ack packet has been transmitted.

Call sl_rail_get_tx_packet_details() to get information about the packet that was transmitted. This event can only occur after calling sl_rail_config_auto_ack().

Note

• sl_rail_get_tx_packet_details() is only valid to call during the time frame of the sl_rail_config_t::events_callback().

SL_RAIL_EVENT_TX_ABORTED#

#define SL_RAIL_EVENT_TX_ABORTED

(1ULL << SL_RAIL_EVENT_TX_ABORTED_SHIFT)

Occurs when a transmit is aborted by the user.

This can happen due to calling sl_rail_idle() or due to a scheduler preemption.

Note

• The Transmit FIFO is left in an indeterminate state and should be reset prior to reuse for sending a new packet. Contrast this with SL_RAIL_EVENT_TX_BLOCKED.

SL_RAIL_EVENT_TXACK_ABORTED#

#define SL_RAIL_EVENT_TXACK_ABORTED

(1ULL << SL_RAIL_EVENT_TXACK_ABORTED_SHIFT)

Occurs when an Ack transmit is aborted by the user.

This event can only occur after calling sl_rail_config_auto_ack(), which can happen due to calling sl_rail_idle() or due to a scheduler preemption.

SL_RAIL_EVENT_TX_BLOCKED#

#define SL_RAIL_EVENT_TX_BLOCKED

(1ULL << SL_RAIL_EVENT_TX_BLOCKED_SHIFT)

Occurs when a transmit is blocked from occurring because sl_rail_enable_tx_hold_off() was called.

Note

• Since the transmit never started, the Transmit FIFO remains intact after this event – no packet data was consumed from it. Contrast this with SL_RAIL_EVENT_TX_ABORTED.

SL_RAIL_EVENT_TXACK_BLOCKED#

#define SL_RAIL_EVENT_TXACK_BLOCKED

(1ULL << SL_RAIL_EVENT_TXACK_BLOCKED_SHIFT)

Occurs when an Ack transmit is blocked from occurring because sl_rail_enable_tx_hold_off() was called.

This event can only occur after calling sl_rail_config_auto_ack().

SL_RAIL_EVENT_TX_UNDERFLOW#

#define SL_RAIL_EVENT_TX_UNDERFLOW

(1ULL << SL_RAIL_EVENT_TX_UNDERFLOW_SHIFT)

Occurs when the transmit buffer underflows.

This can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to sl_rail_write_tx_fifo() calls not keeping up with the transmit rate if the entire packet isn't loaded at once.

Note

• The Transmit FIFO is left in an indeterminate state and should be reset prior to reuse for sending a new packet. Contrast this with SL_RAIL_EVENT_TX_BLOCKED.

SL_RAIL_EVENT_TXACK_UNDERFLOW#

#define SL_RAIL_EVENT_TXACK_UNDERFLOW

(1ULL << SL_RAIL_EVENT_TXACK_UNDERFLOW_SHIFT)

Occurs when the Ack transmit buffer underflows.

This can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to sl_rail_write_auto_ack_fifo() not being called at all before an Ack transmit.

This event can only occur after calling sl_rail_config_auto_ack().

SL_RAIL_EVENT_TX_CHANNEL_CLEAR#

#define SL_RAIL_EVENT_TX_CHANNEL_CLEAR

(1ULL << SL_RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT)

Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) succeeds.

This event can only happen after calling sl_rail_start_cca_csma_tx() or sl_rail_start_cca_lbt_tx() or their scheduled equivalent.

SL_RAIL_EVENT_TX_CHANNEL_BUSY#

#define SL_RAIL_EVENT_TX_CHANNEL_BUSY

(1ULL << SL_RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT)

Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) fails.

This event can only happen after calling sl_rail_start_cca_csma_tx() or sl_rail_start_cca_lbt_tx() or their scheduled equivalent.

Note

• Since the transmit never started, the Transmit FIFO remains intact after this event – no packet data was consumed from it.

SL_RAIL_EVENT_TX_CCA_RETRY#

#define SL_RAIL_EVENT_TX_CCA_RETRY

(1ULL << SL_RAIL_EVENT_TX_CCA_RETRY_SHIFT)

Occurs during CSMA or LBT when an individual Clear Channel Assessment (CCA) check fails, but there are more tries needed before the overall operation completes.

This event can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling sl_rail_start_cca_csma_tx() or sl_rail_start_cca_lbt_tx() or their scheduled equivalent.

SL_RAIL_EVENT_TX_START_CCA#

#define SL_RAIL_EVENT_TX_START_CCA

(1ULL << SL_RAIL_EVENT_TX_START_CCA_SHIFT)

Occurs when the receiver is enabled to perform a Clear Channel Assessment (CCA) check.

This event generally precedes the actual CCA check activation by roughly the sl_rail_state_timing_t::idle_to_rx time (subject to SL_RAIL_MINIMUM_TRANSITION_US). It can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling sl_rail_start_cca_csma_tx() or sl_rail_start_cca_lbt_tx() or their scheduled equivalent.

SL_RAIL_EVENT_TX_CCA_ACTIVATED#

#define SL_RAIL_EVENT_TX_CCA_ACTIVATED

(1ULL << SL_RAIL_EVENT_TX_CCA_ACTIVATED_SHIFT)

Occurs when the a Clear Channel Assessment (CCA) check is activated.

This event generally follows SL_RAIL_EVENT_TX_START_CCA by roughly the sl_rail_state_timing_t::idle_to_rx time (subject to SL_RAIL_MINIMUM_TRANSITION_US). It can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling sl_rail_start_cca_csma_tx() or sl_rail_start_cca_lbt_tx() or their scheduled equivalent.

Note

• This event requires that SL_RAIL_EVENT_TX_START_CCA also be enabled. It may not occur if the current CCA's backoff is 0.

SL_RAIL_EVENT_TX_STARTED#

#define SL_RAIL_EVENT_TX_STARTED

(1ULL << SL_RAIL_EVENT_TX_STARTED_SHIFT)

Occurs when the radio starts transmitting a normal packet on the air.

A start-of-transmit time stamp is captured for this event. It can be retrieved by calling sl_rail_get_tx_time_preamble_start() passing SL_RAIL_TX_STARTED_BYTES for its total_packet_bytes parameter.

Note

• This event does not apply to Ack transmits. Currently there is no equivalent event or time stamp captured for the start of an Ack transmit.

SL_RAIL_TX_STARTED_BYTES#

#define SL_RAIL_TX_STARTED_BYTES

0U

A value to pass as sl_rail_get_tx_time_preamble_start() total_packet_bytes parameter to retrieve the SL_RAIL_EVENT_TX_STARTED time stamp.

SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED#

#define SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED

(1ULL << SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED_SHIFT)

Occurs when a scheduled TX begins turning on the transmitter.

This event has the same numerical value as SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED because one cannot schedule both RX and TX simultaneously.

SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED#

#define SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED

(1ULL << SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT)

Occurs when the start of a scheduled transmit is missed.

This can occur if the radio is put to sleep and not woken up with enough time to configure the scheduled transmit event.

Note

• Since the transmit never started, the Transmit FIFO remains intact after this event – no packet data was consumed from it.

SL_RAIL_EVENTS_TX_COMPLETION#

#define SL_RAIL_EVENTS_TX_COMPLETION

A mask representing all events that determine the end of a transmitted packet.

After a SL_RAIL_STATUS_NO_ERROR return value from one of the transmit functions, exactly one of the following events will occur. When one of these events occurs, a state transition takes place based on the parameter passed to sl_rail_set_tx_transitions(). The sl_rail_state_transitions_t::success transition will be followed only if the SL_RAIL_EVENT_TX_PACKET_SENT event occurs. Any of the other events will trigger the sl_rail_state_transitions_t::error transition.

SL_RAIL_EVENTS_TXACK_COMPLETION#

#define SL_RAIL_EVENTS_TXACK_COMPLETION

A mask representing all events that determine the end of a transmitted Ack packet.

After an Ack-requesting receive, exactly one of the following events will occur. When one of these events occurs, a state transition takes place based on the sl_rail_auto_ack_config_t::rx_transitions passed to sl_rail_config_auto_ack(). The receive transitions are used because the transmitted Ack packet is considered a part of the Ack-requesting received packet. The sl_rail_state_transitions_t::success transition will be followed only if the SL_RAIL_EVENT_TXACK_PACKET_SENT event occurs. Any of the other events will trigger the sl_rail_state_transitions_t::error transition.

SL_RAIL_EVENT_CONFIG_UNSCHEDULED#

#define SL_RAIL_EVENT_CONFIG_UNSCHEDULED

(1ULL << SL_RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT)

Occurs when the scheduler switches away from this configuration.

This event will occur in dynamic multiprotocol scenarios each time a protocol is shutting down. When it does occur, it will be the only event passed to sl_rail_config_t::events_callback(). Therefore, to optimize protocol switch time, this event should be handled among the first in that callback, and then the application can return immediately.

Note

• : To minimize protocol switch time, Silicon Labs recommends this event event being turned off unless it is used.

SL_RAIL_EVENT_CONFIG_SCHEDULED#

#define SL_RAIL_EVENT_CONFIG_SCHEDULED

(1ULL << SL_RAIL_EVENT_CONFIG_SCHEDULED_SHIFT)

Occurs when the scheduler switches to this configuration.

This event will occur in dynamic multiprotocol scenarios each time a protocol is starting up. When it does occur, it will be the only event passed to sl_rail_config_t::events_callback(). Therefore, in order to optimize protocol switch time, this event should be handled among the first in that callback, and then the application can return immediately.

Note

• : To minimize protocol switch time, Silicon Labs recommends this event event being turned off unless it is used.

SL_RAIL_EVENT_SCHEDULER_STATUS#

#define SL_RAIL_EVENT_SCHEDULER_STATUS

(1ULL << SL_RAIL_EVENT_SCHEDULER_STATUS_SHIFT)

Occurs when the scheduler has a status to report.

The exact status can be found with sl_rail_get_scheduler_status(). See sl_rail_scheduler_status_t for more details. When this event does occur, it will be the only event passed to sl_rail_config_t::events_callback(). Therefore, to optimize protocol switch time, this event should be handled among the first in that callback, and then the application can return immediately.

Note

• sl_rail_get_scheduler_status() is only valid to call during the time frame of the sl_rail_config_t::events_callback().

• : To minimize protocol switch time, Silicon Labs recommends this event event being turned off unless it is used.

SL_RAIL_EVENT_CAL_NEEDED#

#define SL_RAIL_EVENT_CAL_NEEDED

(1ULL << SL_RAIL_EVENT_CAL_NEEDED_SHIFT)

Occurs when the application needs to run a calibration, as determined by the RAIL library.

The application determines the opportune time to call sl_rail_calibrate().

SL_RAIL_EVENT_RF_SENSED#

#define SL_RAIL_EVENT_RF_SENSED

(1ULL << SL_RAIL_EVENT_RF_SENSED_SHIFT)

Occurs when RF energy is sensed from the radio.

This event can be used as an alternative to the callback passed as sl_rail_rf_sense_callback_t() or the application polling with sl_rail_is_rf_sensed().

Note

• This event will not occur when waking up from EM4. Prefer sl_rail_is_rf_sensed() when waking from EM4.

SL_RAIL_EVENT_PA_PROTECTION#

#define SL_RAIL_EVENT_PA_PROTECTION

(1ULL << SL_RAIL_EVENT_PA_PROTECTION_SHIFT)

Occurs when PA protection circuit kicks in.

SL_RAIL_EVENT_SIGNAL_DETECTED#

#define SL_RAIL_EVENT_SIGNAL_DETECTED

(1ULL << SL_RAIL_EVENT_SIGNAL_DETECTED_SHIFT)

Occurs after enabling the signal detection using sl_rail_ble_enable_signal_detection() or sl_rail_ieee802154_enable_signal_detection() when a signal is detected.

This is only used on platforms that support signal identifier, where SL_RAIL_BLE_SUPPORTS_SIGNAL_IDENTIFIER or SL_RAIL_IEEE802154_SUPPORTS_SIGNAL_IDENTIFIER is true.

SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START#

#define SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START

(1ULL << SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START_SHIFT)

Occurs when a Wi-SUN mode switch packet has been received, after switching to the new PHY.

It doesn't occur when a mode switch packet is transmitted.

IEEE 802.15.4 option SL_RAIL_IEEE802154_G_OPTION_WI_SUN_MODE_SWITCH must be enabled for this event to occur.

Only available on platforms where SL_RAIL_IEEE802154_SUPPORTS_G_MODE_SWITCH is true.

SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END#

#define SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END

(1ULL << SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END_SHIFT)

Occurs when switching back to the original base PHY in effect prior to the Wi-SUN mode switch reception.

This typically occurs if no packet is seen within some timeframe after the mode switch packet was received or if the first packet received in the new PHY is aborted, filtered, or fails CRC.

IEEE 802.15.4 option SL_RAIL_IEEE802154_G_OPTION_WI_SUN_MODE_SWITCH must be enabled for this event to occur.

Only available on platforms where SL_RAIL_IEEE802154_SUPPORTS_G_MODE_SWITCH is true.

SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD#

#define SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD

(1ULL << SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT)

Occurs when the sampled RSSI is above the threshold set by sl_rail_set_rssi_detect_threshold().

SL_RAIL_EVENT_THERMISTOR_DONE#

#define SL_RAIL_EVENT_THERMISTOR_DONE

(1ULL << SL_RAIL_EVENT_THERMISTOR_DONE_SHIFT)

Occurs when the thermistor has finished its measurement in response to sl_rail_start_thermistor_measurement().

SL_RAIL_EVENT_RESERVED_49#

#define SL_RAIL_EVENT_RESERVED_49

(1ULL << SL_RAIL_EVENT_RESERVED_49_SHIFT)

Reserved for possible future use.

SL_RAIL_EVENT_TEMPERATURE_TOO_HOT#

#define SL_RAIL_EVENT_TEMPERATURE_TOO_HOT

(1ULL << SL_RAIL_EVENT_TEMPERATURE_TOO_HOT_SHIFT)

Occurs when die internal temperature exceeds the temperature threshold subtracted by the cool down parameter from sl_rail_chip_temp_config_t.

Transmits are blocked until temperature has cooled enough, indicated by SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN.

Only occurs on platforms where SL_RAIL_SUPPORTS_THERMAL_PROTECTION is true.

SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN#

#define SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN

(1ULL << SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN_SHIFT)

Occurs when die internal temperature falls below the temperature threshold subtracted by the cool down parameter from sl_rail_chip_temp_config_t.

Transmits are no longer blocked by temperature limitation, indicated by SL_RAIL_EVENT_TEMPERATURE_TOO_HOT.

Only occurs on platforms where SL_RAIL_SUPPORTS_THERMAL_PROTECTION is true.

SL_RAIL_EVENT_USER_MBOX#

#define SL_RAIL_EVENT_USER_MBOX

(1ULL << SL_RAIL_EVENT_USER_MBOX_SHIFT)

Occurs when the user received a mailbox message.

SL_RAIL_EVENTS_ALL#

#define SL_RAIL_EVENTS_ALL

0xFFFFFFFFFFFFFFFFULL

A value representing all possible events.