Events

APIs related to events.

Macros

#define RAIL_EVENTS_NONE   0ULL
 A value representing no events.
 
#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.
 
#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.
 
#define RAIL_EVENT_RX_FIFO_ALMOST_FULL   (1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)
 Occurs when the number of bytes in the receive FIFO exceeds the configured threshold value.
 
#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.
 
#define RAIL_EVENT_RX_PREAMBLE_LOST   (1ULL << RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT)
 Occurs when the radio has lost a preamble.
 
#define RAIL_EVENT_RX_PREAMBLE_DETECT   (1ULL << RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT)
 Occurs when the radio has detected a preamble.
 
#define RAIL_EVENT_RX_SYNC1_DETECT   (1ULL << RAIL_EVENT_RX_SYNC1_DETECT_SHIFT)
 Occurs when the first sync word is detected.
 
#define RAIL_EVENT_RX_SYNC2_DETECT   (1ULL << RAIL_EVENT_RX_SYNC2_DETECT_SHIFT)
 Occurs when the second sync word is detected.
 
#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.
 
#define RAIL_EVENT_RX_FIFO_FULL   (1ULL << RAIL_EVENT_RX_FIFO_FULL_SHIFT)
 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.
 
#define RAIL_EVENT_RX_FIFO_OVERFLOW   (1ULL << RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT)
 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).
 
#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.
 
#define RAIL_EVENT_RX_TIMEOUT   (1ULL << RAIL_EVENT_RX_TIMEOUT_SHIFT)
 Occurs when an RX event times out.
 
#define RAIL_EVENT_RX_SCHEDULED_RX_END   (1ULL << RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT)
 Occurs when the scheduled RX window ends.
 
#define RAIL_EVENT_RX_SCHEDULED_RX_MISSED   (1ULL << RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT)
 Occurs when start of a scheduled receive is missed.
 
#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).
 
#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.
 
#define RAIL_EVENT_RX_TIMING_LOST   (1ULL << RAIL_EVENT_RX_TIMING_LOST_SHIFT)
 Occurs when the modem timing is lost.
 
#define RAIL_EVENT_RX_TIMING_DETECT   (1ULL << RAIL_EVENT_RX_TIMING_DETECT_SHIFT)
 Occurs when the modem timing is detected.
 
#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.
 
#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.
 
#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.
 
#define RAIL_EVENT_ZWAVE_BEAM   (1ULL << RAIL_EVENT_ZWAVE_BEAM_SHIFT)
 Indicate a Z-Wave Beam Request relevant to the node was received.
 
#define RAIL_EVENTS_RX_COMPLETION
 The mask representing all events that determine the end of a received packet.
 
#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.
 
#define RAIL_EVENT_TX_PACKET_SENT   (1ULL << RAIL_EVENT_TX_PACKET_SENT_SHIFT)
 Occurs after a packet has been transmitted.
 
#define RAIL_EVENT_TXACK_PACKET_SENT   (1ULL << RAIL_EVENT_TXACK_PACKET_SENT_SHIFT)
 Occurs after an ACK packet has been transmitted.
 
#define RAIL_EVENT_TX_ABORTED   (1ULL << RAIL_EVENT_TX_ABORTED_SHIFT)
 Occurs when a transmit is aborted by the user.
 
#define RAIL_EVENT_TXACK_ABORTED   (1ULL << RAIL_EVENT_TXACK_ABORTED_SHIFT)
 Occurs when an ACK transmit is aborted by the user.
 
#define RAIL_EVENT_TX_BLOCKED   (1ULL << RAIL_EVENT_TX_BLOCKED_SHIFT)
 Occurs when a transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called.
 
#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.
 
#define RAIL_EVENT_TX_UNDERFLOW   (1ULL << RAIL_EVENT_TX_UNDERFLOW_SHIFT)
 Occurs when the transmit buffer underflows.
 
#define RAIL_EVENT_TXACK_UNDERFLOW   (1ULL << RAIL_EVENT_TXACK_UNDERFLOW_SHIFT)
 Occurs when the ACK transmit buffer underflows.
 
#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.
 
#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.
 
#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.
 
#define RAIL_EVENT_TX_START_CCA   (1ULL << RAIL_EVENT_TX_START_CCA_SHIFT)
 Occurs when a Clear Channel Assessment (CCA) check begins.
 
#define RAIL_EVENT_TX_STARTED   (1ULL << RAIL_EVENT_TX_STARTED_SHIFT)
 Occurs when the radio starts transmitting a normal packet on the air.
 
#define RAIL_TX_STARTED_BYTES   0U
 A value to pass as RAIL_GetTxTimePreambleStart() totalPacketBytes parameter to retrieve the RAIL_EVENT_TX_STARTED timestamp.
 
#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.
 
#define RAIL_EVENTS_TX_COMPLETION
 A mask representing all events that determine the end of a transmitted packet.
 
#define RAIL_EVENTS_TXACK_COMPLETION
 A mask representing all events that determine the end of a transmitted ACK packet.
 
#define RAIL_EVENT_CONFIG_UNSCHEDULED   (1ULL << RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT)
 Occurs when the scheduler switches away from this configuration.
 
#define RAIL_EVENT_CONFIG_SCHEDULED   (1ULL << RAIL_EVENT_CONFIG_SCHEDULED_SHIFT)
 Occurs when the scheduler switches to this configuration.
 
#define RAIL_EVENT_SCHEDULER_STATUS   (1ULL << RAIL_EVENT_SCHEDULER_STATUS_SHIFT)
 Occurs when the scheduler has a status to report.
 
#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.
 
#define RAIL_EVENTS_ALL   0xFFFFFFFFFFFFFFFFULL
 A value representing all possible events.

Enumerations

enum  RAIL_Events_t {
  RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT = 0,
  RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT,
  RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT,
  RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT,
  RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT,
  RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT,
  RAIL_EVENT_RX_SYNC1_DETECT_SHIFT,
  RAIL_EVENT_RX_SYNC2_DETECT_SHIFT,
  RAIL_EVENT_RX_FRAME_ERROR_SHIFT,
  RAIL_EVENT_RX_FIFO_FULL_SHIFT,
  RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT,
  RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT,
  RAIL_EVENT_RX_TIMEOUT_SHIFT,
  RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT,
  RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT,
  RAIL_EVENT_RX_PACKET_ABORTED_SHIFT,
  RAIL_EVENT_RX_FILTER_PASSED_SHIFT,
  RAIL_EVENT_RX_TIMING_LOST_SHIFT,
  RAIL_EVENT_RX_TIMING_DETECT_SHIFT,
  RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT,
  RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT = RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT,
  RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT,
  RAIL_EVENT_ZWAVE_BEAM_SHIFT = RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT,
  RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT,
  RAIL_EVENT_TX_PACKET_SENT_SHIFT,
  RAIL_EVENT_TXACK_PACKET_SENT_SHIFT,
  RAIL_EVENT_TX_ABORTED_SHIFT,
  RAIL_EVENT_TXACK_ABORTED_SHIFT,
  RAIL_EVENT_TX_BLOCKED_SHIFT,
  RAIL_EVENT_TXACK_BLOCKED_SHIFT,
  RAIL_EVENT_TX_UNDERFLOW_SHIFT,
  RAIL_EVENT_TXACK_UNDERFLOW_SHIFT,
  RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT,
  RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT,
  RAIL_EVENT_TX_CCA_RETRY_SHIFT,
  RAIL_EVENT_TX_START_CCA_SHIFT,
  RAIL_EVENT_TX_STARTED_SHIFT,
  RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT,
  RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT,
  RAIL_EVENT_CONFIG_SCHEDULED_SHIFT,
  RAIL_EVENT_SCHEDULER_STATUS_SHIFT,
  RAIL_EVENT_CAL_NEEDED_SHIFT
}
 RAIL events passed to the event callback.

Functions

RAIL_Status_t RAIL_ConfigEvents (RAIL_Handle_t railHandle, RAIL_Events_t mask, RAIL_Events_t events)
 Configure radio events.

Detailed Description

APIs related to events.

Macro Definition Documentation

◆ 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().

Definition at line 1151 of file rail_types.h.

◆ 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.

Definition at line 1123 of file rail_types.h.

◆ 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, 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.

Definition at line 1109 of file rail_types.h.

◆ 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.

Definition at line 855 of file rail_types.h.

◆ 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.

Definition at line 617 of file rail_types.h.

◆ 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.

Definition at line 630 of file rail_types.h.

◆ 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().

Definition at line 734 of file rail_types.h.

◆ 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.

Definition at line 830 of file rail_types.h.

◆ 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.

Definition at line 839 of file rail_types.h.

◆ RAIL_EVENT_RX_FIFO_ALMOST_FULL

#define RAIL_EVENT_RX_FIFO_ALMOST_FULL   (1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)

Occurs when 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().

Definition at line 640 of file rail_types.h.

◆ RAIL_EVENT_RX_FIFO_FULL

#define RAIL_EVENT_RX_FIFO_FULL   (1ULL << RAIL_EVENT_RX_FIFO_FULL_SHIFT)

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.

Definition at line 714 of file rail_types.h.

◆ RAIL_EVENT_RX_FIFO_OVERFLOW

#define RAIL_EVENT_RX_FIFO_OVERFLOW   (1ULL << RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT)

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.

Definition at line 726 of file rail_types.h.

◆ 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.

Definition at line 798 of file rail_types.h.

◆ 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.

Definition at line 701 of file rail_types.h.

◆ 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.

Definition at line 784 of file rail_types.h.

◆ 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.

Definition at line 651 of file rail_types.h.

◆ 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.

Definition at line 671 of file rail_types.h.

◆ 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.

Definition at line 661 of file rail_types.h.

◆ 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.

Definition at line 760 of file rail_types.h.

◆ 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.

Definition at line 768 of file rail_types.h.

◆ 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.

Definition at line 679 of file rail_types.h.

◆ 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.

Definition at line 687 of file rail_types.h.

◆ 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.

Definition at line 743 of file rail_types.h.

◆ 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.

Definition at line 816 of file rail_types.h.

◆ 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.

Definition at line 808 of file rail_types.h.

◆ 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 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
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.

Definition at line 1141 of file rail_types.h.

◆ 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 TX 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.

Definition at line 941 of file rail_types.h.

◆ 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 TX FIFO remains intact after this event – no packet data was consumed from it. Contrast this with RAIL_EVENT_TX_ABORTED.

Definition at line 960 of file rail_types.h.

◆ 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().

Definition at line 1022 of file rail_types.h.

◆ 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().

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

Definition at line 1011 of file rail_types.h.

◆ 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().

Definition at line 999 of file rail_types.h.

◆ 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().

Definition at line 908 of file rail_types.h.

◆ 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.

Definition at line 918 of file rail_types.h.

◆ 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.

Definition at line 1059 of file rail_types.h.

◆ RAIL_EVENT_TX_START_CCA

#define RAIL_EVENT_TX_START_CCA   (1ULL << RAIL_EVENT_TX_START_CCA_SHIFT)

Occurs when a Clear Channel Assessment (CCA) check begins.

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().

Definition at line 1032 of file rail_types.h.

◆ 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 timestamp 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 timestamp captured for the start of an ACK transmit.

Definition at line 1045 of file rail_types.h.

◆ 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.

Definition at line 978 of file rail_types.h.

◆ 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.

Definition at line 950 of file rail_types.h.

◆ 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().

Definition at line 968 of file rail_types.h.

◆ 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.

Definition at line 929 of file rail_types.h.

◆ 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().

Definition at line 990 of file rail_types.h.

◆ 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 NodeId 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.

Definition at line 872 of file rail_types.h.

◆ RAIL_EVENTS_RX_COMPLETION

#define RAIL_EVENTS_RX_COMPLETION
Value:
#define RAIL_EVENT_RX_FRAME_ERROR
Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_CRC_ERROR which only happens after any fil...
Definition: rail_types.h:701
#define RAIL_EVENT_RX_SCHEDULED_RX_MISSED
Occurs when start of a scheduled receive is missed.
Definition: rail_types.h:768
#define RAIL_EVENT_RX_PACKET_RECEIVED
Occurs whenever a packet is received with RAIL_RX_PACKET_READY_SUCCESS or RAIL_RX_PACKET_READY_CRC_ER...
Definition: rail_types.h:651
#define RAIL_EVENT_RX_ADDRESS_FILTERED
Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_FILTERED because its address does not matc...
Definition: rail_types.h:734
#define RAIL_EVENT_RX_FIFO_OVERFLOW
Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_OVERFLOW due to overflowing the receive FI...
Definition: rail_types.h:726
#define RAIL_EVENT_RX_PACKET_ABORTED
Occurs when a receive is aborted during filtering with RAIL_RX_PACKET_ABORT_FORMAT or after filtering...
Definition: rail_types.h:784

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.

Definition at line 887 of file rail_types.h.

◆ RAIL_EVENTS_TX_COMPLETION

#define RAIL_EVENTS_TX_COMPLETION
Value:
#define RAIL_EVENT_TX_UNDERFLOW
Occurs when the transmit buffer underflows.
Definition: rail_types.h:978
#define RAIL_EVENT_TX_PACKET_SENT
Occurs after a packet has been transmitted.
Definition: rail_types.h:918
#define RAIL_EVENT_TX_BLOCKED
Occurs when a transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called...
Definition: rail_types.h:960
#define RAIL_EVENT_TX_CHANNEL_BUSY
Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) fails.
Definition: rail_types.h:1011
#define RAIL_EVENT_TX_ABORTED
Occurs when a transmit is aborted by the user.
Definition: rail_types.h:941
#define RAIL_EVENT_TX_SCHEDULED_TX_MISSED
Occurs when the start of a scheduled transmit is missed.
Definition: rail_types.h:1059

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.

Definition at line 1071 of file rail_types.h.

◆ RAIL_EVENTS_TXACK_COMPLETION

#define RAIL_EVENTS_TXACK_COMPLETION
Value:
#define RAIL_EVENT_TXACK_PACKET_SENT
Occurs after an ACK packet has been transmitted.
Definition: rail_types.h:929
#define RAIL_EVENT_TXACK_ABORTED
Occurs when an ACK transmit is aborted by the user.
Definition: rail_types.h:950
#define RAIL_EVENT_TXACK_UNDERFLOW
Occurs when the ACK transmit buffer underflows.
Definition: rail_types.h:990
#define RAIL_EVENT_TXACK_BLOCKED
Occurs when an ACK transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called...
Definition: rail_types.h:968

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.

Definition at line 1089 of file rail_types.h.

Enumeration Type Documentation

◆ RAIL_Events_t

RAIL events passed to the event callback.

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

Enumerator
RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT 

Shift position of RAIL_EVENT_RSSI_AVERAGE_DONE bit.

RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT 

Shift position of RAIL_EVENT_RX_ACK_TIMEOUT bit.

RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT 

Shift position of RAIL_EVENT_RX_FIFO_ALMOST_FULL bit.

RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT 

Shift position of RAIL_EVENT_RX_PACKET_RECEIVED bit.

RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT 

Shift position of RAIL_EVENT_RX_PREAMBLE_LOST bit.

RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT 

Shift position of RAIL_EVENT_RX_PREAMBLE_DETECT bit.

RAIL_EVENT_RX_SYNC1_DETECT_SHIFT 

Shift position of RAIL_EVENT_RX_SYNC1_DETECT bit.

RAIL_EVENT_RX_SYNC2_DETECT_SHIFT 

Shift position of RAIL_EVENT_RX_SYNC2_DETECT bit.

RAIL_EVENT_RX_FRAME_ERROR_SHIFT 

Shift position of RAIL_EVENT_RX_FRAME_ERROR bit.

RAIL_EVENT_RX_FIFO_FULL_SHIFT 

Shift position of RAIL_EVENT_RX_FIFO_FULL bit.

RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT 

Shift position of RAIL_EVENT_RX_FIFO_OVERFLOW bit.

RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT 

Shift position of RAIL_EVENT_RX_ADDRESS_FILTERED bit.

RAIL_EVENT_RX_TIMEOUT_SHIFT 

Shift position of RAIL_EVENT_RX_TIMEOUT bit.

RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT 

Shift position of RAIL_EVENT_RX_SCHEDULED_RX_END bit.

RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT 

Shift position of RAIL_EVENT_RX_SCHEDULED_RX_MISSED bit.

RAIL_EVENT_RX_PACKET_ABORTED_SHIFT 

Shift position of RAIL_EVENT_RX_PACKET_ABORTED bit.

RAIL_EVENT_RX_FILTER_PASSED_SHIFT 

Shift position of RAIL_EVENT_RX_FILTER_PASSED bit.

RAIL_EVENT_RX_TIMING_LOST_SHIFT 

Shift position of RAIL_EVENT_RX_TIMING_LOST bit.

RAIL_EVENT_RX_TIMING_DETECT_SHIFT 

Shift position of RAIL_EVENT_RX_TIMING_DETECT bit.

RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT 

Shift position of RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE bit.

RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT 

Shift position of RAIL_EVENT_RX_DUTY_CYCLE_RX_END bit.

RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT 

Shift position of RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND bit.

RAIL_EVENT_ZWAVE_BEAM_SHIFT 

Shift position of RAIL_EVENT_ZWAVE_BEAM bit.

RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT 

Shift position of RAIL_EVENT_TX_FIFO_ALMOST_EMPTY bit.

RAIL_EVENT_TX_PACKET_SENT_SHIFT 

Shift position of RAIL_EVENT_TX_PACKET_SENT bit.

RAIL_EVENT_TXACK_PACKET_SENT_SHIFT 

Shift position of RAIL_EVENT_TXACK_PACKET_SENT bit.

RAIL_EVENT_TX_ABORTED_SHIFT 

Shift position of RAIL_EVENT_TX_ABORTED bit.

RAIL_EVENT_TXACK_ABORTED_SHIFT 

Shift position of RAIL_EVENT_TXACK_ABORTED bit.

RAIL_EVENT_TX_BLOCKED_SHIFT 

Shift position of RAIL_EVENT_TX_BLOCKED bit.

RAIL_EVENT_TXACK_BLOCKED_SHIFT 

Shift position of RAIL_EVENT_TXACK_BLOCKED bit.

RAIL_EVENT_TX_UNDERFLOW_SHIFT 

Shift position of RAIL_EVENT_TX_UNDERFLOW bit.

RAIL_EVENT_TXACK_UNDERFLOW_SHIFT 

Shift position of RAIL_EVENT_TXACK_UNDERFLOW bit.

RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT 

Shift position of RAIL_EVENT_TX_CHANNEL_CLEAR bit.

RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT 

Shift position of RAIL_EVENT_TX_CHANNEL_BUSY bit.

RAIL_EVENT_TX_CCA_RETRY_SHIFT 

Shift position of RAIL_EVENT_TX_CCA_RETRY bit.

RAIL_EVENT_TX_START_CCA_SHIFT 

Shift position of RAIL_EVENT_TX_START_CCA bit.

RAIL_EVENT_TX_STARTED_SHIFT 

Shift position of RAIL_EVENT_TX_STARTED bit.

RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT 

Shift position of RAIL_EVENT_TX_SCHEDULED_TX_MISSED bit.

RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT 

Shift position of RAIL_EVENT_CONFIG_UNSCHEDULED bit.

RAIL_EVENT_CONFIG_SCHEDULED_SHIFT 

Shift position of RAIL_EVENT_CONFIG_SCHEDULED bit.

RAIL_EVENT_SCHEDULER_STATUS_SHIFT 

Shift position of RAIL_EVENT_SCHEDULER_STATUS bit.

RAIL_EVENT_CAL_NEEDED_SHIFT 

Shift position of RAIL_EVENT_CAL_NEEDED bit.

Definition at line 507 of file rail_types.h.

Function Documentation

◆ RAIL_ConfigEvents()

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

Configure radio events.

Parameters
[in]railHandleA RAIL instance handle.
[in]maskA bitmask of events to configure.
[in]eventsA bitmask of events to trigger RAIL_Config_t::eventsCallback For a full list of available callbacks, see RAIL_EVENT_* set of defines.
Returns
Status code indicating success of the function call.

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