RAIL_ENUM#

#define RAIL_ENUM

(name)

The RAIL library does not use enumerations because the ARM EABI leaves their size ambiguous, which causes problems if the application is built with different flags than the library.

Instead, uint8_t typedefs are used in compiled code for all enumerations. For documentation purposes, this is converted to an actual enumeration since it's much easier to read in Doxygen.

RAIL_ENUM_GENERIC#

#define RAIL_ENUM_GENERIC

(name, type)

This macro is a more generic version of the RAIL_ENUM() macro that allows the size of the type to be overridden instead of forcing the use of a uint8_t.

See RAIL_ENUM() for more information.

RAIL_DMA_INVALID#

#define RAIL_DMA_INVALID

(0xFFU)

A value to signal that RAIL should not use DMA.

RAIL_SCHEDULER_STATUS_MASK#

#define RAIL_SCHEDULER_STATUS_MASK

0x0FU

Radio Scheduler Status mask.

RAIL_SCHEDULER_STATUS_SHIFT#

#define RAIL_SCHEDULER_STATUS_SHIFT

0

Radio Scheduler Status shift.

RAIL_SCHEDULER_TASK_MASK#

#define RAIL_SCHEDULER_TASK_MASK

0xF0U

Radio Scheduler Task mask.

RAIL_SCHEDULER_TASK_SHIFT#

#define RAIL_SCHEDULER_TASK_SHIFT

4

Radio Scheduler Task shift.

RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT#

#define RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT

RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT

Shift position of RAIL_EVENT_SCHEDULED_TX_STARTED bit.

RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT#

#define RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT

RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT

Shift position of RAIL_EVENT_RX_DUTY_CYCLE_RX_END bit.

RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT#

#define RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT

RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT

Shift position of RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT bit.

RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT#

#define RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT

RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT

Shift position of RAIL_EVENT_MFM_TX_BUFFER_DONE bit.

RAIL_EVENTS_NONE#

#define RAIL_EVENTS_NONE

0ULL

A value representing no events.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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

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.

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

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

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 Transmit FIFO remains intact after this event – no packet data was consumed from it.

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

RAIL_EVENT_TX_START_CCA#

#define RAIL_EVENT_TX_START_CCA

(1ULL << RAIL_EVENT_TX_START_CCA_SHIFT)

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

This event generally precedes the actual start of a CCA check 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().

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.

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

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.

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.

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.

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.

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.

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.

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

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.

Alternatively, the application can poll using RAIL_IsRfSensed().

Note

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

RAIL_EVENT_PA_PROTECTION#

#define RAIL_EVENT_PA_PROTECTION

(1ULL << RAIL_EVENT_PA_PROTECTION_SHIFT)

Occurs when PA protection circuit kicks in.

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.

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.

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.

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

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

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.

Only occurs on platforms where RAIL_SUPPORTS_EFF is true, and only when also reporting RAIL_EVENT_TX_BLOCKED.

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.

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.

RAIL_EVENTS_ALL#

#define RAIL_EVENTS_ALL

0xFFFFFFFFFFFFFFFFULL

A value representing all possible events.

RAIL_TX_POWER_MAX#

#define RAIL_TX_POWER_MAX

((RAIL_TxPower_t)0x7FFF)

The maximum valid value for a RAIL_TxPower_t.

RAIL_TX_POWER_MIN#

#define RAIL_TX_POWER_MIN

((RAIL_TxPower_t)0x8000)

The minimum valid value for a RAIL_TxPower_t.

RAIL_TX_POWER_CURVE_DEFAULT_MAX#

#define RAIL_TX_POWER_CURVE_DEFAULT_MAX

((RAIL_TxPower_t)200)

The maximum power in deci-dBm the curve supports.

RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT#

#define RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT

((RAIL_TxPower_t)40)

The increment step in deci-dBm for calculating power level.

RAIL_TX_POWER_VOLTAGE_SCALING_FACTOR#

#define RAIL_TX_POWER_VOLTAGE_SCALING_FACTOR

1000

mV are used for all TX power voltage values.

TX power voltages take and return voltages multiplied by this factor.

RAIL_TX_POWER_DBM_SCALING_FACTOR#

#define RAIL_TX_POWER_DBM_SCALING_FACTOR

10

deci-dBm are used for all TX power dBm values.

All dBm inputs to TX power functions take dBm power times this factor.

RAIL_SETFIXEDLENGTH_INVALID#

#define RAIL_SETFIXEDLENGTH_INVALID

(0xFFFFU)

An invalid return value when calling RAIL_SetFixedLength().

An invalid return value when calling RAIL_SetFixedLength() while the radio is not in fixed-length mode.

RADIO_CONFIG_ENABLE_CONC_PHY#

#define RADIO_CONFIG_ENABLE_CONC_PHY

1

Indicates this version of RAIL supports concurrent PHY information in radio configurator output.

Needed for backwards compatibility.

RADIO_CONFIG_ENABLE_STACK_INFO#

#define RADIO_CONFIG_ENABLE_STACK_INFO

Indicates this version of RAIL supports stack info feature in radio configurator output.

Needed for backwards compatibility.

RAIL_FIFO_THRESHOLD_DISABLED#

#define RAIL_FIFO_THRESHOLD_DISABLED

0xFFFFU

A FIFO threshold value that disables the threshold.

RAIL_RF_STATE_DETAIL_INACTIVE#

#define RAIL_RF_STATE_DETAIL_INACTIVE

(0U)

Radio is inactive.

RAIL_RF_STATE_DETAIL_IDLE_STATE#

#define RAIL_RF_STATE_DETAIL_IDLE_STATE

(1U << RAIL_RF_STATE_DETAIL_IDLE_STATE_SHIFT)

Radio is in or headed to the idle state.

RAIL_RF_STATE_DETAIL_RX_STATE#

#define RAIL_RF_STATE_DETAIL_RX_STATE

(1U << RAIL_RF_STATE_DETAIL_RX_STATE_SHIFT)

Radio is in or headed to the receive state.

RAIL_RF_STATE_DETAIL_TX_STATE#

#define RAIL_RF_STATE_DETAIL_TX_STATE

(1U << RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT)

Radio is in or headed to the transmit state.

RAIL_RF_STATE_DETAIL_TRANSITION#

#define RAIL_RF_STATE_DETAIL_TRANSITION

(1U << RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT)

Radio is headed to the idle, receive, or transmit state.

RAIL_RF_STATE_DETAIL_ACTIVE#

#define RAIL_RF_STATE_DETAIL_ACTIVE

(1U << RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT)

Radio is actively transmitting or receiving.

RAIL_RF_STATE_DETAIL_NO_FRAMES#

#define RAIL_RF_STATE_DETAIL_NO_FRAMES

(1U << RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT)

Radio has frame detect disabled.

RAIL_RF_STATE_DETAIL_LBT#

#define RAIL_RF_STATE_DETAIL_LBT

(1U << RAIL_RF_STATE_DETAIL_LBT_SHIFT)

LBT/CSMA operation is currently ongoing.

RAIL_RF_STATE_DETAIL_CORE_STATE_MASK#

#define RAIL_RF_STATE_DETAIL_CORE_STATE_MASK

Mask for core radio state bits.

RAIL_STOP_MODES_NONE#

#define RAIL_STOP_MODES_NONE

(0U)

Do not stop any radio operations.

RAIL_STOP_MODE_ACTIVE#

#define RAIL_STOP_MODE_ACTIVE

(1U << RAIL_STOP_MODE_ACTIVE_SHIFT)

Stop active radio operations only.

RAIL_STOP_MODE_PENDING#

#define RAIL_STOP_MODE_PENDING

(1U << RAIL_STOP_MODE_PENDING_SHIFT)

Stop pending radio operations.

RAIL_STOP_MODES_ALL#

#define RAIL_STOP_MODES_ALL

(0xFFU)

Stop all radio operations.

RAIL_TX_OPTIONS_NONE#

#define RAIL_TX_OPTIONS_NONE

0UL

A value representing no options enabled.

RAIL_TX_OPTIONS_DEFAULT#

#define RAIL_TX_OPTIONS_DEFAULT

RAIL_TX_OPTIONS_NONE

All options disabled by default.

This is the fastest TX option to apply.

RAIL_TX_OPTION_WAIT_FOR_ACK#

#define RAIL_TX_OPTION_WAIT_FOR_ACK

(1UL << RAIL_TX_OPTION_WAIT_FOR_ACK_SHIFT)

An option to configure whether or not the TXing node will listen for an ACK.

If this is false, the isAck flag in RAIL_RxPacketDetails_t of a received packet will always be false.

RAIL_TX_OPTION_REMOVE_CRC#

#define RAIL_TX_OPTION_REMOVE_CRC

(1UL << RAIL_TX_OPTION_REMOVE_CRC_SHIFT)

An option to remove CRC bytes from TX packets.

To receive packets when the sender has this option set true, set RAIL_RX_OPTION_IGNORE_CRC_ERRORS on the receive side.

RAIL_TX_OPTION_SYNC_WORD_ID#

#define RAIL_TX_OPTION_SYNC_WORD_ID

(1UL << RAIL_TX_OPTION_SYNC_WORD_ID_SHIFT)

An option to select which sync word is used during the transmission.

When two sync words are configured by the PHY or RAIL_ConfigSyncWords() enabling this option selects SYNC2 rather than SYNC1 for the upcoming transmit.

This option should not be used when only one sync word has been configured.

Note

• There are a few special radio configurations (e.g. BLE Viterbi) that do not support transmitting different sync words.

RAIL_TX_OPTION_ANTENNA0#

#define RAIL_TX_OPTION_ANTENNA0

(1UL << RAIL_TX_OPTION_ANTENNA0_SHIFT)

An option to select antenna 0 for transmission.

If the antenna selection option is not set or if both antenna options are set, then the transmit will occur on either antenna depending on the last receive or transmit selection. This option is only valid on platforms that support Antenna Control and have been configured via RAIL_ConfigAntenna().

Note

• These TX antenna options do not control the antenna used for Auto-ACK transmissions, which always occur on the same antenna used to receive the packet being acknowledged.

RAIL_TX_OPTION_ANTENNA1#

#define RAIL_TX_OPTION_ANTENNA1

(1UL << RAIL_TX_OPTION_ANTENNA1_SHIFT)

An option to select antenna 1 for transmission.

If the antenna selection option is not set or if both antenna options are set, then the transmit will occur on either antenna depending on the last receive or transmit selection. This option is only valid on platforms that support Antenna Control and have been configured via RAIL_ConfigAntenna().

Note

• These TX antenna options do not control the antenna used for Auto-ACK transmissions, which always occur on the same antenna used to receive the packet being acknowledged.

RAIL_TX_OPTION_ALT_PREAMBLE_LEN#

#define RAIL_TX_OPTION_ALT_PREAMBLE_LEN

(1UL << RAIL_TX_OPTION_ALT_PREAMBLE_LEN_SHIFT)

An option to use the alternate preamble length established by RAIL_SetTxAltPreambleLength() for the transmission.

When not set, the PHY configuration's preamble length is used.

RAIL_TX_OPTION_CCA_PEAK_RSSI#

#define RAIL_TX_OPTION_CCA_PEAK_RSSI

(1UL << RAIL_TX_OPTION_CCA_PEAK_RSSI_SHIFT)

An option to use peak rather than average RSSI energy detected during CSMA's RAIL_CsmaConfig_t::ccaDuration or LBT's RAIL_LbtConfig_t::lbtDuration to determine whether the channel is clear or busy.

This option is only valid when calling one of the CCA transmit routines: RAIL_StartCcaCsmaTx, RAIL_StartCcaLbtTx, RAIL_StartScheduledCcaCsmaTx, or RAIL_StartScheduledCcaLbtTx.

Note

• This option does nothing on platforms like EFR32XG1 that lack support for capturing peak RSSI energy.

RAIL_TX_OPTION_CCA_ONLY#

#define RAIL_TX_OPTION_CCA_ONLY

(1UL << RAIL_TX_OPTION_CCA_ONLY_SHIFT)

An option to only perform the CCA (CSMA/LBT) operation but not automatically transmit if the channel is clear.

This option is only valid when calling one of the CCA transmit routines: RAIL_StartCcaCsmaTx, RAIL_StartCcaLbtTx, RAIL_StartScheduledCcaCsmaTx, or RAIL_StartScheduledCcaLbtTx.

Application can then use the RAIL_EVENT_TX_CHANNEL_CLEAR to initiate transmit manually, e.g., giving it the opportunity to adjust outgoing packet data before the packet goes out.

Note

• Configured state transitions to Rx or Idle are suspended during this CSMA/LBT operation. If packet reception occurs, the radio will return to the state it was in just prior to the CSMA/LBT operation when that reception (including any AutoACK response) is complete.

RAIL_TX_OPTION_RESEND#

#define RAIL_TX_OPTION_RESEND

(1UL << RAIL_TX_OPTION_RESEND_SHIFT)

An option to resend packet at the beginning of the Transmit FIFO.

The packet to be resent must have been previously provided by RAIL_SetTxFifo() or RAIL_WriteTxFifo() passing true for the latter's reset parameter. It works by setting the transmit FIFO's read offset to the beginning of the FIFO while leaving its write offset intact. For this to work, RAIL_DataConfig_t::txMethod must be RAIL_DataMethod_t::PACKET_MODE (i.e., the packet can't exceed the Transmit FIFO's size), otherwise undefined behavior will result.

This option can also be used with RAIL_SetNextTxRepeat() to cause the repeated packet(s) to all be the same as the first.

RAIL_TX_OPTION_CONCURRENT_PHY_ID#

#define RAIL_TX_OPTION_CONCURRENT_PHY_ID

(1UL << RAIL_TX_OPTION_CONCURRENT_PHY_ID_SHIFT)

An option to specify which PHY is used to transmit in the case of concurrent mode.

Concurrent mode is only allowed on EFR32xG25 for some predefined combinations of Wi-SUN PHYs. When set/unset, the alternate/base PHY is used to transmit.

RAIL_TX_OPTIONS_ALL#

#define RAIL_TX_OPTIONS_ALL

0xFFFFFFFFUL

A value representing all possible options.

RAIL_MAX_LBT_TRIES#

#define RAIL_MAX_LBT_TRIES

(15U)

The maximum number of LBT/CSMA retries supported.

RAIL_MAX_CSMA_EXPONENT#

#define RAIL_MAX_CSMA_EXPONENT

(8U)

The maximum power-of-2 exponent for CSMA backoffs.

RAIL_CSMA_CONFIG_802_15_4_2003_2p4_GHz_OQPSK_CSMA#

#define RAIL_CSMA_CONFIG_802_15_4_2003_2p4_GHz_OQPSK_CSMA

RAIL_CsmaConfig_t initializer configuring CSMA per IEEE 802.15.4-2003 on 2.4 GHz OSPSK, commonly used by ZigBee.

RAIL_CSMA_CONFIG_SINGLE_CCA#

#define RAIL_CSMA_CONFIG_SINGLE_CCA

RAIL_CsmaConfig_t initializer configuring a single CCA prior to TX.

It can be used to as a basis for implementing other channel access schemes with custom backoff delays. Users can override ccaBackoff with a fixed delay on each use.

RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1#

#define RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1

RAIL_LbtConfig_t initializer configuring LBT per ETSI 300 220-1 V2.4.1 for a typical Sub-GHz band.

To be practical, users should override lbtTries and/or lbtTimeout so channel access failure will be reported in a reasonable time frame rather than the unbounded time frame ETSI defined.

RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0#

#define RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0

RAIL_LbtConfig_t initializer configuring LBT per ETSI 300 220-1 V3.1.0 for a typical Sub-GHz band.

To be practical, users should override lbtTries and/or lbtTimeout so channel access failure will be reported in a reasonable time frame rather than the unbounded time frame ETSI defined.

ADDRCONFIG_MATCH_TABLE_SINGLE_FIELD#

#define ADDRCONFIG_MATCH_TABLE_SINGLE_FIELD

(0x1FFFFFE)

A default address filtering match table for configurations that use only one address field.

The truth table for address matching is shown below.

ADDRCONFIG_MATCH_TABLE_DOUBLE_FIELD#

#define ADDRCONFIG_MATCH_TABLE_DOUBLE_FIELD

(0x1041040)

A default address filtering match table for configurations that use two address fields and want to match the same index in each.

The truth table for address matching is shown below.

ADDRCONFIG_MAX_ADDRESS_FIELDS#

#define ADDRCONFIG_MAX_ADDRESS_FIELDS

(2)

The maximum number of address fields that can be used by the address filtering logic.

RAIL_RX_OPTIONS_NONE#

#define RAIL_RX_OPTIONS_NONE

0

A value representing no options enabled.

RAIL_RX_OPTIONS_DEFAULT#

#define RAIL_RX_OPTIONS_DEFAULT

RAIL_RX_OPTIONS_NONE

All options are disabled by default.

RAIL_RX_OPTION_STORE_CRC#

#define RAIL_RX_OPTION_STORE_CRC

(1UL << RAIL_RX_OPTION_STORE_CRC_SHIFT)

An option to configure whether the CRC portion of the packet is included in the packet payload exposed to the app on packet reception.

Defaults to false.

RAIL_RX_OPTION_IGNORE_CRC_ERRORS#

#define RAIL_RX_OPTION_IGNORE_CRC_ERRORS

(1UL << RAIL_RX_OPTION_IGNORE_CRC_ERRORS_SHIFT)

An option to configure whether CRC errors will be ignored.

If this is set, RX will still be successful, even if the CRC does not pass the check. Defaults to false.

Note

• An expected ACK that fails CRC with this option set will still be considered the expected ACK, terminating the RAIL_AutoAckConfig_t::ackTimeout period.

RAIL_RX_OPTION_ENABLE_DUALSYNC#

#define RAIL_RX_OPTION_ENABLE_DUALSYNC

(1UL << RAIL_RX_OPTION_ENABLE_DUALSYNC_SHIFT)

An option to control which sync words will be accepted.

Setting it to 0 (default) will cause the receiver to listen for SYNC1 only. Setting it to 1 causes the receiver to listen for either SYNC1 or SYNC2. RX appended info will contain which sync word was detected. Note, this only affects which sync word(s) are received, but not what each of the sync words actually are. This feature may not be available on some combinations of chips, PHYs, and protocols. Use the compile time symbol RAIL_SUPPORTS_DUAL_SYNC_WORDS or the runtime call RAIL_SupportsDualSyncWords() to check whether the platform supports this feature. Also, DUALSYNC may be incompatible with certain radio configurations. In these cases, setting this bit will be ignored. See the data sheet or support team for more details.

RAIL_RX_OPTION_TRACK_ABORTED_FRAMES#

#define RAIL_RX_OPTION_TRACK_ABORTED_FRAMES

(1UL << RAIL_RX_OPTION_TRACK_ABORTED_FRAMES_SHIFT)

An option to configure whether frames which are aborted during reception should continue to be tracked.

Setting this option allows viewing Packet Trace information for frames which get discarded. Defaults to false.

This option is ignored when doing a RAIL_IDLE_FORCE_SHUTDOWN or RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS.

Note

• This option should not be used with coded PHYs since packet data received after the abort will not be decoded properly.

RAIL_RX_OPTION_REMOVE_APPENDED_INFO#

#define RAIL_RX_OPTION_REMOVE_APPENDED_INFO

(1UL << RAIL_RX_OPTION_REMOVE_APPENDED_INFO_SHIFT)

An option to suppress capturing the appended information after received frames.

Defaults to false. When suppressed, certain RAIL_RxPacketDetails_t details will not be available for received packets whose RAIL_RxPacketStatus_t is among the RAIL_RX_PACKET_READY_ set.

Warnings

• This option should be changed only when the radio is idle and the receive FIFO is empty or has been reset, otherwise RAIL_GetRxPacketInfo() and RAIL_GetRxPacketDetails() may think appended info is packet data or vice-versa.

RAIL_RX_OPTION_ANTENNA0#

#define RAIL_RX_OPTION_ANTENNA0

(1UL << RAIL_RX_OPTION_ANTENNA0_SHIFT)

An option to select the use of antenna 0 during receive (including Auto-ACK receive).

If no antenna option is selected, the packet will be received on the last antenna used for receive or transmit. Defaults to false. This option is only valid on platforms that support Antenna Control and have been configured via RAIL_ConfigAntenna().

RAIL_RX_OPTION_ANTENNA1#

#define RAIL_RX_OPTION_ANTENNA1

(1UL << RAIL_RX_OPTION_ANTENNA1_SHIFT)

An option to select the use of antenna 1 during receive (including Auto-ACK receive).

If no antenna option is selected, the packet will be received on the last antenna used for receive or transmit. Defaults to false. This option is only valid on platforms that support Antenna Control and have been configured via RAIL_ConfigAntenna().

RAIL_RX_OPTION_ANTENNA_AUTO#

#define RAIL_RX_OPTION_ANTENNA_AUTO

(RAIL_RX_OPTION_ANTENNA0 | RAIL_RX_OPTION_ANTENNA1)

An option combination to automatically choose an antenna during receive (including Auto-ACK receive).

If both antenna 0 and antenna 1 options are set, the radio will dynamically switch between antennas during packet detection and choose the best one for completing the reception. This option is only valid when the antenna diversity field is properly configured via Simplicity Studio. This option is only valid on platforms that support Antenna Control and have been configured via RAIL_ConfigAntenna().

RAIL_RX_OPTION_DISABLE_FRAME_DETECTION#

#define RAIL_RX_OPTION_DISABLE_FRAME_DETECTION

(1UL << RAIL_RX_OPTION_DISABLE_FRAME_DETECTION_SHIFT)

An option to disable frame detection.

This can be useful for doing energy detection without risking packet reception. Enabling this will abort any frame currently being received in addition to preventing further frames from being received. Defaults to false.

RAIL_RX_OPTION_CHANNEL_SWITCHING#

#define RAIL_RX_OPTION_CHANNEL_SWITCHING

(1U << RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT)

An option to enable IEEE 802.15.4 RX channel switching.

RAIL_IEEE802154_ConfigRxChannelSwitching() must be called to configure the feature before enabling it via this option. Defaults to false.

Note

• This option is only supported on specific chips where RAIL_IEEE802154_SUPPORTS_RX_CHANNEL_SWITCHING is true.

• This option overrides RAIL_RX_OPTION_ANTENNA0, RAIL_RX_OPTION_ANTENNA1 and RAIL_RX_OPTION_ANTENNA_AUTO antenna selection options.

RAIL_RX_OPTION_FAST_RX2RX#

#define RAIL_RX_OPTION_FAST_RX2RX

(1U << RAIL_RX_OPTION_FAST_RX2RX_SHIFT)

An option to enable fast RX2RX state transition.

Once enabled, the sequencer will send the radio to RXSEARCH and get ready to receive the next packet while still processing the previous one. This will reduce RX to RX state transition time but risks impacting receive capability.

Note

• This option is only supported on specific chips where RAIL_SUPPORTS_FAST_RX2RX is true.

RAIL_RX_OPTIONS_ALL#

#define RAIL_RX_OPTIONS_ALL

0xFFFFFFFFUL

A value representing all possible options.

RAIL_RSSI_INVALID_DBM#

#define RAIL_RSSI_INVALID_DBM

(-128)

The value returned by RAIL for an invalid RSSI, in dBm.

RAIL_RSSI_INVALID#

#define RAIL_RSSI_INVALID

((int16_t)(RAIL_RSSI_INVALID_DBM * 4))

The value returned by RAIL for an invalid RSSI: in quarter dBm.

RAIL_RSSI_LOWEST#

#define RAIL_RSSI_LOWEST

((int16_t)(RAIL_RSSI_INVALID + 1))

The lowest RSSI value returned by RAIL: in quarter dBm.

RAIL_RSSI_OFFSET_MAX#

#define RAIL_RSSI_OFFSET_MAX

35

Maximum absolute value for RSSI offset.

RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT#

#define RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT

((RAIL_Time_t)0xFFFFFFFFU)

A sentinel value to indicate waiting for a valid RSSI without a timeout.

RAIL_GET_RSSI_NO_WAIT#

#define RAIL_GET_RSSI_NO_WAIT

((RAIL_Time_t)0U)

A sentinel value to indicate no waiting for a valid RSSI.

RAIL_RX_PACKET_HANDLE_INVALID#

#define RAIL_RX_PACKET_HANDLE_INVALID

(NULL)

An invalid RX packet handle value.

RAIL_RX_PACKET_HANDLE_OLDEST#

#define RAIL_RX_PACKET_HANDLE_OLDEST

((RAIL_RxPacketHandle_t) 1)

A special RX packet handle to refer to the oldest unreleased packet.

This includes the newest unread packet which is possibly incomplete or not yet started. This handle is used implicitly by RAIL_ReadRxFifo().

RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE#

#define RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE

((RAIL_RxPacketHandle_t) 2)

A special RX packet handle to refer to the oldest unreleased complete packet.

This never includes incomplete or unstarted packets. (Using RAIL_RX_PACKET_HANDLE_OLDEST is inappropriate for this purpose because it can refer to an unstarted, incomplete, or unheld packet which are inappropriate to be consumed by the application.)

RAIL_RX_PACKET_HANDLE_NEWEST#

#define RAIL_RX_PACKET_HANDLE_NEWEST

((RAIL_RxPacketHandle_t) 3)

A special RX packet handle to refer to the newest unreleased packet when in callback context.

For a callback involving a completed receive event, this refers to the packet just completed. For other callback events, this refers to the next packet to be completed, which might be in-progress or might not have even started yet.

RAIL_AUTOACK_MAX_LENGTH#

#define RAIL_AUTOACK_MAX_LENGTH

(64U)

Acknowledgment packets cannot be longer than 64 bytes.

RAIL_INVALID_THERMISTOR_VALUE#

#define RAIL_INVALID_THERMISTOR_VALUE

(0xFFFFFFFFU)

A sentinel value to indicate an invalid thermistor measurement value.

RAIL_INVALID_PPM_VALUE#

#define RAIL_INVALID_PPM_VALUE

(-128)

A sentinel value to indicate an invalid PPM calculation value.

RAIL_RFSENSE_LOW_SENSITIVITY_OFFSET#

#define RAIL_RFSENSE_LOW_SENSITIVITY_OFFSET

(0x20U)

RF Sense low sensitivity offset.

RAIL_RFSENSE_USE_HW_SYNCWORD#

#define RAIL_RFSENSE_USE_HW_SYNCWORD

(0U)

Use the MODEM default sync word.

RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US#

#define RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US

0x08000000UL

The maximum sense time supported for those RAIL_RxChannelHoppingMode_t modes whose parameter(s) specify a sensing time.

RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE#

#define RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE

0U

A value representing no options enabled.

RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT#

#define RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT

RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE

All options disabled by default.

Channel hopping will behave as described by other parameters as it did in RAIL 2.7 and earlier.

RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT

RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT

DeprecatedPlease use RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT instead.

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL

(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT)

An option to skip synth calibration while hopping into the channel specified in the current entry.

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL

(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT)

An option to skip DC calibration while hopping into the channel specified in the current entry.

RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD

(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT)

An option to check RSSI after hopping into the channel specified in the current entry and hop if that RSSI is below the threshold specified in RAIL_RxChannelHoppingConfigEntry_t::rssiThresholdDbm.

This check runs in parallel with the RAIL_RxChannelHoppingMode_t specified and may cause a hop sooner than that mode otherwise would.

RAIL_RX_CHANNEL_HOPPING_OPTION_STOP#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_STOP

(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT)

An option to stop the hopping sequence at this entry in the hop table.

RAIL_CHANNEL_HOPPING_INVALID_INDEX#

#define RAIL_CHANNEL_HOPPING_INVALID_INDEX

(0xFEU)

A sentinel value to flag an invalid channel hopping index.

RAIL_VERIFY_DURATION_MAX#

#define RAIL_VERIFY_DURATION_MAX

0xFFFFFFFFUL

This radio state verification duration indicates to RAIL that all memory contents should be verified by RAIL before returning to the application.

RAIL_EFF_SUPPORTS_TRANSMIT#

#define RAIL_EFF_SUPPORTS_TRANSMIT

A macro that checks for EFFxx devices that support high power transmit.

RAIL_EFF_SUPPORTS_RECEIVE#

#define RAIL_EFF_SUPPORTS_RECEIVE

A macro that checks for EFFxx devices that support receive.

RAIL_EFF_TEMP_THRESHOLD_MAX#

#define RAIL_EFF_TEMP_THRESHOLD_MAX

(383U)

Maximum EFF internal temperature in Kelvin, allowing transmissions when RAIL_SUPPORTS_EFF is enabled.

RAIL_EFF_MODE_SENSOR_ENUM_NAMES#

#define RAIL_EFF_MODE_SENSOR_ENUM_NAMES

A macro that is string versions of the calibration enums.

RAIL_EFF_CLPC_ENABLE_ENUM_NAMES#

#define RAIL_EFF_CLPC_ENABLE_ENUM_NAMES

A macro that is string versions of the calibration enums.

RAIL_CHIP_TEMP_THRESHOLD_MAX#

#define RAIL_CHIP_TEMP_THRESHOLD_MAX

(398U)

Maximum junction temperature in Kelvin.

A margin is subtracted before using it when RAIL_SUPPORTS_THERMAL_PROTECTION is enabled.

RAIL_CHIP_TEMP_COOLDOWN_DEFAULT#

#define RAIL_CHIP_TEMP_COOLDOWN_DEFAULT

(7U)

Default number of Kelvin degrees below threshold needed to allow transmissions.

RAIL_CHIP_TEMP_MEASURE_COUNT#

#define RAIL_CHIP_TEMP_MEASURE_COUNT

(3U)

Number of temperature values provided for the chip thermal protection.

RAIL_TRANSITION_TIME_KEEP#

#define RAIL_TRANSITION_TIME_KEEP

((RAIL_TransitionTime_t) -1)

A value to use in RAIL_StateTiming_t fields when calling RAIL_SetStateTiming() to keep that timing parameter at it current setting.

RAIL_TX_REPEAT_OPTIONS_NONE#

#define RAIL_TX_REPEAT_OPTIONS_NONE

0U

A value representing no repeat options enabled.

RAIL_TX_REPEAT_OPTIONS_DEFAULT#

#define RAIL_TX_REPEAT_OPTIONS_DEFAULT

RAIL_TX_REPEAT_OPTIONS_NONE

All repeat options disabled by default.

RAIL_TX_REPEAT_OPTION_HOP#

#define RAIL_TX_REPEAT_OPTION_HOP

(1U << RAIL_TX_REPEAT_OPTION_HOP_SHIFT)

An option to configure whether or not to channel-hop before each repeated transmit.

RAIL_TX_REPEAT_OPTION_START_TO_START#

#define RAIL_TX_REPEAT_OPTION_START_TO_START

(1 << RAIL_TX_REPEAT_OPTION_START_TO_START_SHIFT)

An option to configure the delay between transmissions to be from start to start instead of end to start.

Delay must be long enough to cover the prior transmit's time.

RAIL_TX_REPEAT_INFINITE_ITERATIONS#

#define RAIL_TX_REPEAT_INFINITE_ITERATIONS

(0xFFFFU)

RAIL_TxRepeatConfig_t::iterations initializer configuring infinite repeated transmissions.

RAIL_Status_t#

RAIL_Status_t

A status returned by many RAIL API calls indicating their success or failure.

RAIL_TimeMode_t#

RAIL_TimeMode_t

Specify a time offset in RAIL APIs.

Different APIs use the same constants and may provide more specifics about how they're used but the general use for each is described below.

RAIL_PacketTimePosition_t#

RAIL_PacketTimePosition_t

The available packet timestamp position choices.

RAIL_SleepConfig_t#

RAIL_SleepConfig_t

The configuration.

RAIL_SchedulerStatus_t#

RAIL_SchedulerStatus_t

Multiprotocol scheduler status returned by RAIL_GetSchedulerStatus().

Multiprotocol scheduler status is a combination of the upper 4 bits which constitute the type of scheduler task and the lower 4 bits which constitute the type of scheduler error.

RAIL_TaskType_t#

RAIL_TaskType_t

Multiprotocol radio operation task types, used with RAIL_SetTaskPriority.

RAIL_Events_t#

RAIL_Events_t

RAIL events passed to the event callback.

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

RAIL_ChannelConfigEntryType_t#

RAIL_ChannelConfigEntryType_t

Define if the channel support using concurrent PHY during channel hopping.

RAIL_RX_CHANNEL_HOPPING_MODE_CONC and RAIL_RX_CHANNEL_HOPPING_MODE_VT can only be used if the channel supports it.

RAIL_PtiProtocol_t#

RAIL_PtiProtocol_t

The protocol that RAIL outputs via the Packet Trace Interface (PTI).

RAIL_TxDataSource_t#

RAIL_TxDataSource_t

Transmit data sources supported by RAIL.

RAIL_RxDataSource_t#

RAIL_RxDataSource_t

Receive data sources supported by RAIL.

Note

• Data sources other than RX_PACKET_DATA require use of RAIL_DataMethod_t::FIFO_MODE.

RAIL_DataMethod_t#

RAIL_DataMethod_t

Methods for the application to provide and retrieve data from RAIL.

For Transmit the distinction between RAIL_DataMethod_t::PACKET_MODE and RAIL_DataMethod_t::FIFO_MODE has become more cosmetic than functional, as the RAIL_WriteTxFifo() and RAIL_SetTxFifoThreshold() APIs and related RAIL_EVENT_TX_FIFO_ALMOST_EMPTY event can be used in either mode. For Receive the distinction is functionally important because in RAIL_DataMethod_t::PACKET_MODE rollback occurs automatically for unsuccessfully-received packets (RAIL_RxPacketStatus_t ABORT statuses), flushing their data. In RAIL_DataMethod_t::FIFO_MODE rollback is prevented, leaving the data from unsuccessfully-received packets in the receive FIFO for the application to deal with. This allows for packets larger than the receive FIFO size where automatic rollback would corrupt the receive FIFO.

RAIL_RadioState_t#

RAIL_RadioState_t

The state of the radio.

RAIL_RadioStateDetail_t#

RAIL_RadioStateDetail_t

The detailed state of the radio.

The three radio state bits RAIL_RF_STATE_DETAIL_IDLE_STATE, RAIL_RF_STATE_DETAIL_RX_STATE, and RAIL_RF_STATE_DETAIL_TX_STATE comprise a set of mutually exclusive core radio states. Only one (or none) of these bits can be set at a time. Otherwise, the value is invalid.

The precise meaning of each of these three core bits, when set, depends on the value of the two bits RAIL_RF_STATE_DETAIL_TRANSITION and RAIL_RF_STATE_DETAIL_ACTIVE. When RAIL_RF_STATE_DETAIL_TRANSITION is set, the radio is transitioning into the core radio state corresponding to the set state bit. When it is clear, the radio is already in the core radio state that corresponds to the set state bit. When RAIL_RF_STATE_DETAIL_ACTIVE is set, the radio is actively transmitting or receiving. When it is clear, the radio is not actively transmitting or receiving. This bit will always be clear when RAIL_RF_STATE_DETAIL_IDLE_STATE is set, and will always be set when RAIL_RF_STATE_DETAIL_TX_STATE is set. Otherwise, the value is invalid.

The bit RAIL_RF_STATE_DETAIL_NO_FRAMES is set if the radio is currently operating with frame detection disabled, and clear otherwise. The bit RAIL_RF_STATE_DETAIL_LBT_SHIFT is set if an LBT/CSMA operation (e.g., performing CCA) is currently ongoing, and clear otherwise.

RAIL_IdleMode_t#

RAIL_IdleMode_t

An enumeration for the different types of supported idle modes.

These vary how quickly and destructively they put the radio into idle.

RAIL_StopMode_t#

RAIL_StopMode_t

Stop radio operation options bit mask.

RAIL_TxOptions_t#

RAIL_TxOptions_t

Transmit options, in reality a bitmask.

RAIL_ScheduledTxDuringRx_t#

RAIL_ScheduledTxDuringRx_t

Enumerates the possible outcomes of what will occur if a scheduled TX ends up firing during RX.

Because RX and TX can't happen at the same time, it is up to the user how the TX should be handled. This enumeration is passed into RAIL_StartScheduledTx() as part of RAIL_ScheduleTxConfig_t.

RAIL_RxOptions_t#

RAIL_RxOptions_t

Receive options, in reality a bitmask.

RAIL_RxPacketStatus_t#

RAIL_RxPacketStatus_t

The packet status code associated with a packet received or currently being received.

Note

• RECEIVING implies some packet data may be available, but is untrustworthy (not CRC-verified) and might disappear if the packet is rolled back on error. No packet details are yet available.

• In RX RAIL_DataMethod_t::FIFO_MODE, ABORT statuses imply some packet data may be available, but it's incomplete and not trustworthy.

RAIL_RfSenseBand_t#

RAIL_RfSenseBand_t

An enumeration for specifying the RF Sense frequency band.

RAIL_RxChannelHoppingMode_t#

RAIL_RxChannelHoppingMode_t

Modes by which RAIL can determine when to proceed to the next channel during channel hopping.

RAIL_RxChannelHoppingDelayMode_t#

RAIL_RxChannelHoppingDelayMode_t

DeprecatedSet only to RAIL_RX_CHANNEL_DELAY_MODE_STATIC

RAIL_RxChannelHoppingOptions_t#

RAIL_RxChannelHoppingOptions_t

Options that can customize channel hopping behavior on a per-hop basis.

RAIL_StreamMode_t#

RAIL_StreamMode_t

Possible stream output modes.

RAIL_EffDevice_t#

RAIL_EffDevice_t

EFF part numbers.

The part number of the attached EFF device is passed to RAIL_ConfigEff() as RAIL_EffConfig_t::device. The Energy Friendly Front End Module (EFF) Utility configures and controls the EFF based on the capabilities of the attached EFF.

RAIL_EffLnaMode_t#

RAIL_EffLnaMode_t

EFF LNA Modes.

The enabled EFF LNA modes are passed toRAIL_ConfigEff() as the RAIL_EffConfig_t::enabledLnaModes. The Energy Friendly Front End Module (EFF) Utility dynamically transitions between enabled LNA modes to maximize receive performance.

RAIL_ClpcEnable_t#

RAIL_ClpcEnable_t

EFF Closed Loop Power Control (CLPC) Enable states.

The EFF CLPC Enable state is passed to RAIL_ConfigEff() as the RAIL_EffConfig_t::clpcEnable. The Energy Friendly Front End Module (EFF) Utility uses advanced power controls to tune EFF output to match Surface Acoustic Wave (SAW) filter losses and antenna performance.

RAIL_EffModeSensor_t#

RAIL_EffModeSensor_t

EFF Closed Loop Power Control (CLPC) Mode Sensor Indices.

The mode sensor indices are used to access specific settings with CLPC.

RAIL_TxRepeatOptions_t#

RAIL_TxRepeatOptions_t

Transmit repeat options, in reality a bitmask.

RAIL_Handle_t#

RAIL_Handle_t

A generic handle to a particular radio (e.g.

RAIL_EFR32_HANDLE), or a real handle of a RAIL instance, as returned from RAIL_Init().

Generic handles should be used for certain RAIL APIs that are called prior to RAIL initialization. However, once RAIL has been initialized, the real handle returned by RAIL_Init() should be used instead.

RAIL_InitCompleteCallbackPtr_t#

typedef void(* RAIL_InitCompleteCallbackPtr_t) (RAIL_Handle_t railHandle) )(RAIL_Handle_t railHandle)

A pointer to init complete callback function.

RAIL_Time_t#

RAIL_Time_t

Time in microseconds.

RAIL_TimerCallback_t#

typedef void(* RAIL_TimerCallback_t) (RAIL_Handle_t cbArg) )(RAIL_Handle_t cbArg)

A pointer to the callback called when the RAIL timer expires.

RAIL_MultiTimerCallback_t#

RAIL_MultiTimerCallback_t )(struct RAIL_MultiTimer *tmr, RAIL_Time_t expectedTimeOfEvent, void *cbArg)

Callback fired when timer expires.

RAIL_TxPower_t#

typedef int16_t RAIL_TxPower_t

The transmit power in deci-dBm units (e.g., 4.5 dBm -> 45 deci-dBm).

These values are used by the conversion functions to convert a RAIL_TxPowerLevel_t to deci-dBm for the application consumption. On EFR32, they can range from RAIL_TX_POWER_MIN to RAIL_TX_POWER_MAX.

RAIL_RadioConfigChangedCallback_t#

RAIL_RadioConfigChangedCallback_t )(RAIL_Handle_t railHandle, const RAIL_ChannelConfigEntry_t *entry)

A pointer to a function called whenever a radio configuration change occurs.

RAIL_AddrFilterMask_t#

typedef uint8_t RAIL_AddrFilterMask_t

A bitmask representation of which 4 filters passed for each ADDRCONFIG_MAX_ADDRESS_FIELDS when filtering has completed successfully.

It's layout is: | Bit 7 | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | Bit 0 | |-----—+-----—+-----—+-----—+-----—+-----—+-----—+-----—| | Second Address Field Nibble | First Address Field Nibble | | Addr 3 | Addr 2 | Addr 1 | Addr 0 | Addr 3 | Addr 2 | Addr 1 | Addr 0 | | match | match | match | match | match | match | match | match | |-----—+-----—+-----—+-----—+-----—+-----—+-----—+-----—|

Note

• This information is valid in RAIL_IEEE802154_Address_t on all platforms, but is only valid in RAIL_RxPacketInfo_t on platforms where RAIL_SUPPORTS_ADDR_FILTER_MASK is true.

RAIL_RxPacketHandle_t#

RAIL_RxPacketHandle_t

A handle used to reference a packet during reception processing.

There are several sentinel handle values that pertain to certain circumstances: RAIL_RX_PACKET_HANDLE_INVALID, RAIL_RX_PACKET_HANDLE_OLDEST, RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE and RAIL_RX_PACKET_HANDLE_NEWEST.

RAIL_CalMask_t#

RAIL_CalMask_t

A calibration mask type.

This type is a bitmask of different RAIL calibration values. The exact meaning of these bits depends on what a particular chip supports.

RAIL_ConvertLqiCallback_t#

RAIL_ConvertLqiCallback_t )(uint8_t lqi, int8_t rssi)

A pointer to a function called before LQI is copied into the RAIL_RxPacketDetails_t structure.

Returns

• uint8_t The converted LQI value that will be loaded into the RAIL_RxPacketDetails_t structure in preparation for application consumption. This value should likewise be in integral units ranging from 0 to 255.

RAIL_RfSense_CallbackPtr_t#

typedef void(* RAIL_RfSense_CallbackPtr_t) (void) )(void)

A pointer to an RF Sense callback function.

Consider using the event RAIL_EVENT_RF_SENSED as an alternative.

RAIL_RxChannelHoppingParameter_t#

RAIL_RxChannelHoppingParameter_t

Rx channel hopping on-channel time.

RAIL_VerifyCallbackPtr_t#

typedef bool(* RAIL_VerifyCallbackPtr_t) (uint32_t address, uint32_t expectedValue, uint32_t actualValue) )(uint32_t address, uint32_t expectedValue, uint32_t actualValue)

A pointer to a verification callback function.

This will be called by the radio state verification feature built into RAIL when a verified memory value is different from its reference value.

Returns

• bool True indicates a data value difference is acceptable. False indicates a data value difference in unacceptable.

Note

• This callback will be issued when an address' value is different from its reference value and either of the following conditions are met: 1) The default radio configuration provided by the radio configurator is used for verification purposes (i.e., a custom radio configuration is not supplied as an input to RAIL_ConfigVerification()), and the radio configurator has flagged the address under question as being verifiable. 2) A custom radio configuration is provided to the verification API (i.e., a custom radio configuration is supplied as an input to RAIL_ConfigVerification()). When providing a custom radio configuration for verification purposes, all addresses in that configuration will be verified, regardless of whether or not the addresses are flagged as verifiable.