SLI_RAIL_ENUM#

#define SLI_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.

SLI_RAIL_ENUM_GENERIC#

#define SLI_RAIL_ENUM_GENERIC

(name, type)

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

See SLI_RAIL_ENUM() for more information.

SL_RAIL_EFR32_HANDLE#

#define SL_RAIL_EFR32_HANDLE

((sl_rail_handle_t)0xFFFFFFFFUL)

A generic-radio RAIL handle for the primary EFR32 radio.

Using NULL as a RAIL handle is not recommended. As a result, this value that can't be de-referenced is used.

Generic radio handles must be used for RAIL APIs that are called prior to RAIL initialization, and passed into sl_rail_init().

SL_RAIL_STATUS_NO_ERROR#

#define SL_RAIL_STATUS_NO_ERROR

SL_STATUS_OK

RAIL function reports no error.

SL_RAIL_STATUS_INVALID_PARAMETER#

#define SL_RAIL_STATUS_INVALID_PARAMETER

SL_STATUS_INVALID_PARAMETER

Call to RAIL function threw an error because of an invalid parameter.

SL_RAIL_STATUS_INVALID_STATE#

#define SL_RAIL_STATUS_INVALID_STATE

SL_STATUS_INVALID_STATE

Call to RAIL function threw an error because it was called during an invalid radio state.

SL_RAIL_STATUS_INVALID_CALL#

#define SL_RAIL_STATUS_INVALID_CALL

SL_STATUS_NOT_AVAILABLE

RAIL function is called in an invalid order.

SL_RAIL_STATUS_SUSPENDED#

#define SL_RAIL_STATUS_SUSPENDED

SL_STATUS_IN_PROGRESS

RAIL function did not finish in the allotted time.

SL_RAIL_STATUS_SCHED_ERROR#

#define SL_RAIL_STATUS_SCHED_ERROR

SL_STATUS_ABORT

RAIL function could not be scheduled by the Radio scheduler.

Only issued when using a Multiprotocol application.

SL_RAIL_STATUS_NO_MORE_RESOURCE#

#define SL_RAIL_STATUS_NO_MORE_RESOURCE

SL_STATUS_NO_MORE_RESOURCE

RAIL function could not allocate needed resource(s).

SL_RAIL_DMA_INVALID#

#define SL_RAIL_DMA_INVALID

(0xFFU)

A value to signal that RAIL should not use DMA.

SL_RAIL_TIMER_SYNC_PRS_CHANNEL_DEFAULT#

#define SL_RAIL_TIMER_SYNC_PRS_CHANNEL_DEFAULT

(255U)

Platform-agnostic value to use default PRS channel when configuring sleep.

SL_RAIL_TIMER_SYNC_RTCC_CHANNEL_DEFAULT#

#define SL_RAIL_TIMER_SYNC_RTCC_CHANNEL_DEFAULT

(255U)

Platform-agnostic vlaue to use default RTCC channel when configuring sleep.

SL_RAIL_TIMER_SYNC_DEFAULT#

#define SL_RAIL_TIMER_SYNC_DEFAULT

Default timer synchronization configuration.

SL_RAIL_SCHEDULER_STATUS_MASK#

#define SL_RAIL_SCHEDULER_STATUS_MASK

0x0FU

Radio Scheduler Status mask within sl_rail_scheduler_status_t values.

SL_RAIL_SCHEDULER_STATUS_SHIFT#

#define SL_RAIL_SCHEDULER_STATUS_SHIFT

0

Radio Scheduler Status shift within sl_rail_scheduler_status_t values.

SL_RAIL_SCHEDULER_TASK_MASK#

#define SL_RAIL_SCHEDULER_TASK_MASK

0xF0U

Radio Scheduler Task mask within sl_rail_scheduler_status_t values.

SL_RAIL_SCHEDULER_TASK_SHIFT#

#define SL_RAIL_SCHEDULER_TASK_SHIFT

4

Radio Scheduler Task shift within sl_rail_scheduler_status_t values.

SL_RAIL_EVENTS_NONE#

#define SL_RAIL_EVENTS_NONE

0ULL

A value representing no events.

SL_RAIL_EVENT_RSSI_AVERAGE_DONE#

#define SL_RAIL_EVENT_RSSI_AVERAGE_DONE

(1ULL << SL_RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT)

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

Call sl_rail_get_average_rssi() to get the result.

SL_RAIL_EVENT_RX_ACK_TIMEOUT#

#define SL_RAIL_EVENT_RX_ACK_TIMEOUT

(1ULL << SL_RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT)

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

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

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

SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL#

#define SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL

(1ULL << SL_RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)

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

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

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

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

2. Increase FIFO threshold

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

SL_RAIL_EVENT_RX_PACKET_RECEIVED#

#define SL_RAIL_EVENT_RX_PACKET_RECEIVED

(1ULL << SL_RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT)

Occurs whenever a packet is received with SL_RAIL_RX_PACKET_READY_SUCCESS or SL_RAIL_RX_PACKET_READY_CRC_ERROR.

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

SL_RAIL_EVENT_RX_PREAMBLE_LOST#

#define SL_RAIL_EVENT_RX_PREAMBLE_LOST

(1ULL << SL_RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT)

Occurs when the radio has lost a preamble.

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

Note

• See warning for SL_RAIL_EVENT_RX_PREAMBLE_DETECT.

SL_RAIL_EVENT_RX_PREAMBLE_DETECT#

#define SL_RAIL_EVENT_RX_PREAMBLE_DETECT

(1ULL << SL_RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT)

Occurs when the radio has detected a preamble.

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

Warnings

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

SL_RAIL_EVENT_RX_SYNC_0_DETECT#

#define SL_RAIL_EVENT_RX_SYNC_0_DETECT

(1ULL << SL_RAIL_EVENT_RX_SYNC_0_DETECT_SHIFT)

Occurs when the primary sync word is detected.

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

SL_RAIL_EVENT_RX_SYNC_1_DETECT#

#define SL_RAIL_EVENT_RX_SYNC_1_DETECT

(1ULL << SL_RAIL_EVENT_RX_SYNC_1_DETECT_SHIFT)

Occurs when the alternate sync word is detected.

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

SL_RAIL_EVENT_RX_FRAME_ERROR#

#define SL_RAIL_EVENT_RX_FRAME_ERROR

(1ULL << SL_RAIL_EVENT_RX_FRAME_ERROR_SHIFT)

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

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

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

SL_RAIL_EVENT_RX_FIFO_FULL#

#define SL_RAIL_EVENT_RX_FIFO_FULL

(1ULL << SL_RAIL_EVENT_RX_FIFO_FULL_SHIFT)

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

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

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

SL_RAIL_EVENT_RX_FIFO_OVERFLOW#

#define SL_RAIL_EVENT_RX_FIFO_OVERFLOW

(1ULL << SL_RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT)

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

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

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

SL_RAIL_EVENT_RX_ADDRESS_FILTERED#

#define SL_RAIL_EVENT_RX_ADDRESS_FILTERED

(1ULL << SL_RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT)

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

This event can only occur after calling sl_rail_enable_address_filter().

SL_RAIL_EVENT_RX_TIMEOUT#

#define SL_RAIL_EVENT_RX_TIMEOUT

(1ULL << SL_RAIL_EVENT_RX_TIMEOUT_SHIFT)

Occurs when an RX event times out.

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

SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED#

#define SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED

(1ULL << SL_RAIL_EVENT_RX_SCHEDULED_RX_STARTED_SHIFT)

Occurs when a scheduled RX begins turning on the receiver.

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

SL_RAIL_EVENT_RX_BLOCKED#

#define SL_RAIL_EVENT_RX_BLOCKED

(1ULL << SL_RAIL_EVENT_RX_BLOCKED_SHIFT)

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

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

SL_RAIL_EVENT_RX_SCHEDULED_RX_END#

#define SL_RAIL_EVENT_RX_SCHEDULED_RX_END

(1ULL << SL_RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT)

Occurs when the scheduled RX window ends.

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

Note

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

SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED#

#define SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED

(1ULL << SL_RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT)

Occurs when start of a scheduled receive is missed.

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

SL_RAIL_EVENT_RX_PACKET_ABORTED#

#define SL_RAIL_EVENT_RX_PACKET_ABORTED

(1ULL << SL_RAIL_EVENT_RX_PACKET_ABORTED_SHIFT)

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

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

SL_RAIL_EVENT_RX_FILTER_PASSED#

#define SL_RAIL_EVENT_RX_FILTER_PASSED

(1ULL << SL_RAIL_EVENT_RX_FILTER_PASSED_SHIFT)

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

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

SL_RAIL_EVENT_RX_TIMING_LOST#

#define SL_RAIL_EVENT_RX_TIMING_LOST

(1ULL << SL_RAIL_EVENT_RX_TIMING_LOST_SHIFT)

Occurs when the modem timing is lost.

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

Note

• See warning for SL_RAIL_EVENT_RX_TIMING_DETECT.

SL_RAIL_EVENT_RX_TIMING_DETECT#

#define SL_RAIL_EVENT_RX_TIMING_DETECT

(1ULL << SL_RAIL_EVENT_RX_TIMING_DETECT_SHIFT)

Occurs when the modem timing is detected.

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

Warnings

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

SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE#

#define SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE

(1ULL << SL_RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT)

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

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

SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END#

#define SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END

(1ULL << SL_RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT)

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

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

SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND#

#define SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND

(1ULL << SL_RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT)

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

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

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

SL_RAIL_EVENT_ZWAVE_BEAM#

#define SL_RAIL_EVENT_ZWAVE_BEAM

(1ULL << SL_RAIL_EVENT_ZWAVE_BEAM_SHIFT)

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

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

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

Note

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

SL_RAIL_EVENT_MFM_TX_BUFFER_DONE#

#define SL_RAIL_EVENT_MFM_TX_BUFFER_DONE

(1ULL << SL_RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT)

Indicate a MFM buffer has completely transmitted.

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

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

SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND#

#define SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND

(1ULL << SL_RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT)

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

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

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

SL_RAIL_EVENTS_RX_COMPLETION#

#define SL_RAIL_EVENTS_RX_COMPLETION

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

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

SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY#

#define SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY

(1ULL << SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT)

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

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

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

SL_RAIL_EVENT_TX_PACKET_SENT#

#define SL_RAIL_EVENT_TX_PACKET_SENT

(1ULL << SL_RAIL_EVENT_TX_PACKET_SENT_SHIFT)

Occurs after a packet has been transmitted.

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

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

SL_RAIL_EVENT_TXACK_PACKET_SENT#

#define SL_RAIL_EVENT_TXACK_PACKET_SENT

(1ULL << SL_RAIL_EVENT_TXACK_PACKET_SENT_SHIFT)

Occurs after an Ack packet has been transmitted.

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

Note

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

SL_RAIL_EVENT_TX_ABORTED#

#define SL_RAIL_EVENT_TX_ABORTED

(1ULL << SL_RAIL_EVENT_TX_ABORTED_SHIFT)

Occurs when a transmit is aborted by the user.

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

Note

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

SL_RAIL_EVENT_TXACK_ABORTED#

#define SL_RAIL_EVENT_TXACK_ABORTED

(1ULL << SL_RAIL_EVENT_TXACK_ABORTED_SHIFT)

Occurs when an Ack transmit is aborted by the user.

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

SL_RAIL_EVENT_TX_BLOCKED#

#define SL_RAIL_EVENT_TX_BLOCKED

(1ULL << SL_RAIL_EVENT_TX_BLOCKED_SHIFT)

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

Note

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

SL_RAIL_EVENT_TXACK_BLOCKED#

#define SL_RAIL_EVENT_TXACK_BLOCKED

(1ULL << SL_RAIL_EVENT_TXACK_BLOCKED_SHIFT)

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

This event can only occur after calling sl_rail_config_auto_ack().

SL_RAIL_EVENT_TX_UNDERFLOW#

#define SL_RAIL_EVENT_TX_UNDERFLOW

(1ULL << SL_RAIL_EVENT_TX_UNDERFLOW_SHIFT)

Occurs when the transmit buffer underflows.

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

Note

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

SL_RAIL_EVENT_TXACK_UNDERFLOW#

#define SL_RAIL_EVENT_TXACK_UNDERFLOW

(1ULL << SL_RAIL_EVENT_TXACK_UNDERFLOW_SHIFT)

Occurs when the Ack transmit buffer underflows.

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

This event can only occur after calling sl_rail_config_auto_ack().

SL_RAIL_EVENT_TX_CHANNEL_CLEAR#

#define SL_RAIL_EVENT_TX_CHANNEL_CLEAR

(1ULL << SL_RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT)

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

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

SL_RAIL_EVENT_TX_CHANNEL_BUSY#

#define SL_RAIL_EVENT_TX_CHANNEL_BUSY

(1ULL << SL_RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT)

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

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

Note

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

SL_RAIL_EVENT_TX_CCA_RETRY#

#define SL_RAIL_EVENT_TX_CCA_RETRY

(1ULL << SL_RAIL_EVENT_TX_CCA_RETRY_SHIFT)

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

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

SL_RAIL_EVENT_TX_START_CCA#

#define SL_RAIL_EVENT_TX_START_CCA

(1ULL << SL_RAIL_EVENT_TX_START_CCA_SHIFT)

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

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

SL_RAIL_EVENT_TX_CCA_ACTIVATED#

#define SL_RAIL_EVENT_TX_CCA_ACTIVATED

(1ULL << SL_RAIL_EVENT_TX_CCA_ACTIVATED_SHIFT)

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

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

Note

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

SL_RAIL_EVENT_TX_STARTED#

#define SL_RAIL_EVENT_TX_STARTED

(1ULL << SL_RAIL_EVENT_TX_STARTED_SHIFT)

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

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

Note

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

SL_RAIL_TX_STARTED_BYTES#

#define SL_RAIL_TX_STARTED_BYTES

0U

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

SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED#

#define SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED

(1ULL << SL_RAIL_EVENT_TX_SCHEDULED_TX_STARTED_SHIFT)

Occurs when a scheduled TX begins turning on the transmitter.

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

SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED#

#define SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED

(1ULL << SL_RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT)

Occurs when the start of a scheduled transmit is missed.

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

Note

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

SL_RAIL_EVENTS_TX_COMPLETION#

#define SL_RAIL_EVENTS_TX_COMPLETION

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

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

SL_RAIL_EVENTS_TXACK_COMPLETION#

#define SL_RAIL_EVENTS_TXACK_COMPLETION

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

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

SL_RAIL_EVENT_CONFIG_UNSCHEDULED#

#define SL_RAIL_EVENT_CONFIG_UNSCHEDULED

(1ULL << SL_RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT)

Occurs when the scheduler switches away from this configuration.

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

Note

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

SL_RAIL_EVENT_CONFIG_SCHEDULED#

#define SL_RAIL_EVENT_CONFIG_SCHEDULED

(1ULL << SL_RAIL_EVENT_CONFIG_SCHEDULED_SHIFT)

Occurs when the scheduler switches to this configuration.

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

Note

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

SL_RAIL_EVENT_SCHEDULER_STATUS#

#define SL_RAIL_EVENT_SCHEDULER_STATUS

(1ULL << SL_RAIL_EVENT_SCHEDULER_STATUS_SHIFT)

Occurs when the scheduler has a status to report.

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

Note

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

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

SL_RAIL_EVENT_CAL_NEEDED#

#define SL_RAIL_EVENT_CAL_NEEDED

(1ULL << SL_RAIL_EVENT_CAL_NEEDED_SHIFT)

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

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

SL_RAIL_EVENT_RF_SENSED#

#define SL_RAIL_EVENT_RF_SENSED

(1ULL << SL_RAIL_EVENT_RF_SENSED_SHIFT)

Occurs when RF energy is sensed from the radio.

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

Note

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

SL_RAIL_EVENT_PA_PROTECTION#

#define SL_RAIL_EVENT_PA_PROTECTION

(1ULL << SL_RAIL_EVENT_PA_PROTECTION_SHIFT)

Occurs when PA protection circuit kicks in.

SL_RAIL_EVENT_SIGNAL_DETECTED#

#define SL_RAIL_EVENT_SIGNAL_DETECTED

(1ULL << SL_RAIL_EVENT_SIGNAL_DETECTED_SHIFT)

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

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

SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START#

#define SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START

(1ULL << SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_START_SHIFT)

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

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

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

Only available on platforms where SL_RAIL_IEEE802154_SUPPORTS_G_MODE_SWITCH is true.

SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END#

#define SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END

(1ULL << SL_RAIL_EVENT_IEEE802154_MODE_SWITCH_END_SHIFT)

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

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

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

Only available on platforms where SL_RAIL_IEEE802154_SUPPORTS_G_MODE_SWITCH is true.

SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD#

#define SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD

(1ULL << SL_RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT)

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

SL_RAIL_EVENT_THERMISTOR_DONE#

#define SL_RAIL_EVENT_THERMISTOR_DONE

(1ULL << SL_RAIL_EVENT_THERMISTOR_DONE_SHIFT)

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

SL_RAIL_EVENT_RESERVED_49#

#define SL_RAIL_EVENT_RESERVED_49

(1ULL << SL_RAIL_EVENT_RESERVED_49_SHIFT)

Reserved for possible future use.

SL_RAIL_EVENT_TEMPERATURE_TOO_HOT#

#define SL_RAIL_EVENT_TEMPERATURE_TOO_HOT

(1ULL << SL_RAIL_EVENT_TEMPERATURE_TOO_HOT_SHIFT)

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

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

Only occurs on platforms where SL_RAIL_SUPPORTS_THERMAL_PROTECTION is true.

SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN#

#define SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN

(1ULL << SL_RAIL_EVENT_TEMPERATURE_COOL_DOWN_SHIFT)

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

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

Only occurs on platforms where SL_RAIL_SUPPORTS_THERMAL_PROTECTION is true.

SL_RAIL_EVENT_USER_MBOX#

#define SL_RAIL_EVENT_USER_MBOX

(1ULL << SL_RAIL_EVENT_USER_MBOX_SHIFT)

Occurs when the user received a mailbox message.

SL_RAIL_EVENTS_ALL#

#define SL_RAIL_EVENTS_ALL

0xFFFFFFFFFFFFFFFFULL

A value representing all possible events.

SL_RAIL_DECLARE_FIFO_BUFFER#

#define SL_RAIL_DECLARE_FIFO_BUFFER

(buffer_name, bytes)

Convenience macro for declaring RAIL FIFO buffers of desired size.

For example:

#define MY_RX_FIFO_BUFFER_BYTES 512
union my_rx_fifo_buffer_u {
  SL_RAIL_DECLARE_FIFO_BUFFER(aligned, MY_RX_FIFO_BUFFER_BYTES);
  uint8_t bytes[MY_RX_FIFO_BUFFER_BYTES]; // For byte accessing
} my_rx_fifo_buffer;

sl_rail_config_t my_rail_config = {
  .rx_fifo_bytes = sizeof(my_rx_fifo_buffer),
  .rx_fifo_buffer = my_rx_fifo_buffer.aligned,
  ...
};
#define MY_RX_FIFO_BUFFER_BYTES 512
union my_rx_fifo_buffer_u {
  SL_RAIL_DECLARE_FIFO_BUFFER(aligned, MY_RX_FIFO_BUFFER_BYTES);
  uint8_t bytes[MY_RX_FIFO_BUFFER_BYTES]; // For byte accessing
} my_rx_fifo_buffer;

sl_rail_config_t my_rail_config = {
  .rx_fifo_bytes = sizeof(my_rx_fifo_buffer),
  .rx_fifo_buffer = my_rx_fifo_buffer.aligned,
  ...
};

SL_RAIL_MINIMUM_FIFO_BYTES#

#define SL_RAIL_MINIMUM_FIFO_BYTES

(64U)

The minimum size in bytes of a receive / transmit / Auto-Ack FIFO.

SL_RAIL_MAXIMUM_FIFO_BYTES#

#define SL_RAIL_MAXIMUM_FIFO_BYTES

(4096U)

The maximum size in bytes of a receive / transmit / Auto-Ack FIFO.

SL_RAIL_FIFO_THRESHOLD_DISABLED#

#define SL_RAIL_FIFO_THRESHOLD_DISABLED

0xFFFFU

A FIFO threshold value that disables the threshold.

SL_RAIL_TX_POWER_MAX#

#define SL_RAIL_TX_POWER_MAX

((sl_rail_tx_power_t)0x7FFF)

The maximum valid value for a sl_rail_tx_power_t.

SL_RAIL_TX_POWER_MIN#

#define SL_RAIL_TX_POWER_MIN

((sl_rail_tx_power_t)0x8000)

The minimum valid value for a sl_rail_tx_power_t.

SL_RAIL_TX_POWER_CURVE_DEFAULT_MAX#

#define SL_RAIL_TX_POWER_CURVE_DEFAULT_MAX

((sl_rail_tx_power_t)200)

The maximum power in deci-dBm the curve supports.

SL_RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT#

#define SL_RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT

((sl_rail_tx_power_t)40)

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

SL_RAIL_TX_POWER_VOLTAGE_SCALING_FACTOR#

#define SL_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.

SL_RAIL_TX_POWER_DBM_SCALING_FACTOR#

#define SL_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.

SL_RAIL_TX_PA_POWER_SETTING_UNSUPPORTED#

#define SL_RAIL_TX_PA_POWER_SETTING_UNSUPPORTED

(0U)

An unsupported power setting used with the PA Power Conversions component.

when the device does not support the dBm to power setting mapping table.

SL_RAIL_TX_POWER_MODE_NAMES#

#define SL_RAIL_TX_POWER_MODE_NAMES

The names of the TX power modes.

A list of the names for the TX power modes on EFR32 parts. This macro is useful for test applications and debugging output.

SL_RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_OFDM#

#define SL_RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_OFDM

(x)

Convenience macro for any OFDM mapping table mode.

SL_RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_SUB_GHZ#

#define SL_RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_SUB_GHZ

(x)

Convenience macro for any Sub-GHz mapping table mode.

SL_RAIL_POWER_MODE_IS_ANY_OFDM#

#define SL_RAIL_POWER_MODE_IS_ANY_OFDM

(x)

Convenience macro for any OFDM mode.

SL_RAIL_SET_FIXED_LENGTH_INVALID#

#define SL_RAIL_SET_FIXED_LENGTH_INVALID

(0xFFFFU)

An invalid return value when calling sl_rail_set_fixed_length().

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

SL_RAIL_RADIO_CONFIG_ENABLE_CONC_PHY#

#define SL_RAIL_RADIO_CONFIG_ENABLE_CONC_PHY

1

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

Needed for backwards compatibility.

SL_RAIL_RADIO_CONFIG_ENABLE_STACK_INFO#

#define SL_RAIL_RADIO_CONFIG_ENABLE_STACK_INFO

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

Needed for backwards compatibility.

SL_RAIL_CHANNEL_INVALID#

#define SL_RAIL_CHANNEL_INVALID

(0xFFFFU)

A value representing an invalid channel, used for APIs that return or output a channel when none can be identified.

SL_RAIL_TRANSITION_TIME_KEEP#

#define SL_RAIL_TRANSITION_TIME_KEEP

((sl_rail_transition_time_t) -1)

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

SL_RAIL_RF_STATE_DETAIL_INACTIVE#

#define SL_RAIL_RF_STATE_DETAIL_INACTIVE

(0U)

Radio is inactive.

SL_RAIL_RF_STATE_DETAIL_IDLE_STATE#

#define SL_RAIL_RF_STATE_DETAIL_IDLE_STATE

(1U << SL_RAIL_RF_STATE_DETAIL_IDLE_STATE_SHIFT)

Radio is in or headed to the idle state.

SL_RAIL_RF_STATE_DETAIL_RX_STATE#

#define SL_RAIL_RF_STATE_DETAIL_RX_STATE

(1U << SL_RAIL_RF_STATE_DETAIL_RX_STATE_SHIFT)

Radio is in or headed to the receive state.

SL_RAIL_RF_STATE_DETAIL_TX_STATE#

#define SL_RAIL_RF_STATE_DETAIL_TX_STATE

(1U << SL_RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT)

Radio is in or headed to the transmit state.

SL_RAIL_RF_STATE_DETAIL_TRANSITION#

#define SL_RAIL_RF_STATE_DETAIL_TRANSITION

(1U << SL_RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT)

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

SL_RAIL_RF_STATE_DETAIL_ACTIVE#

#define SL_RAIL_RF_STATE_DETAIL_ACTIVE

(1U << SL_RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT)

Radio is actively transmitting or receiving.

SL_RAIL_RF_STATE_DETAIL_NO_FRAMES#

#define SL_RAIL_RF_STATE_DETAIL_NO_FRAMES

(1U << SL_RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT)

Radio has frame detect disabled.

SL_RAIL_RF_STATE_DETAIL_LBT#

#define SL_RAIL_RF_STATE_DETAIL_LBT

(1U << SL_RAIL_RF_STATE_DETAIL_LBT_SHIFT)

LBT/CSMA operation is currently ongoing.

SL_RAIL_RF_STATE_DETAIL_CORE_STATE_MASK#

#define SL_RAIL_RF_STATE_DETAIL_CORE_STATE_MASK

Mask for core radio state bits.

SL_RAIL_CHANNEL_HOPPING_BUFFER_WORDS_PER_CHANNEL_WORST_CASE#

#define SL_RAIL_CHANNEL_HOPPING_BUFFER_WORDS_PER_CHANNEL_WORST_CASE

(65U)

The worst-case platform-agnostic static amount of memory needed per channel for channel hopping, measured in 32 bit words, regardless of the size of radio configuration structures.

SL_RAIL_STOP_MODES_NONE#

#define SL_RAIL_STOP_MODES_NONE

(0U)

Do not stop any radio operations.

SL_RAIL_STOP_MODE_ACTIVE#

#define SL_RAIL_STOP_MODE_ACTIVE

(1U << SL_RAIL_STOP_MODE_ACTIVE_SHIFT)

Stop active radio operations only.

SL_RAIL_STOP_MODE_PENDING#

#define SL_RAIL_STOP_MODE_PENDING

(1U << SL_RAIL_STOP_MODE_PENDING_SHIFT)

Stop pending radio operations.

SL_RAIL_STOP_MODES_ALL#

#define SL_RAIL_STOP_MODES_ALL

(0xFFU)

Stop all radio operations.

SL_RAIL_TX_OPTIONS_NONE#

#define SL_RAIL_TX_OPTIONS_NONE

0UL

A value representing no options enabled.

SL_RAIL_TX_OPTIONS_DEFAULT#

#define SL_RAIL_TX_OPTIONS_DEFAULT

SL_RAIL_TX_OPTIONS_NONE

All options disabled by default.

This is the fastest TX option to apply.

SL_RAIL_TX_OPTION_WAIT_FOR_ACK#

#define SL_RAIL_TX_OPTION_WAIT_FOR_ACK

(1UL << SL_RAIL_TX_OPTION_WAIT_FOR_ACK_SHIFT)

An option when Auto-Ack has been configured, enabled, and not TX paused, to configure whether or not the transmitting node will listen for an Ack response.

If this is false, the sl_rail_rx_packet_details_t::is_ack flag of a received packet will always be false. If Auto-Ack is enabled, for instance using sl_rail_config_auto_ack() or sl_rail_ieee802154_init(), and if this option is false, the radio transitions to sl_rail_auto_ack_config_t::tx_transitions's sl_rail_state_transitions_t::success state directly after transmitting a packet and does not wait for an Ack.

SL_RAIL_TX_OPTION_REMOVE_CRC#

#define SL_RAIL_TX_OPTION_REMOVE_CRC

(1UL << SL_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 SL_RAIL_RX_OPTION_IGNORE_CRC_ERRORS on the receive side.

SL_RAIL_TX_OPTION_SYNC_WORD_ID#

#define SL_RAIL_TX_OPTION_SYNC_WORD_ID

(1UL << SL_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 sl_rail_config_sync_words() enabling this option selects SYNC 1 rather than SYNC 0 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.

SL_RAIL_TX_OPTION_ANTENNA_0#

#define SL_RAIL_TX_OPTION_ANTENNA_0

(1UL << SL_RAIL_TX_OPTION_ANTENNA_0_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 sl_rail_config_antenna().

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.

SL_RAIL_TX_OPTION_ANTENNA_1#

#define SL_RAIL_TX_OPTION_ANTENNA_1

(1UL << SL_RAIL_TX_OPTION_ANTENNA_1_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 sl_rail_config_antenna().

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.

SL_RAIL_TX_OPTION_ALT_PREAMBLE_LEN#

#define SL_RAIL_TX_OPTION_ALT_PREAMBLE_LEN

(1UL << SL_RAIL_TX_OPTION_ALT_PREAMBLE_LEN_SHIFT)

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

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

SL_RAIL_TX_OPTION_CCA_ONLY#

#define SL_RAIL_TX_OPTION_CCA_ONLY

(1UL << SL_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: sl_rail_start_cca_csma_tx(), sl_rail_start_cca_lbt_tx(), sl_rail_start_scheduled_cca_csma_tx(), or sl_rail_start_scheduled_cca_lbt_tx().

Application can then use the SL_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 Auto-Ack response) is complete.

SL_RAIL_TX_OPTION_RESEND#

#define SL_RAIL_TX_OPTION_RESEND

(1UL << SL_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 sl_rail_set_tx_fifo() or sl_rail_write_tx_fifo() 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, sl_rail_tx_data_config_t::tx_method must be sl_rail_data_method_t::SL_RAIL_DATA_METHOD_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 sl_rail_set_next_tx_repeat() to cause the repeated packet(s) to all be the same as the first.

SL_RAIL_TX_OPTION_CONCURRENT_PHY_ID#

#define SL_RAIL_TX_OPTION_CONCURRENT_PHY_ID

(1UL << SL_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.

SL_RAIL_TX_OPTIONS_ALL#

#define SL_RAIL_TX_OPTIONS_ALL

0xFFFFFFFFUL

A value representing all possible options.

SL_RAIL_MAX_LBT_TRIES#

#define SL_RAIL_MAX_LBT_TRIES

(15U)

The maximum number of LBT/CSMA retries supported.

SL_RAIL_MAX_CSMA_EXPONENT#

#define SL_RAIL_MAX_CSMA_EXPONENT

(8U)

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

SL_RAIL_CSMA_CONFIG_802_15_4_2003_2P4_GHZ_OQPSK_CSMA#

#define SL_RAIL_CSMA_CONFIG_802_15_4_2003_2P4_GHZ_OQPSK_CSMA

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

SL_RAIL_CSMA_CONFIG_SINGLE_CCA#

#define SL_RAIL_CSMA_CONFIG_SINGLE_CCA

sl_rail_csma_config_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 cca_backoff_us with a fixed delay on each use.

SL_RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1#

#define SL_RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1

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

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

SL_RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0#

#define SL_RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0

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

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

SL_RAIL_TX_REPEAT_OPTIONS_NONE#

#define SL_RAIL_TX_REPEAT_OPTIONS_NONE

0U

A value representing no repeat options enabled.

SL_RAIL_TX_REPEAT_OPTIONS_DEFAULT#

#define SL_RAIL_TX_REPEAT_OPTIONS_DEFAULT

SL_RAIL_TX_REPEAT_OPTIONS_NONE

All repeat options disabled by default.

SL_RAIL_TX_REPEAT_OPTION_HOP#

#define SL_RAIL_TX_REPEAT_OPTION_HOP

(1U << SL_RAIL_TX_REPEAT_OPTION_HOP_SHIFT)

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

SL_RAIL_TX_REPEAT_OPTION_START_TO_START#

#define SL_RAIL_TX_REPEAT_OPTION_START_TO_START

(1 << SL_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.

SL_RAIL_TX_REPEAT_INFINITE_ITERATIONS#

#define SL_RAIL_TX_REPEAT_INFINITE_ITERATIONS

(0xFFFFU)

sl_rail_tx_repeat_config_t::iterations initializer configuring infinite repeated transmissions.

SL_RAIL_ADDR_CONFIG_MATCH_TABLE_SINGLE_FIELD#

#define SL_RAIL_ADDR_CONFIG_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.

SL_RAIL_ADDR_CONFIG_MATCH_TABLE_DOUBLE_FIELD#

#define SL_RAIL_ADDR_CONFIG_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.

SL_RAIL_ADDR_CONFIG_MAX_ADDRESS_FIELDS#

#define SL_RAIL_ADDR_CONFIG_MAX_ADDRESS_FIELDS

(2)

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

SL_RAIL_RX_OPTIONS_NONE#

#define SL_RAIL_RX_OPTIONS_NONE

0

A value representing no options enabled.

SL_RAIL_RX_OPTIONS_DEFAULT#

#define SL_RAIL_RX_OPTIONS_DEFAULT

SL_RAIL_RX_OPTIONS_NONE

All options are disabled by default.

SL_RAIL_RX_OPTION_STORE_CRC#

#define SL_RAIL_RX_OPTION_STORE_CRC

(1UL << SL_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.

SL_RAIL_RX_OPTION_IGNORE_CRC_ERRORS#

#define SL_RAIL_RX_OPTION_IGNORE_CRC_ERRORS

(1UL << SL_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 sl_rail_auto_ack_config_t::ack_timeout_us period.

SL_RAIL_RX_OPTION_ENABLE_DUAL_SYNC#

#define SL_RAIL_RX_OPTION_ENABLE_DUAL_SYNC

(1UL << SL_RAIL_RX_OPTION_ENABLE_DUAL_SYNC_SHIFT)

An option to control which sync words will be accepted.

Setting it to 0 (default) will cause the receiver to listen for SYNC 0 only. Setting it to 1 causes the receiver to listen for either SYNC 0 or SYNC 1. 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 SL_RAIL_SUPPORTS_DUAL_SYNC_WORDS or the runtime call sl_rail_supports_dual_sync_words() to check whether the platform supports this feature. Also, dual sync 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.

SL_RAIL_RX_OPTION_TRACK_ABORTED_FRAMES#

#define SL_RAIL_RX_OPTION_TRACK_ABORTED_FRAMES

(1UL << SL_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 SL_RAIL_IDLE_FORCE_SHUTDOWN or SL_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.

SL_RAIL_RX_OPTION_REMOVE_APPENDED_INFO#

#define SL_RAIL_RX_OPTION_REMOVE_APPENDED_INFO

(1UL << SL_RAIL_RX_OPTION_REMOVE_APPENDED_INFO_SHIFT)

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

Defaults to false. When suppressed, certain sl_rail_rx_packet_details_t details will not be available for received packets whose sl_rail_rx_packet_status_t is among the SL_RAIL_RX_PACKET_READY_ set.

Warnings

• This option should be changed only when the radio is idle and the receive FIFO and Packet Queue are empty or have been reset, otherwise sl_rail_get_rx_packet_info() and sl_rail_get_rx_packet_details() may think appended info is packet data or vice-versa.

SL_RAIL_RX_OPTION_ANTENNA_0#

#define SL_RAIL_RX_OPTION_ANTENNA_0

(1UL << SL_RAIL_RX_OPTION_ANTENNA_0_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 sl_rail_config_antenna().

SL_RAIL_RX_OPTION_ANTENNA_1#

#define SL_RAIL_RX_OPTION_ANTENNA_1

(1UL << SL_RAIL_RX_OPTION_ANTENNA_1_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 sl_rail_config_antenna().

SL_RAIL_RX_OPTION_ANTENNA_AUTO#

#define SL_RAIL_RX_OPTION_ANTENNA_AUTO

(SL_RAIL_RX_OPTION_ANTENNA_0 | SL_RAIL_RX_OPTION_ANTENNA_1)

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

SL_RAIL_RX_OPTION_DISABLE_FRAME_DETECTION#

#define SL_RAIL_RX_OPTION_DISABLE_FRAME_DETECTION

(1UL << SL_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.

SL_RAIL_RX_OPTION_CHANNEL_SWITCHING#

#define SL_RAIL_RX_OPTION_CHANNEL_SWITCHING

(1U << SL_RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT)

An option to enable IEEE 802.15.4 RX channel switching.

See sl_rail_ieee802154_config_rx_channel_switching() for more information. Defaults to false.

Note

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

• This option overrides SL_RAIL_RX_OPTION_ANTENNA_0, SL_RAIL_RX_OPTION_ANTENNA_1 and SL_RAIL_RX_OPTION_ANTENNA_AUTO antenna selection options.

SL_RAIL_RX_OPTION_FAST_RX_TO_RX#

#define SL_RAIL_RX_OPTION_FAST_RX_TO_RX

(1U << SL_RAIL_RX_OPTION_FAST_RX_TO_RX_SHIFT)

An option to enable fast RX-to-RX 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 SL_RAIL_SUPPORTS_FAST_RX_TO_RX is true.

SL_RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION#

#define SL_RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION

(1U << SL_RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION_SHIFT)

An option to enable collision detection.

Once enabled, when a collision with a strong enough packet is detected, the demod will stop the current packet decoding and try to detect the preamble of the incoming packet.

Note

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

SL_RAIL_RX_OPTIONS_ALL#

#define SL_RAIL_RX_OPTIONS_ALL

0xFFFFFFFFUL

A value representing all possible options.

SL_RAIL_RSSI_INVALID_DBM#

#define SL_RAIL_RSSI_INVALID_DBM

(-128)

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

SL_RAIL_RSSI_INVALID#

#define SL_RAIL_RSSI_INVALID

((int16_t)(SL_RAIL_RSSI_INVALID_DBM * 4))

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

SL_RAIL_RSSI_LOWEST#

#define SL_RAIL_RSSI_LOWEST

((int16_t)(SL_RAIL_RSSI_INVALID + 1))

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

SL_RAIL_RSSI_OFFSET_MAX#

#define SL_RAIL_RSSI_OFFSET_MAX

35

Maximum absolute value for RSSI offset.

SL_RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT#

#define SL_RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT

((sl_rail_time_t)0xFFFFFFFFU)

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

SL_RAIL_GET_RSSI_NO_WAIT#

#define SL_RAIL_GET_RSSI_NO_WAIT

((sl_rail_time_t)0U)

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

SL_RAIL_RX_PACKET_HANDLE_INVALID#

#define SL_RAIL_RX_PACKET_HANDLE_INVALID

(NULL)

An invalid RX packet handle value.

SL_RAIL_RX_PACKET_HANDLE_OLDEST#

#define SL_RAIL_RX_PACKET_HANDLE_OLDEST

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

SL_RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE#

#define SL_RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE

((sl_rail_rx_packet_handle_t) 2)

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

This never includes incomplete or unstarted packets. (Using SL_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.)

SL_RAIL_RX_PACKET_HANDLE_NEWEST#

#define SL_RAIL_RX_PACKET_HANDLE_NEWEST

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

SL_RAIL_DEFAULT_AUTO_ACK_FIFO_BYTES#

#define SL_RAIL_DEFAULT_AUTO_ACK_FIFO_BYTES

SL_RAIL_MINIMUM_FIFO_BYTES

The default size in bytes of the built-in per-protocol Auto-Ack FIFO.

SL_RAIL_INVALID_THERMISTOR_VALUE#

#define SL_RAIL_INVALID_THERMISTOR_VALUE

(0xFFFFFFFFU)

A sentinel value to indicate an invalid thermistor measurement value.

SL_RAIL_INVALID_PPM_VALUE#

#define SL_RAIL_INVALID_PPM_VALUE

(-128)

A sentinel value to indicate an invalid PPM calculation value.

SL_RAIL_CAL_TEMP_VCO#

#define SL_RAIL_CAL_TEMP_VCO

(0x00000001U)

EFR32-specific temperature calibration bit.

SL_RAIL_CAL_TEMP_HFXO#

#define SL_RAIL_CAL_TEMP_HFXO

(0x00000002U)

EFR32-specific HFXO temperature check bit.

(Ignored if platform lacks SL_RAIL_SUPPORTS_HFXO_COMPENSATION.)

SL_RAIL_CAL_COMPENSATE_HFXO#

#define SL_RAIL_CAL_COMPENSATE_HFXO

(0x00000004U)

EFR32-specific HFXO compensation bit.

(Ignored if platform lacks SL_RAIL_SUPPORTS_HFXO_COMPENSATION.)

SL_RAIL_CAL_RX_IR_CAL#

#define SL_RAIL_CAL_RX_IR_CAL

(0x00010000U)

EFR32-specific IR calibration bit.

SL_RAIL_CAL_OFDM_TX_IR_CAL#

#define SL_RAIL_CAL_OFDM_TX_IR_CAL

(0x00100000U)

EFR32-specific Tx IR calibration bit.

(Ignored if platform lacks SL_RAIL_SUPPORTS_OFDM_PA.)

SL_RAIL_CAL_ONETIME_IR_CAL#

#define SL_RAIL_CAL_ONETIME_IR_CAL

(SL_RAIL_CAL_RX_IR_CAL | SL_RAIL_CAL_OFDM_TX_IR_CAL)

A mask to run EFR32-specific IR calibrations.

SL_RAIL_CAL_TEMP#

#define SL_RAIL_CAL_TEMP

(SL_RAIL_CAL_TEMP_VCO | SL_RAIL_CAL_TEMP_HFXO | SL_RAIL_CAL_COMPENSATE_HFXO)

A mask to run temperature-dependent calibrations.

SL_RAIL_CAL_ONETIME#

#define SL_RAIL_CAL_ONETIME

(SL_RAIL_CAL_ONETIME_IR_CAL)

A mask to run one-time calibrations.

SL_RAIL_CAL_PERF#

#define SL_RAIL_CAL_PERF

(0)

A mask to run optional performance calibrations.

SL_RAIL_CAL_OFFLINE#

#define SL_RAIL_CAL_OFFLINE

(SL_RAIL_CAL_ONETIME_IR_CAL)

A mask for calibrations that require the radio to be off.

SL_RAIL_CAL_ALL#

#define SL_RAIL_CAL_ALL

(SL_RAIL_CAL_TEMP | SL_RAIL_CAL_ONETIME)

A mask to run all possible calibrations for this chip.

SL_RAIL_CAL_ALL_PENDING#

#define SL_RAIL_CAL_ALL_PENDING

(0x00000000U)

A mask to run all pending calibrations.

SL_RAIL_CAL_INVALID_VALUE#

#define SL_RAIL_CAL_INVALID_VALUE

(0xFFFFFFFFU)

An invalid calibration value.

SL_RAIL_MAX_RF_PATHS#

#define SL_RAIL_MAX_RF_PATHS

2

Indicates the maximum number of RF Paths supported across all platforms.

SL_RAIL_RX_IR_CAL_VALUES_UNINIT#

#define SL_RAIL_RX_IR_CAL_VALUES_UNINIT

A define to set all sl_rail_rx_ir_cal_values_t values to uninitialized.

This define can be used when you have no data to pass to the calibration routines but wish to compute and save all possible calibrations.

SL_RAIL_TX_IR_CAL_VALUES_UNINIT#

#define SL_RAIL_TX_IR_CAL_VALUES_UNINIT

A define to set all sl_rail_tx_ir_cal_values_t values to uninitialized.

This define can be used when you have no data to pass to the calibration routines but wish to compute and save all possible calibrations.

SL_RAIL_IR_CAL_VALUES_UNINIT#

#define SL_RAIL_IR_CAL_VALUES_UNINIT

A define to set all sl_rail_ir_cal_values_t values to uninitialized.

This define can be used when you have no data to pass to the calibration routines but wish to compute and save all possible calibrations.

SL_RAIL_IR_CAL_VAL#

#define SL_RAIL_IR_CAL_VAL

(ir_cal_struct, rf_path)

A define allowing Rx calibration value access compatibility between non-OFDM and OFDM platforms.

SL_RAIL_CAL_VALUES_UNINIT#

#define SL_RAIL_CAL_VALUES_UNINIT

SL_RAIL_IR_CAL_VALUES_UNINIT

A define to set all sl_rail_cal_values_t values to uninitialized.

This define can be used when you have no data to pass to the calibration routines but wish to compute and save all possible calibrations.

SL_RAIL_RF_SENSE_LOW_SENSITIVITY_OFFSET#

#define SL_RAIL_RF_SENSE_LOW_SENSITIVITY_OFFSET

(0x20U)

RF Sense low sensitivity offset.

SL_RAIL_RF_SENSE_USE_HW_SYNC_WORD#

#define SL_RAIL_RF_SENSE_USE_HW_SYNC_WORD

(0U)

Use the MODEM default sync word.

SL_RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US#

#define SL_RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US

0x08000000UL

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

SL_RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE#

#define SL_RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE

0U

A value representing no options enabled.

SL_RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT#

#define SL_RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT

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

SL_RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL#

#define SL_RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL

(1U << SL_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.

SL_RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL#

#define SL_RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL

(1U << SL_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.

SL_RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD#

#define SL_RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD

(1U << SL_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 sl_rail_rx_channel_hopping_config_entry_t::rssi_threshold_dbm.

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

SL_RAIL_RX_CHANNEL_HOPPING_OPTION_STOP#

#define SL_RAIL_RX_CHANNEL_HOPPING_OPTION_STOP

(1U << SL_RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT)

An option to stop the hopping sequence at this entry in the hop table, which also idles the radio.

Intended only for testing purposes and not supported on EFR32xG21.

SL_RAIL_CHANNEL_HOPPING_INVALID_INDEX#

#define SL_RAIL_CHANNEL_HOPPING_INVALID_INDEX

(0xFEU)

A sentinel value to flag an invalid channel hopping index.

SL_RAIL_FREQUENCY_OFFSET_MAX#

#define SL_RAIL_FREQUENCY_OFFSET_MAX

((sl_rail_frequency_offset_t) 0x3FFF)

The maximum frequency offset value supported.

SL_RAIL_FREQUENCY_OFFSET_MIN#

#define SL_RAIL_FREQUENCY_OFFSET_MIN

((sl_rail_frequency_offset_t) -SL_RAIL_FREQUENCY_OFFSET_MAX)

The minimum frequency offset value supported.

SL_RAIL_FREQUENCY_OFFSET_INVALID#

#define SL_RAIL_FREQUENCY_OFFSET_INVALID

((sl_rail_frequency_offset_t) 0x8000)

Specify an invalid frequency offset value.

This will be returned if you call sl_rail_get_rx_freq_offset() at an invalid time.

SL_RAIL_VDET_MODE_ENUM_NAMES#

#define SL_RAIL_VDET_MODE_ENUM_NAMES

A macro that is string versions of the calibration enums.

SL_RAIL_VDET_RESOLUTION_ENUM_NAMES#

#define SL_RAIL_VDET_RESOLUTION_ENUM_NAMES

A macro that is string versions of the resolution enums.

SL_RAIL_VDET_STATUS_ENUM_NAMES#

#define SL_RAIL_VDET_STATUS_ENUM_NAMES

A macro that is string versions of the status enums.

SL_RAIL_CHIP_TEMP_THRESHOLD_MAX#

#define SL_RAIL_CHIP_TEMP_THRESHOLD_MAX

(398U)

Maximum junction temperature in Kelvin.

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

SL_RAIL_CHIP_TEMP_COOLDOWN_DEFAULT#

#define SL_RAIL_CHIP_TEMP_COOLDOWN_DEFAULT

(7U)

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

SL_RAIL_CHIP_TEMP_MEASURE_COUNT#

#define SL_RAIL_CHIP_TEMP_MEASURE_COUNT

(3U)

Number of temperature values provided for the chip thermal protection.

SL_RAIL_RETIME_OPTION_HFXO#

#define SL_RAIL_RETIME_OPTION_HFXO

  (1U << SL_RAIL_RETIME_OPTION_HFXO_SHIFT)

An option to configure HFXO retiming.

SL_RAIL_RETIME_OPTION_HFRCO#

#define SL_RAIL_RETIME_OPTION_HFRCO

  (1U << SL_RAIL_RETIME_OPTION_HFRCO_SHIFT)

An option to configure HFRCO retiming.

SL_RAIL_RETIME_OPTION_DCDC#

#define SL_RAIL_RETIME_OPTION_DCDC

  (1U << SL_RAIL_RETIME_OPTION_DCDC_SHIFT)

An option to configure DCDC retiming.

Ignored on platforms that lack DCDC.

SL_RAIL_RETIME_OPTION_LCD#

#define SL_RAIL_RETIME_OPTION_LCD

  (1U << SL_RAIL_RETIME_OPTION_LCD_SHIFT)

An option to configure LCD retiming.

Ignored on platforms that lack LCD.

SL_RAIL_RETIME_OPTIONS_NONE#

#define SL_RAIL_RETIME_OPTIONS_NONE

0x0U

A value representing no retiming options.

SL_RAIL_RETIME_OPTIONS_ALL#

#define SL_RAIL_RETIME_OPTIONS_ALL

0xFFU

A value representing all retiming options.

sl_rail_time_mode_t#

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

sl_rail_packet_time_position_t#

sl_rail_packet_time_position_t

The available packet time stamp position choices.

sl_rail_sleep_config_t#

sl_rail_sleep_config_t

The configuration.

sl_rail_scheduler_status_t#

sl_rail_scheduler_status_t

Multiprotocol scheduler status returned by sl_rail_get_scheduler_status().

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.

sl_rail_task_type_t#

sl_rail_task_type_t

Multiprotocol radio operation task types, used with sl_rail_set_task_priority().

sl_rail_events_t#

sl_rail_events_t

RAIL events passed to the event callback.

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

sl_rail_tx_data_source_t#

sl_rail_tx_data_source_t

Transmit data sources supported by RAIL.

sl_rail_rx_data_source_t#

sl_rail_rx_data_source_t

Receive data sources supported by RAIL.

Note

• Data sources other than SL_RAIL_RX_DATA_SOURCE_PACKET_DATA require use of sl_rail_data_method_t::SL_RAIL_DATA_METHOD_FIFO_MODE.

sl_rail_data_method_t#

sl_rail_data_method_t

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

For Transmit the distinction between sl_rail_data_method_t::SL_RAIL_DATA_METHOD_PACKET_MODE and sl_rail_data_method_t::SL_RAIL_DATA_METHOD_FIFO_MODE has become more cosmetic than functional, as the sl_rail_write_tx_fifo() and sl_rail_set_tx_fifo_threshold() APIs and related SL_RAIL_EVENT_TX_FIFO_ALMOST_EMPTY event can be used in either mode. For Receive the distinction is functionally important because in sl_rail_data_method_t::SL_RAIL_DATA_METHOD_PACKET_MODE rollback occurs automatically for unsuccessfully-received packets (sl_rail_rx_packet_status_t ABORT statuses), flushing their data. In sl_rail_data_method_t::SL_RAIL_DATA_METHOD_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.

sl_rail_tx_pa_mode_t#

sl_rail_tx_pa_mode_t

Suitable type for the supported PA modes.

The PA modes correspond to the different on-chip PAs that are physically available. For more information about the power and performance characteristics of a given amplifier, see the data sheet.

Note

• Some platforms support only a subset of these PAs.

sl_rail_tx_power_mode_t#

sl_rail_tx_power_mode_t

An enumeration of the power modes.

The power modes correspond to the different on-chip PAs that are available. For more information about the power and performance characteristics of a given amplifier, see the data sheet.

sl_rail_pti_mode_t#

sl_rail_pti_mode_t

A channel type enumeration.

sl_rail_pti_protocol_t#

sl_rail_pti_protocol_t

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

sl_rail_channel_config_entry_type_t#

sl_rail_channel_config_entry_type_t

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

SL_RAIL_RX_CHANNEL_HOPPING_MODE_CONC and SL_RAIL_RX_CHANNEL_HOPPING_MODE_VT can only be used if the channel supports it.

sl_rail_radio_state_t#

sl_rail_radio_state_t

The state of the radio.

sl_rail_radio_state_detail_t#

sl_rail_radio_state_detail_t

The detailed state of the radio.

The three radio state bits SL_RAIL_RF_STATE_DETAIL_IDLE_STATE, SL_RAIL_RF_STATE_DETAIL_RX_STATE, and SL_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 SL_RAIL_RF_STATE_DETAIL_TRANSITION and SL_RAIL_RF_STATE_DETAIL_ACTIVE. When SL_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 SL_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 SL_RAIL_RF_STATE_DETAIL_IDLE_STATE is set, and will always be set when SL_RAIL_RF_STATE_DETAIL_TX_STATE is set. Otherwise, the value is invalid.

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

sl_rail_idle_mode_t#

sl_rail_idle_mode_t

An enumeration for the different types of supported idle modes.

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

sl_rail_stop_mode_t#

sl_rail_stop_mode_t

Stop radio operation options bit mask.

sl_rail_tx_options_t#

sl_rail_tx_options_t

Transmit options, in reality a bitmask.

sl_rail_scheduled_tx_during_rx_t#

sl_rail_scheduled_tx_during_rx_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 sl_rail_start_scheduled_tx() as part of sl_rail_scheduled_tx_config_t.

sl_rail_tx_repeat_options_t#

sl_rail_tx_repeat_options_t

Transmit repeat options, in reality a bitmask.

sl_rail_rx_options_t#

sl_rail_rx_options_t

Receive options, in reality a bitmask.

sl_rail_rx_packet_status_t#

sl_rail_rx_packet_status_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 sl_rail_data_method_t::SL_RAIL_DATA_METHOD_FIFO_MODE, ABORT statuses imply some packet data may be available, but it's incomplete and not trustworthy.

sl_rail_antenna_sel_t#

sl_rail_antenna_sel_t

Antenna path Selection enumeration.

sl_rail_rf_sense_band_t#

sl_rail_rf_sense_band_t

An enumeration for specifying the RF Sense frequency band.

sl_rail_rx_channel_hopping_mode_t#

sl_rail_rx_channel_hopping_mode_t

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

sl_rail_rx_channel_hopping_options_t#

sl_rail_rx_channel_hopping_options_t

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

sl_rail_stream_mode_t#

sl_rail_stream_mode_t

Possible stream output modes.

sl_rail_vdet_mode_t#

sl_rail_vdet_mode_t

VDET Modes.

The VDET Mode is passed to sl_rail_config_vdet() via sl_rail_vdet_config_t. The Front End Module Voltage Detection (VDET) Utility component allows customers to measure their Front End Module performance at specified points in the Transmit packet.

sl_rail_vdet_resolution_t#

sl_rail_vdet_resolution_t

VDET Resolution for the Aux ADC.

The VDET Resolution is passed to sl_rail_config_vdet() via sl_rail_vdet_config_t. Shows available resolution options.

sl_rail_vdet_status_t#

sl_rail_vdet_status_t

VDET Status.

The VDET Status for internal debug. Shows states.

sl_rail_retime_options_t#

sl_rail_retime_options_t

Retiming options bit shifts.

sl_rail_handle_t#

sl_rail_handle_t

A radio-generic handle (e.g., SL_RAIL_EFR32_HANDLE), or a real RAIL instance handle as returned from sl_rail_init().

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

sl_rail_status_t#

sl_rail_status_t

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

It is a subset of sl_status_t.

sl_rail_init_complete_callback_t#

typedef void(* sl_rail_init_complete_callback_t) (sl_rail_handle_t rail_handle) )(sl_rail_handle_t rail_handle)

A pointer to an initialization complete callback function.

sl_rail_opaque_value_t#

sl_rail_opaque_value_t [1]

An opaque type not examined by RAIL; can be used for application- specific purposes.

sl_rail_time_t#

sl_rail_time_t

Time in microseconds.

sl_rail_timer_callback_t#

typedef void(* sl_rail_timer_callback_t) (sl_rail_handle_t rail_handle) )(sl_rail_handle_t rail_handle)

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

sl_rail_multi_timer_callback_t#

sl_rail_multi_timer_callback_t )(struct sl_rail_multi_timer *p_tmr, sl_rail_time_t expected_time_of_event, void *cb_arg)

Callback fired when timer expires.

sl_rail_fifo_buffer_align_t#

typedef uint32_t sl_rail_fifo_buffer_align_t

Type indicating the needed alignment for RX and TX FIFOs.

sl_rail_packet_queue_entry_t#

typedef uint64_t sl_rail_packet_queue_entry_t

Type used for Packet Queue entries.

RAIL utilizes a receive Packet Queue for packet reception metadata that supplements the receive FIFO, helping sl_rail_get_rx_packet_info() and sl_rail_get_rx_packet_details() provide their information in the order that packets were received.

sl_rail_events_callback_t#

typedef void(* sl_rail_events_callback_t) (sl_rail_handle_t rail_handle, sl_rail_events_t events) )(sl_rail_handle_t rail_handle, sl_rail_events_t events)

A pointer to the callback called when some RAIL event(s) occur.

sl_rail_tx_power_t#

typedef int16_t sl_rail_tx_power_t

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

On EFR32 they can range from SL_RAIL_TX_POWER_MIN to SL_RAIL_TX_POWER_MAX.

sl_rail_pa_power_setting_t#

typedef uint32_t sl_rail_pa_power_setting_t

PA power setting type used directly by the PA Power Conversions component which is decoded to the actual hardware register value(s).

sl_rail_radio_config_t#

typedef const uint32_t* sl_rail_radio_config_t

Pointer to a radio configuration array.

The radio configuration properly configures the radio for operation on a protocol. These configurations are very chip-specific should not be created or edited by hand.

sl_rail_packet_duration_t#

sl_rail_packet_duration_t )(uint8_t bit_rate, uint16_t number_of_bytes)

A pointer to a function that processes packet duration on air.

sl_rail_radio_config_changed_callback_t#

sl_rail_radio_config_changed_callback_t )(sl_rail_handle_t rail_handle, const sl_rail_channel_config_entry_t *p_entry)

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

sl_rail_transition_time_t#

sl_rail_transition_time_t

Suitable type for the supported transition time range.

Refer to platform-specific SL_RAIL_MINIMUM_TRANSITION_US and SL_RAIL_MAXIMUM_TRANSITION_US for the valid range of this type.

sl_rail_addr_filter_mask_t#

typedef uint8_t sl_rail_addr_filter_mask_t

A bitmask representation of which 4 filters passed for each SL_RAIL_ADDR_CONFIG_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 sl_rail_ieee802154_address_t on all platforms, but is only valid in sl_rail_rx_packet_info_t on platforms where SL_RAIL_SUPPORTS_ADDR_FILTER_MASK is true.

sl_rail_rx_packet_handle_t#

sl_rail_rx_packet_handle_t

A handle used to reference a packet during reception processing.

There are several sentinel handle values that pertain to certain circumstances: SL_RAIL_RX_PACKET_HANDLE_INVALID, SL_RAIL_RX_PACKET_HANDLE_OLDEST, SL_RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE and SL_RAIL_RX_PACKET_HANDLE_NEWEST.

sl_rail_convert_lqi_callback_t#

sl_rail_convert_lqi_callback_t )(uint8_t lqi, int8_t rssi_dbm)

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

Returns

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

sl_rail_cal_mask_t#

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

sl_rail_rx_ir_cal_values_t#

typedef uint32_t sl_rail_rx_ir_cal_values_t[2] [2]

sl_rail_rx_ir_cal_values_t

RX IR calibration values.

Platforms with fewer SL_RAIL_RF_PATHS than SL_RAIL_MAX_RF_PATHS will only respect and update SL_RAIL_RF_PATHS indices and ignore the rest.

sl_rail_cal_values_t#

sl_rail_cal_values_t

A calibration value structure.

This structure contains the set of persistent calibration values for EFR32. You can set these beforehand and apply them at startup to save the time required to compute them. Any of these values may be set to SL_RAIL_CAL_INVALID_VALUE to force the code to compute that calibration value.

sl_rail_rf_sense_callback_t#

typedef void(* sl_rail_rf_sense_callback_t) (void) )(void)

A pointer to an RF Sense callback function.

Consider using the event SL_RAIL_EVENT_RF_SENSED as an alternative.

sl_rail_rx_channel_hopping_parameter_t#

sl_rail_rx_channel_hopping_parameter_t

Rx channel hopping on-channel time.

sl_rail_frequency_offset_t#

sl_rail_frequency_offset_t

Type that represents the number of Frequency Offset units.

It is used with sl_rail_get_rx_freq_offset() and sl_rail_set_freq_offset().

The units are chip-specific. For EFR32 they are radio synthesizer resolution steps (synth ticks) and is limited to 15 bits. A value of SL_RAIL_FREQUENCY_OFFSET_INVALID means that this value is invalid.

sl_rail_tz_changed_dcdc_callback_t#

sl_rail_tz_changed_dcdc_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_changed_dcdc().

Returns

• Status code indicating success of the function call.

sl_rail_tz_config_antenna_gpio_callback_t#

sl_rail_tz_config_antenna_gpio_callback_t )(const sl_rail_antenna_config_t *p_config)

A pointer to the callback used to switch to secure world and run sl_rail_tz_config_antenna_gpio().

Returns

• Status code indicating success of the function call.

sl_rail_tz_radio_clock_enable_callback_t#

sl_rail_tz_radio_clock_enable_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_tz_radio_clock_enable().

sl_rail_tz_get_radio_clock_freq_hz_callback_t#

sl_rail_tz_get_radio_clock_freq_hz_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_get_radio_clock_freq_hz().

Returns

• Radio subsystem clock frequency in Hz.

sl_rail_tz_rfeca_clock_enable_callback_t#

sl_rail_tz_rfeca_clock_enable_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_tz_rfeca_clock_enable().

sl_rail_tz_rfeca_is_clock_enabled_callback_t#

sl_rail_tz_rfeca_is_clock_enabled_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_tz_rfeca_is_clock_enabled().

Returns

• true if RFECA clocks are enabled; false otherwise

sl_rail_tz_read_internal_temperature_callback_t#

sl_rail_tz_read_internal_temperature_callback_t )(uint16_t *p_internal_temperature_kelvin, bool enable_temperature_interrupts)

A pointer to the callback used to switch to secure world and run sl_rail_tz_read_internal_temperature().

Returns

• Status code indicating success of the function call.

sl_rail_tz_enable_secure_radio_irqs_callback_t#

sl_rail_tz_enable_secure_radio_irqs_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_tz_enable_secure_radio_irqs().

sl_rail_tz_disable_secure_radio_irqs_callback_t#

sl_rail_tz_disable_secure_radio_irqs_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_tz_disable_secure_radio_irqs().

sl_rail_tz_radio_perform_m2m_ldma_callback_t#

sl_rail_tz_radio_perform_m2m_ldma_callback_t )(uint32_t *p_dest, const uint32_t *p_src, uint32_t num_words)

A pointer to the callback used to switch to secure world and run sl_rail_tz_radio_perform_m2m_ldma().

Returns

• Status code indicating success of the function call.

sl_rail_tz_configure_hfxo_callback_t#

sl_rail_tz_configure_hfxo_callback_t )(void)

A pointer to the callback used to switch to secure world and run sl_rail_tz_configure_hfxo().