This file contains the type definitions for RAIL structures, enums, and other types.

License#

Copyright 2020 Silicon Laboratories Inc. www.silabs.com

SPDX-License-Identifier: Zlib

The licensor of this software is Silicon Laboratories Inc.

This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

Modules#

RAIL_Version_t

RAILSched_Config_t

RAIL_MultiTimer_t

RAIL_PacketTimeStamp_t

RAIL_TimerSyncConfig_t

RAIL_SchedulerInfo_t

RAIL_Config_t

RAIL_TxPowerConfig_t

RAIL_FrameType_t

RAIL_AlternatePhy_t

RAIL_ChannelConfigEntry_t

RAIL_ChannelConfig_t

RAIL_ChannelMetadata_t

RAIL_StackInfoCommon_t

RAIL_PtiConfig_t

RAIL_DataConfig_t

RAIL_StateTiming_t

RAIL_StateTransitions_t

RAIL_TxChannelHoppingConfigEntry_t

RAIL_TxChannelHoppingConfig_t

RAIL_TxPacketDetails_t

RAIL_ScheduleTxConfig_t

RAIL_CsmaConfig_t

RAIL_LbtConfig_t

RAIL_SyncWordConfig_t

RAIL_TxRepeatConfig_t

RAIL_AddrConfig_t

RAIL_ScheduleRxConfig_t

RAIL_RxPacketInfo_t

RAIL_RxPacketDetails_t

RAIL_AutoLnaBypassConfig_t

RAIL_AutoAckConfig_t

RAIL_AntennaConfig_t

RAIL_HFXOThermistorConfig_t

RAIL_HFXOCompensationConfig_t

RAIL_TxIrCalValues_t

RAIL_IrCalValues_t

RAIL_RfSenseSelectiveOokConfig_t

RAIL_RxChannelHoppingConfigMultiMode_t

RAIL_RxChannelHoppingConfigEntry_t

RAIL_RxChannelHoppingConfig_t

RAIL_RxDutyCycleConfig_t

RAIL_DirectModeConfig_t

RAIL_VerifyConfig_t

RAIL_VdetConfig_t

RAIL_ChipTempConfig_t

RAIL_ChipTempMetrics_t

Macros#

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

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

#define
RAIL_EFR32_HANDLE ((RAIL_Handle_t)0xFFFFFFFFUL)

A placeholder for a radio-generic RAIL handle.

#define

A value to signal that RAIL should not use DMA.

#define

Default timer synchronization configuration.

#define

Radio Scheduler Status mask.

#define

Radio Scheduler Status shift.

#define

Radio Scheduler Task mask.

#define

Radio Scheduler Task shift.

#define
RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT

Shift position of RAIL_EVENT_SCHEDULED_TX_STARTED bit.

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

#define
RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_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.

#define

A value representing no events.

#define
RAIL_EVENT_RSSI_AVERAGE_DONE (1ULL << RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT)

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

#define
RAIL_EVENT_RX_ACK_TIMEOUT (1ULL << RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT)

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

#define
RAIL_EVENT_RX_FIFO_ALMOST_FULL (1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)

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

#define
RAIL_EVENT_RX_PACKET_RECEIVED (1ULL << RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT)

Occurs whenever a packet is received with RAIL_RX_PACKET_READY_SUCCESS or RAIL_RX_PACKET_READY_CRC_ERROR.

#define
RAIL_EVENT_RX_PREAMBLE_LOST (1ULL << RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT)

Occurs when the radio has lost a preamble.

#define
RAIL_EVENT_RX_PREAMBLE_DETECT (1ULL << RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT)

Occurs when the radio has detected a preamble.

#define
RAIL_EVENT_RX_SYNC1_DETECT (1ULL << RAIL_EVENT_RX_SYNC1_DETECT_SHIFT)

Occurs when the first sync word is detected.

#define
RAIL_EVENT_RX_SYNC2_DETECT (1ULL << RAIL_EVENT_RX_SYNC2_DETECT_SHIFT)

Occurs when the second sync word is detected.

#define
RAIL_EVENT_RX_FRAME_ERROR (1ULL << RAIL_EVENT_RX_FRAME_ERROR_SHIFT)

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

#define
RAIL_EVENT_RX_FIFO_FULL (1ULL << RAIL_EVENT_RX_FIFO_FULL_SHIFT)

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.

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

#define
RAIL_EVENT_RX_ADDRESS_FILTERED (1ULL << RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT)

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

#define
RAIL_EVENT_RX_TIMEOUT (1ULL << RAIL_EVENT_RX_TIMEOUT_SHIFT)

Occurs when an RX event times out.

#define
RAIL_EVENT_SCHEDULED_RX_STARTED (1ULL << RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT)

Occurs when a scheduled RX begins turning on the receiver.

#define
RAIL_EVENT_SCHEDULED_TX_STARTED (1ULL << RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT)

Occurs when a scheduled TX begins turning on the transmitter.

#define
RAIL_EVENT_RX_SCHEDULED_RX_END (1ULL << RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT)

Occurs when the scheduled RX window ends.

#define
RAIL_EVENT_RX_SCHEDULED_RX_MISSED (1ULL << RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT)

Occurs when start of a scheduled receive is missed.

#define
RAIL_EVENT_RX_PACKET_ABORTED (1ULL << RAIL_EVENT_RX_PACKET_ABORTED_SHIFT)

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

#define
RAIL_EVENT_RX_FILTER_PASSED (1ULL << RAIL_EVENT_RX_FILTER_PASSED_SHIFT)

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

#define
RAIL_EVENT_RX_TIMING_LOST (1ULL << RAIL_EVENT_RX_TIMING_LOST_SHIFT)

Occurs when the modem timing is lost.

#define
RAIL_EVENT_RX_TIMING_DETECT (1ULL << RAIL_EVENT_RX_TIMING_DETECT_SHIFT)

Occurs when the modem timing is detected.

#define
RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE (1ULL << RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT)

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

#define
RAIL_EVENT_RX_DUTY_CYCLE_RX_END (1ULL << RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT)

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

#define
RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND (1ULL << RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT)

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

#define
RAIL_EVENT_ZWAVE_BEAM (1ULL << RAIL_EVENT_ZWAVE_BEAM_SHIFT)

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

#define
RAIL_EVENT_MFM_TX_BUFFER_DONE (1ULL << RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT)

Indicate a MFM buffer has completely transmitted.

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

#define

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

#define
RAIL_EVENT_TX_FIFO_ALMOST_EMPTY (1ULL << RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT)

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

#define
RAIL_EVENT_TX_PACKET_SENT (1ULL << RAIL_EVENT_TX_PACKET_SENT_SHIFT)

Occurs after a packet has been transmitted.

#define
RAIL_EVENT_TXACK_PACKET_SENT (1ULL << RAIL_EVENT_TXACK_PACKET_SENT_SHIFT)

Occurs after an ACK packet has been transmitted.

#define
RAIL_EVENT_TX_ABORTED (1ULL << RAIL_EVENT_TX_ABORTED_SHIFT)

Occurs when a transmit is aborted by the user.

#define
RAIL_EVENT_TXACK_ABORTED (1ULL << RAIL_EVENT_TXACK_ABORTED_SHIFT)

Occurs when an ACK transmit is aborted by the user.

#define
RAIL_EVENT_TX_BLOCKED (1ULL << RAIL_EVENT_TX_BLOCKED_SHIFT)

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

#define
RAIL_EVENT_TXACK_BLOCKED (1ULL << RAIL_EVENT_TXACK_BLOCKED_SHIFT)

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

#define
RAIL_EVENT_TX_UNDERFLOW (1ULL << RAIL_EVENT_TX_UNDERFLOW_SHIFT)

Occurs when the transmit buffer underflows.

#define
RAIL_EVENT_TXACK_UNDERFLOW (1ULL << RAIL_EVENT_TXACK_UNDERFLOW_SHIFT)

Occurs when the ACK transmit buffer underflows.

#define
RAIL_EVENT_TX_CHANNEL_CLEAR (1ULL << RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT)

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

#define
RAIL_EVENT_TX_CHANNEL_BUSY (1ULL << RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT)

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

#define
RAIL_EVENT_TX_CCA_RETRY (1ULL << RAIL_EVENT_TX_CCA_RETRY_SHIFT)

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

#define
RAIL_EVENT_TX_START_CCA (1ULL << RAIL_EVENT_TX_START_CCA_SHIFT)

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

#define
RAIL_EVENT_TX_STARTED (1ULL << RAIL_EVENT_TX_STARTED_SHIFT)

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

#define

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

#define
RAIL_EVENT_TX_SCHEDULED_TX_MISSED (1ULL << RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT)

Occurs when the start of a scheduled transmit is missed.

#define

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

#define

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

#define
RAIL_EVENT_CONFIG_UNSCHEDULED (1ULL << RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT)

Occurs when the scheduler switches away from this configuration.

#define
RAIL_EVENT_CONFIG_SCHEDULED (1ULL << RAIL_EVENT_CONFIG_SCHEDULED_SHIFT)

Occurs when the scheduler switches to this configuration.

#define
RAIL_EVENT_SCHEDULER_STATUS (1ULL << RAIL_EVENT_SCHEDULER_STATUS_SHIFT)

Occurs when the scheduler has a status to report.

#define
RAIL_EVENT_CAL_NEEDED (1ULL << RAIL_EVENT_CAL_NEEDED_SHIFT)

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

#define
RAIL_EVENT_RF_SENSED (1ULL << RAIL_EVENT_RF_SENSED_SHIFT)

Occurs when RF energy is sensed from the radio.

#define
RAIL_EVENT_PA_PROTECTION (1ULL << RAIL_EVENT_PA_PROTECTION_SHIFT)

Occurs when PA protection circuit kicks in.

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

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

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

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

#define
RAIL_EVENT_THERMISTOR_DONE (1ULL << RAIL_EVENT_THERMISTOR_DONE_SHIFT)

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

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

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

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

#define
RAIL_EVENT_USER_MBOX (1ULL << RAIL_EVENT_USER_MBOX_SHIFT)

Occurs when the user received a mailbox message.

#define
RAIL_EVENTS_ALL 0xFFFFFFFFFFFFFFFFULL

A value representing all possible events.

#define
RAIL_TX_POWER_MAX ((RAIL_TxPower_t)0x7FFF)

The maximum valid value for a RAIL_TxPower_t.

#define
RAIL_TX_POWER_MIN ((RAIL_TxPower_t)0x8000)

The minimum valid value for a RAIL_TxPower_t.

#define
RAIL_TX_POWER_CURVE_DEFAULT_MAX ((RAIL_TxPower_t)200)

The maximum power in deci-dBm the curve supports.

#define

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

#define

mV are used for all TX power voltage values.

#define

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

#define

Invalid RAIL_TxPowerLevel_t value returned when an error occurs with RAIL_GetTxPower.

#define

Sentinel value that can be passed to RAIL_SetTxPower to set the highest power level available on the current PA, regardless of which one is selected.

#define

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

#define

The names of the TX power modes.

#define

Convenience macro for any OFDM mapping table mode.

#define

Convenience macro for any Sub-GHz mapping table mode.

#define

Convenience macro for any OFDM mode.

#define

An invalid return value when calling RAIL_SetFixedLength().

#define

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

#define

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

#define

Fixed-width type indicating the needed alignment for RX and TX FIFOs.

#define
RAIL_FIFO_ALIGNMENT (sizeof(RAIL_FIFO_ALIGNMENT_TYPE))

Alignment that is needed for the RX and TX FIFOs.

#define

A FIFO threshold value that disables the threshold.

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

#define

Radio is inactive.

#define
RAIL_RF_STATE_DETAIL_IDLE_STATE (1U << RAIL_RF_STATE_DETAIL_IDLE_STATE_SHIFT)

Radio is in or headed to the idle 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.

#define
RAIL_RF_STATE_DETAIL_TX_STATE (1U << RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT)

Radio is in or headed to the transmit state.

#define
RAIL_RF_STATE_DETAIL_TRANSITION (1U << RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT)

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

#define
RAIL_RF_STATE_DETAIL_ACTIVE (1U << RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT)

Radio is actively transmitting or receiving.

#define
RAIL_RF_STATE_DETAIL_NO_FRAMES (1U << RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT)

Radio has frame detect disabled.

#define
RAIL_RF_STATE_DETAIL_LBT (1U << RAIL_RF_STATE_DETAIL_LBT_SHIFT)

LBT/CSMA operation is currently ongoing.

#define

Mask for core radio state bits.

#define

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.

#define

Do not stop any radio operations.

#define
RAIL_STOP_MODE_ACTIVE (1U << RAIL_STOP_MODE_ACTIVE_SHIFT)

Stop active radio operations only.

#define
RAIL_STOP_MODE_PENDING (1U << RAIL_STOP_MODE_PENDING_SHIFT)

Stop pending radio operations.

#define

Stop all radio operations.

#define

A value representing no options enabled.

#define
RAIL_TX_OPTIONS_DEFAULT RAIL_TX_OPTIONS_NONE

All options disabled by default.

#define
RAIL_TX_OPTION_WAIT_FOR_ACK (1UL << 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.

#define
RAIL_TX_OPTION_REMOVE_CRC (1UL << RAIL_TX_OPTION_REMOVE_CRC_SHIFT)

An option to remove CRC bytes from TX packets.

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

#define
RAIL_TX_OPTION_ANTENNA0 (1UL << RAIL_TX_OPTION_ANTENNA0_SHIFT)

An option to select antenna 0 for transmission.

#define
RAIL_TX_OPTION_ANTENNA1 (1UL << RAIL_TX_OPTION_ANTENNA1_SHIFT)

An option to select antenna 1 for transmission.

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

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

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

#define
RAIL_TX_OPTION_RESEND (1UL << RAIL_TX_OPTION_RESEND_SHIFT)

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

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

#define
RAIL_TX_OPTIONS_ALL 0xFFFFFFFFUL

A value representing all possible options.

#define

The maximum number of LBT/CSMA retries supported.

#define

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

#define

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

#define

RAIL_CsmaConfig_t initializer configuring a single CCA prior to TX.

#define

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

#define

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

#define

A value representing no repeat options enabled.

#define
RAIL_TX_REPEAT_OPTIONS_DEFAULT RAIL_TX_REPEAT_OPTIONS_NONE

All repeat options disabled by default.

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

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

#define

RAIL_TxRepeatConfig_t::iterations initializer configuring infinite repeated transmissions.

#define

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

#define

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

#define

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

#define

A value representing no options enabled.

#define
RAIL_RX_OPTIONS_DEFAULT RAIL_RX_OPTIONS_NONE

All options are disabled by default.

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

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

#define
RAIL_RX_OPTION_ENABLE_DUALSYNC (1UL << RAIL_RX_OPTION_ENABLE_DUALSYNC_SHIFT)

An option to control which sync words will be accepted.

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

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

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

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

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

#define
RAIL_RX_OPTION_DISABLE_FRAME_DETECTION (1UL << RAIL_RX_OPTION_DISABLE_FRAME_DETECTION_SHIFT)

An option to disable frame detection.

#define
RAIL_RX_OPTION_CHANNEL_SWITCHING (1U << RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT)

An option to enable IEEE 802.15.4 RX channel switching.

#define
RAIL_RX_OPTION_FAST_RX2RX (1U << RAIL_RX_OPTION_FAST_RX2RX_SHIFT)

An option to enable fast RX2RX state transition.

#define
RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION (1U << RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION_SHIFT)

An option to enable collision detection.

#define
RAIL_RX_OPTIONS_ALL 0xFFFFFFFFUL

A value representing all possible options.

#define

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

#define
RAIL_RSSI_INVALID ((int16_t)(RAIL_RSSI_INVALID_DBM * 4))

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

#define
RAIL_RSSI_LOWEST ((int16_t)(RAIL_RSSI_INVALID + 1))

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

#define

Maximum absolute value for RSSI offset.

#define
RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT ((RAIL_Time_t)0xFFFFFFFFU)

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

#define
RAIL_GET_RSSI_NO_WAIT ((RAIL_Time_t)0U)

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

#define

An invalid RX packet handle value.

#define
RAIL_RX_PACKET_HANDLE_OLDEST ((RAIL_RxPacketHandle_t) 1)

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

#define
RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE ((RAIL_RxPacketHandle_t) 2)

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

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

#define

Acknowledgment packets cannot be longer than 64 bytes.

#define
ant0Loc defaultPath
#define

A sentinel value to indicate an invalid thermistor measurement value.

#define

A sentinel value to indicate an invalid PPM calculation value.

#define
RAIL_CAL_TEMP_VCO (0x00000001U)

EFR32-specific temperature calibration bit.

#define
RAIL_CAL_TEMP_HFXO (0x00000002U)

EFR32-specific HFXO temperature check bit.

#define

EFR32-specific HFXO compensation bit.

#define
RAIL_CAL_RX_IRCAL (0x00010000U)

EFR32-specific IR calibration bit.

#define

EFR32-specific Tx IR calibration bit.

#define
RAIL_CAL_ONETIME_IRCAL (RAIL_CAL_RX_IRCAL | RAIL_CAL_OFDM_TX_IRCAL)

A mask to run EFR32-specific IR calibrations.

#define
RAIL_CAL_TEMP (RAIL_CAL_TEMP_VCO | RAIL_CAL_TEMP_HFXO | RAIL_CAL_COMPENSATE_HFXO)

A mask to run temperature-dependent calibrations.

#define
RAIL_CAL_ONETIME (RAIL_CAL_ONETIME_IRCAL)

A mask to run one-time calibrations.

#define

A mask to run optional performance calibrations.

#define
RAIL_CAL_OFFLINE (RAIL_CAL_ONETIME_IRCAL)

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

#define
RAIL_CAL_ALL (RAIL_CAL_TEMP | RAIL_CAL_ONETIME)

A mask to run all possible calibrations for this chip.

#define
RAIL_CAL_ALL_PENDING (0x00000000U)

A mask to run all pending calibrations.

#define

An invalid calibration value.

#define

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

#define

A define to set all RAIL_RxIrCalValues_t values to uninitialized.

#define

A define to set all RAIL_TxIrCalValues_t values to uninitialized.

#define

A define to set all RAIL_IrCalValues_t values to uninitialized.

#define
RAIL_IRCALVAL (irCalStruct, rfPath)

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

#define
RAIL_CALVALUES_UNINIT RAIL_IRCALVALUES_UNINIT

A define to set all RAIL_CalValues_t values to uninitialized.

#define

Use this value with either TX or RX values in RAIL_SetPaCTune to use whatever value is already set and do no update.

#define

RF Sense low sensitivity offset.

#define

Use the MODEM default sync word.

#define

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

#define

A value representing no options enabled.

#define
RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE

All options disabled by default.

#define
RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT
#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.

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

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

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

#define

A sentinel value to flag an invalid channel hopping index.

#define
RAIL_FREQUENCY_OFFSET_MAX ((RAIL_FrequencyOffset_t) 0x3FFF)

The maximum frequency offset value supported.

#define
RAIL_FREQUENCY_OFFSET_MIN ((RAIL_FrequencyOffset_t) -RAIL_FREQUENCY_OFFSET_MAX)

The minimum frequency offset value supported.

#define
RAIL_FREQUENCY_OFFSET_INVALID ((RAIL_FrequencyOffset_t) 0x8000)

Specify an invalid frequency offset value.

#define

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

#define

A macro that is string versions of the calibration enums.

#define

A macro that is string versions of the resolution enums.

#define

A macro that is string versions of the status enums.

#define

Maximum junction temperature in Kelvin.

#define

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

#define

Number of temperature values provided for the chip thermal protection.

#define
RAIL_RETIME_OPTION_HFXO (1U << RAIL_RETIME_OPTION_HFXO_SHIFT)

An option to configure HFXO retiming.

#define
RAIL_RETIME_OPTION_HFRCO (1U << RAIL_RETIME_OPTION_HFRCO_SHIFT)

An option to configure HFRCO retiming.

#define
RAIL_RETIME_OPTION_DCDC (1U << RAIL_RETIME_OPTION_DCDC_SHIFT)

An option to configure DCDC retiming.

#define
RAIL_RETIME_OPTION_LCD (1U << RAIL_RETIME_OPTION_LCD_SHIFT)

An option to configure LCD retiming.

#define

A value representing no retiming options.

#define

A value representing all retiming options.

Enumerations#

enum
RAIL_STATUS_NO_ERROR
RAIL_STATUS_INVALID_PARAMETER
RAIL_STATUS_INVALID_STATE
RAIL_STATUS_INVALID_CALL
RAIL_STATUS_SUSPENDED
RAIL_STATUS_SCHED_ERROR
}

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

enum
RAIL_TIME_ABSOLUTE = 0
RAIL_TIME_DELAY = 1
RAIL_TIME_DISABLED = 2
}

Specify a time offset in RAIL APIs.

enum
RAIL_PACKET_TIME_INVALID = 0
RAIL_PACKET_TIME_DEFAULT = 1
RAIL_PACKET_TIME_AT_PREAMBLE_START = 2
RAIL_PACKET_TIME_AT_PREAMBLE_START_USED_TOTAL = 3
RAIL_PACKET_TIME_AT_SYNC_END = 4
RAIL_PACKET_TIME_AT_SYNC_END_USED_TOTAL = 5
RAIL_PACKET_TIME_AT_PACKET_END = 6
RAIL_PACKET_TIME_AT_PACKET_END_USED_TOTAL = 7
RAIL_PACKET_TIME_COUNT = 8
}

The available packet timestamp position choices.

enum
RAIL_SLEEP_CONFIG_TIMERSYNC_DISABLED = 0
RAIL_SLEEP_CONFIG_TIMERSYNC_ENABLED = 1
}

The configuration.

enum
RAIL_SCHEDULER_STATUS_NO_ERROR = (0U << 0 )
RAIL_SCHEDULER_STATUS_UNSUPPORTED = (1U << 0 )
RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED = (2U << 0 )
RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL = (3U << 0 )
RAIL_SCHEDULER_STATUS_TASK_FAIL = (4U << 0 )
RAIL_SCHEDULER_STATUS_INTERNAL_ERROR = (5U << 0 )
RAIL_SCHEDULER_TASK_EMPTY = (0U << 4 )
RAIL_SCHEDULER_TASK_SCHEDULED_RX = (1U << 4 )
RAIL_SCHEDULER_TASK_SCHEDULED_TX = (2U << 4 )
RAIL_SCHEDULER_TASK_SINGLE_TX = (3U << 4 )
RAIL_SCHEDULER_TASK_SINGLE_CCA_CSMA_TX = (4U << 4 )
RAIL_SCHEDULER_TASK_SINGLE_CCA_LBT_TX = (5U << 4 )
RAIL_SCHEDULER_TASK_SCHEDULED_CCA_CSMA_TX = (6U << 4 )
RAIL_SCHEDULER_TASK_SCHEDULED_CCA_LBT_TX = (7U << 4 )
RAIL_SCHEDULER_TASK_TX_STREAM = (8U << 4 )
RAIL_SCHEDULER_TASK_AVERAGE_RSSI = (9U << 4 )
RAIL_SCHEDULER_STATUS_SCHEDULED_TX_FAIL = (RAIL_SCHEDULER_TASK_SCHEDULED_TX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_STATUS_SINGLE_TX_FAIL = (RAIL_SCHEDULER_TASK_SINGLE_TX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_STATUS_CCA_CSMA_TX_FAIL = (RAIL_SCHEDULER_TASK_SINGLE_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_STATUS_CCA_LBT_TX_FAIL = (RAIL_SCHEDULER_TASK_SINGLE_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_STATUS_SCHEDULED_RX_FAIL = (RAIL_SCHEDULER_TASK_SCHEDULED_RX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_STATUS_TX_STREAM_FAIL = (RAIL_SCHEDULER_TASK_TX_STREAM | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_STATUS_AVERAGE_RSSI_FAIL = (RAIL_SCHEDULER_TASK_AVERAGE_RSSI | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_SCHEDULED_RX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_RX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SCHEDULED_RX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_RX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SCHEDULED_RX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SCHEDULED_RX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_SCHEDULED_TX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_TX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SCHEDULED_TX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_TX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SCHEDULED_TX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SCHEDULED_TX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_SINGLE_TX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SINGLE_TX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SINGLE_TX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SINGLE_TX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SINGLE_TX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SINGLE_TX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_SINGLE_CCA_CSMA_TX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SINGLE_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SINGLE_CCA_CSMA_TX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SINGLE_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SINGLE_CCA_CSMA_TX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SINGLE_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_SINGLE_CCA_LBT_TX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SINGLE_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SINGLE_CCA_LBT_TX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SINGLE_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SINGLE_CCA_LBT_TX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SINGLE_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_FAIL = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_CSMA_TX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_FAIL = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_TASK_FAIL)
RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_INTERRUPTED = (RAIL_SCHEDULER_TASK_SCHEDULED_CCA_LBT_TX | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_TX_STREAM_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_TX_STREAM | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_TX_STREAM_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_TX_STREAM | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_TX_STREAM_INTERRUPTED = (RAIL_SCHEDULER_TASK_TX_STREAM | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
RAIL_SCHEDULER_AVERAGE_RSSI_INTERNAL_ERROR = (RAIL_SCHEDULER_TASK_AVERAGE_RSSI | RAIL_SCHEDULER_STATUS_INTERNAL_ERROR)
RAIL_SCHEDULER_AVERAGE_RSSI_SCHEDULING_ERROR = (RAIL_SCHEDULER_TASK_AVERAGE_RSSI | RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL)
RAIL_SCHEDULER_AVERAGE_RSSI_INTERRUPTED = (RAIL_SCHEDULER_TASK_AVERAGE_RSSI | RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED)
}

Multiprotocol scheduler status returned by RAIL_GetSchedulerStatus().

enum
RAIL_TASK_TYPE_START_RX = 0
RAIL_TASK_TYPE_OTHER = 1
}

Multiprotocol radio operation task types, used with RAIL_SetTaskPriority.

enum
RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT = 0
RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT = 1
RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT = 2
RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT = 3
RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT = 4
RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT = 5
RAIL_EVENT_RX_SYNC1_DETECT_SHIFT = 6
RAIL_EVENT_RX_SYNC2_DETECT_SHIFT = 7
RAIL_EVENT_RX_FRAME_ERROR_SHIFT = 8
RAIL_EVENT_RX_FIFO_FULL_SHIFT = 9
RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT = 10
RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT = 11
RAIL_EVENT_RX_TIMEOUT_SHIFT = 12
RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT = 13
RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT = 14
RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT = 15
RAIL_EVENT_RX_PACKET_ABORTED_SHIFT = 16
RAIL_EVENT_RX_FILTER_PASSED_SHIFT = 17
RAIL_EVENT_RX_TIMING_LOST_SHIFT = 18
RAIL_EVENT_RX_TIMING_DETECT_SHIFT = 19
RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT = 20
RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT = 21
RAIL_EVENT_ZWAVE_BEAM_SHIFT = 22
RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT = 23
RAIL_EVENT_TX_PACKET_SENT_SHIFT = 24
RAIL_EVENT_TXACK_PACKET_SENT_SHIFT = 25
RAIL_EVENT_TX_ABORTED_SHIFT = 26
RAIL_EVENT_TXACK_ABORTED_SHIFT = 27
RAIL_EVENT_TX_BLOCKED_SHIFT = 28
RAIL_EVENT_TXACK_BLOCKED_SHIFT = 29
RAIL_EVENT_TX_UNDERFLOW_SHIFT = 30
RAIL_EVENT_TXACK_UNDERFLOW_SHIFT = 31
RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT = 32
RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT = 33
RAIL_EVENT_TX_CCA_RETRY_SHIFT = 34
RAIL_EVENT_TX_START_CCA_SHIFT = 35
RAIL_EVENT_TX_STARTED_SHIFT = 36
RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT = 37
RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT = 38
RAIL_EVENT_CONFIG_SCHEDULED_SHIFT = 39
RAIL_EVENT_SCHEDULER_STATUS_SHIFT = 40
RAIL_EVENT_CAL_NEEDED_SHIFT = 41
RAIL_EVENT_RF_SENSED_SHIFT = 42
RAIL_EVENT_PA_PROTECTION_SHIFT = 43
RAIL_EVENT_SIGNAL_DETECTED_SHIFT = 44
RAIL_EVENT_IEEE802154_MODESWITCH_START_SHIFT = 45
RAIL_EVENT_IEEE802154_MODESWITCH_END_SHIFT = 46
RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT = 47
RAIL_EVENT_THERMISTOR_DONE_SHIFT = 48
RAIL_EVENT_TX_BLOCKED_TOO_HOT_SHIFT = 49
RAIL_EVENT_TEMPERATURE_TOO_HOT_SHIFT = 50
RAIL_EVENT_TEMPERATURE_COOL_DOWN_SHIFT = 51
RAIL_EVENT_USER_MBOX_SHIFT = 52
}

RAIL events passed to the event callback.

enum
RAIL_TX_POWER_MODE_2P4GIG_HP = 0U
RAIL_TX_POWER_MODE_2P4_HP = RAIL_TX_POWER_MODE_2P4GIG_HP
RAIL_TX_POWER_MODE_2P4GIG_MP = 1U
RAIL_TX_POWER_MODE_2P4_MP = RAIL_TX_POWER_MODE_2P4GIG_MP
RAIL_TX_POWER_MODE_2P4GIG_LP = 2U
RAIL_TX_POWER_MODE_2P4_LP = RAIL_TX_POWER_MODE_2P4GIG_LP
RAIL_TX_POWER_MODE_2P4GIG_LLP = 3U
RAIL_TX_POWER_MODE_2P4GIG_HIGHEST = 4U
RAIL_TX_POWER_MODE_2P4_HIGHEST = RAIL_TX_POWER_MODE_2P4GIG_HIGHEST
RAIL_TX_POWER_MODE_SUBGIG_POWERSETTING_TABLE = 5U
RAIL_TX_POWER_MODE_SUBGIG_HP = 6U
RAIL_TX_POWER_MODE_SUBGIG = RAIL_TX_POWER_MODE_SUBGIG_HP
RAIL_TX_POWER_MODE_SUBGIG_MP = 7U
RAIL_TX_POWER_MODE_SUBGIG_LP = 8U
RAIL_TX_POWER_MODE_SUBGIG_LLP = 9U
RAIL_TX_POWER_MODE_SUBGIG_HIGHEST = 10U
RAIL_TX_POWER_MODE_OFDM_PA_POWERSETTING_TABLE = 11U
RAIL_TX_POWER_MODE_OFDM_PA = RAIL_TX_POWER_MODE_OFDM_PA_POWERSETTING_TABLE
RAIL_TX_POWER_MODE_NONE
}

An enumeration of the EFR32 power modes.

enum
RAIL_CH_TYPE_NORMAL
RAIL_CH_TYPE_CONC_BASE
RAIL_CH_TYPE_CONC_VIRTUAL
}

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

enum
RAIL_PTI_MODE_DISABLED = 0
RAIL_PTI_MODE_SPI = 1
RAIL_PTI_MODE_UART = 2
RAIL_PTI_MODE_UART_ONEWIRE = 3
}

A channel type enumeration.

enum
RAIL_PTI_PROTOCOL_CUSTOM = 0
RAIL_PTI_PROTOCOL_THREAD = 2
RAIL_PTI_PROTOCOL_BLE = 3
RAIL_PTI_PROTOCOL_CONNECT = 4
RAIL_PTI_PROTOCOL_ZIGBEE = 5
RAIL_PTI_PROTOCOL_ZWAVE = 6
RAIL_PTI_PROTOCOL_WISUN = 7
RAIL_PTI_PROTOCOL_802154 = 8
RAIL_PTI_PROTOCOL_SIDEWALK = 9
}

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

enum
TX_PACKET_DATA = 0
TX_MFM_DATA = 1
RAIL_TX_DATA_SOURCE_COUNT
}

Transmit data sources supported by RAIL.

enum
RX_PACKET_DATA = 0
RX_DEMOD_DATA = 1
RX_IQDATA_FILTLSB = 2
RX_IQDATA_FILTMSB = 3
RX_DIRECT_MODE_DATA = 4
RX_DIRECT_SYNCHRONOUS_MODE_DATA = 5
RAIL_RX_DATA_SOURCE_COUNT
}

Receive data sources supported by RAIL.

enum
PACKET_MODE = 0
FIFO_MODE = 1
RAIL_DATA_METHOD_COUNT
}

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

enum
RAIL_RF_STATE_INACTIVE = 0u
RAIL_RF_STATE_ACTIVE = (1u << 0)
RAIL_RF_STATE_RX = (1u << 1)
RAIL_RF_STATE_TX = (1u << 2)
RAIL_RF_STATE_IDLE = (RAIL_RF_STATE_ACTIVE)
RAIL_RF_STATE_RX_ACTIVE = (RAIL_RF_STATE_RX | RAIL_RF_STATE_ACTIVE)
RAIL_RF_STATE_TX_ACTIVE = (RAIL_RF_STATE_TX | RAIL_RF_STATE_ACTIVE)
}

The state of the radio.

enum
RAIL_RF_STATE_DETAIL_IDLE_STATE_SHIFT = 0u
RAIL_RF_STATE_DETAIL_RX_STATE_SHIFT = 1u
RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT = 2u
RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT = 3u
RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT = 4u
RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT = 5u
RAIL_RF_STATE_DETAIL_LBT_SHIFT = 6u
}

The detailed state of the radio.

enum
RAIL_IDLE = 0u
RAIL_IDLE_ABORT = 1u
RAIL_IDLE_FORCE_SHUTDOWN = 2u
RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS = 3u
}

An enumeration for the different types of supported idle modes.

enum
RAIL_STOP_MODE_ACTIVE_SHIFT = 0
RAIL_STOP_MODE_PENDING_SHIFT = 1
}

Stop radio operation options bit mask.

enum
RAIL_TX_OPTION_WAIT_FOR_ACK_SHIFT = 0
RAIL_TX_OPTION_REMOVE_CRC_SHIFT = 1
RAIL_TX_OPTION_SYNC_WORD_ID_SHIFT = 2
RAIL_TX_OPTION_ANTENNA0_SHIFT = 3
RAIL_TX_OPTION_ANTENNA1_SHIFT = 4
RAIL_TX_OPTION_ALT_PREAMBLE_LEN_SHIFT = 5
RAIL_TX_OPTION_CCA_PEAK_RSSI_SHIFT = 6
RAIL_TX_OPTION_CCA_ONLY_SHIFT = 7
RAIL_TX_OPTION_RESEND_SHIFT = 8
RAIL_TX_OPTION_CONCURRENT_PHY_ID_SHIFT = 9
RAIL_TX_OPTIONS_COUNT
}

Transmit options, in reality a bitmask.

enum
RAIL_SCHEDULED_TX_DURING_RX_POSTPONE_TX = 0
RAIL_SCHEDULED_TX_DURING_RX_ABORT_TX = 1
}

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

enum
RAIL_TX_REPEAT_OPTION_HOP_SHIFT = 0
RAIL_TX_REPEAT_OPTION_START_TO_START_SHIFT = 1
}

Transmit repeat options, in reality a bitmask.

enum
RAIL_RX_OPTION_STORE_CRC_SHIFT = 0
RAIL_RX_OPTION_IGNORE_CRC_ERRORS_SHIFT = 1
RAIL_RX_OPTION_ENABLE_DUALSYNC_SHIFT = 2
RAIL_RX_OPTION_TRACK_ABORTED_FRAMES_SHIFT = 3
RAIL_RX_OPTION_REMOVE_APPENDED_INFO_SHIFT = 4
RAIL_RX_OPTION_ANTENNA0_SHIFT = 5
RAIL_RX_OPTION_ANTENNA1_SHIFT = 6
RAIL_RX_OPTION_DISABLE_FRAME_DETECTION_SHIFT = 7
RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT = 10
RAIL_RX_OPTION_FAST_RX2RX_SHIFT = 11
RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION_SHIFT = 12
}

Receive options, in reality a bitmask.

enum
RAIL_RX_PACKET_NONE = 0
RAIL_RX_PACKET_ABORT_FORMAT = 1
RAIL_RX_PACKET_ABORT_FILTERED = 2
RAIL_RX_PACKET_ABORT_ABORTED = 3
RAIL_RX_PACKET_ABORT_OVERFLOW = 4
RAIL_RX_PACKET_ABORT_CRC_ERROR = 5
RAIL_RX_PACKET_READY_CRC_ERROR = 6
RAIL_RX_PACKET_READY_SUCCESS = 7
RAIL_RX_PACKET_RECEIVING = 8
}

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

enum
RAIL_ANTENNA_0 = 0
RAIL_ANTENNA_1 = 1
RAIL_ANTENNA_AUTO = 255
}

Antenna path Selection enumeration.

enum
RAIL_RFSENSE_OFF
RAIL_RFSENSE_2_4GHZ
RAIL_RFSENSE_SUBGHZ
RAIL_RFSENSE_ANY
RAIL_RFSENSE_MAX
RAIL_RFSENSE_2_4GHZ_LOW_SENSITIVITY = (0x20U) + RAIL_RFSENSE_2_4GHZ
RAIL_RFSENSE_SUBGHZ_LOW_SENSITIVITY = (0x20U) + RAIL_RFSENSE_SUBGHZ
RAIL_RFENSE_ANY_LOW_SENSITIVITY = (0x20U) + RAIL_RFSENSE_ANY
}

An enumeration for specifying the RF Sense frequency band.

enum
RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL = 0
RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT = 1
RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE = 2
RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE = 3
RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1 = 4
RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE = 5
RAIL_RX_CHANNEL_HOPPING_MODE_SQ = 6
RAIL_RX_CHANNEL_HOPPING_MODE_CONC = 7
RAIL_RX_CHANNEL_HOPPING_MODE_VT = 8
RAIL_RX_CHANNEL_HOPPING_MODE_TX = 9
RAIL_RX_CHANNEL_HOPPING_MODES_COUNT = 10
RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE = 0x80
RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL)
RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT)
RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE)
RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE)
RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1)
RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE)
RAIL_RX_CHANNEL_HOPPING_MODE_SQ_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_SQ)
RAIL_RX_CHANNEL_HOPPING_MODE_CONC_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_CONC)
RAIL_RX_CHANNEL_HOPPING_MODE_VT_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_VT)
RAIL_RX_CHANNEL_HOPPING_MODE_TX_WITH_OPTIONS = (RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE + RAIL_RX_CHANNEL_HOPPING_MODE_TX)
}

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

enum
RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC = 0
}
enum
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT = 0
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT = 1
RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT = 2
RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT = 3
RAIL_RX_CHANNEL_HOPPING_OPTIONS_COUNT
}

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

enum
RAIL_STREAM_CARRIER_WAVE = 0
RAIL_STREAM_PN9_STREAM = 1
RAIL_STREAM_10_STREAM = 2
RAIL_STREAM_CARRIER_WAVE_PHASENOISE = 3
RAIL_STREAM_RAMP_STREAM = 4
RAIL_STREAM_CARRIER_WAVE_SHIFTED = 5
RAIL_STREAM_MODES_COUNT
}

Possible stream output modes.

enum
RAIL_VDET_MODE_DISABLED = 0u
RAIL_VDET_MODE_AUTOMATIC = 1u
RAIL_VDET_MODE_IMMEDIATE = 2u
RAIL_VDET_MODE_COUNT
}

VDET Modes.

enum
RAIL_VDET_RESOLUTION_10_BIT = 0u
RAIL_VDET_RESOLUTION_11_BIT = 1u
RAIL_VDET_RESOLUTION_12_BIT = 2u
RAIL_VDET_RESOLUTION_COUNT
}

VDET Resolution for the AuxADC.

enum
RAIL_VDET_STATUS_IDLE = 0u
RAIL_VDET_STATUS_START = 1u
RAIL_VDET_STATUS_10_BIT_DONE = 2u
RAIL_VDET_STATUS_11_BIT_DONE = 3u
RAIL_VDET_STATUS_12_BIT_DONE = 4u
RAIL_VDET_STATUS_BLOCKED = 5u
RAIL_VDET_STATUS_ERROR = 6u
RAIL_VDET_STATUS_COUNT
}

VDET Status.

enum
RAIL_RETIME_OPTION_HFXO_SHIFT = 0
RAIL_RETIME_OPTION_HFRCO_SHIFT = 1
RAIL_RETIME_OPTION_DCDC_SHIFT = 2
RAIL_RETIME_OPTION_LCD_SHIFT = 3
}

Retiming options bit shifts.

Typedefs#

typedef void *

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

typedef void(*
RAIL_InitCompleteCallbackPtr_t)(RAIL_Handle_t railHandle)

A pointer to init complete callback function.

typedef uint8_t

Provided for backwards compatibility.

typedef uint32_t

Time in microseconds.

typedef void(*
RAIL_TimerCallback_t)(RAIL_Handle_t cbArg)

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

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

Callback fired when timer expires.

typedef int16_t

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

typedef uint8_t

Raw power levels used directly by the RAIL_Get/SetTxPower API where a higher numerical value corresponds to a higher output power.

typedef uint32_t

PA power setting used directly by the RAIL_GetPaPowerSetting() and RAIL_SetPaPowerSetting() APIs which is decoded to the actual hardware register value(s).

typedef const uint32_t *

Pointer to a radio configuration array.

typedef void(*
RAIL_RadioConfigChangedCallback_t)(RAIL_Handle_t railHandle, const RAIL_ChannelConfigEntry_t *entry)

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

typedef uint32_t

Suitable type for the supported transition time range.

typedef uint8_t

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

typedef const void *

A handle used to reference a packet during reception processing.

typedef uint8_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.

typedef uint32_t

A calibration mask type.

typedef uint32_t

RAIL_RxIrCalValues_t.

A calibration value structure.

typedef void(*

A pointer to an RF Sense callback function.

typedef uint32_t

Rx channel hopping on-channel time.

typedef int16_t

Type that represents the number of Frequency Offset units.

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

A pointer to a verification callback function.

Macro Definition Documentation#

RAIL_ENUM#

#define RAIL_ENUM
Value:
(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.


Definition at line 50 of file common/rail_types.h

RAIL_ENUM_GENERIC#

#define RAIL_ENUM_GENERIC
Value:
(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.


Definition at line 54 of file common/rail_types.h

RAIL_EFR32_HANDLE#

#define RAIL_EFR32_HANDLE
Value:
((RAIL_Handle_t)0xFFFFFFFFUL)

A placeholder for a radio-generic RAIL handle.

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

This generic handle can and should be used for RAIL APIs that are called prior to RAIL initialization.


Definition at line 118 of file common/rail_types.h

RAIL_DMA_INVALID#

#define RAIL_DMA_INVALID
Value:
(0xFFU)

A value to signal that RAIL should not use DMA.


Definition at line 165 of file common/rail_types.h

RAIL_TIMER_SYNC_DEFAULT#

#define RAIL_TIMER_SYNC_DEFAULT
Value:
{ \
.prsChannel = RAIL_TIMER_SYNC_PRS_CHANNEL_DEFAULT, \
.rtccChannel = RAIL_TIMER_SYNC_RTCC_CHANNEL_DEFAULT, \
.sleep = RAIL_SLEEP_CONFIG_TIMERSYNC_ENABLED, \
}

Default timer synchronization configuration.


Definition at line 474 of file common/rail_types.h

RAIL_SCHEDULER_STATUS_MASK#

#define RAIL_SCHEDULER_STATUS_MASK
Value:
0x0FU

Radio Scheduler Status mask.


Definition at line 523 of file common/rail_types.h

RAIL_SCHEDULER_STATUS_SHIFT#

#define RAIL_SCHEDULER_STATUS_SHIFT
Value:
0

Radio Scheduler Status shift.


Definition at line 525 of file common/rail_types.h

RAIL_SCHEDULER_TASK_MASK#

#define RAIL_SCHEDULER_TASK_MASK
Value:
0xF0U

Radio Scheduler Task mask.


Definition at line 528 of file common/rail_types.h

RAIL_SCHEDULER_TASK_SHIFT#

#define RAIL_SCHEDULER_TASK_SHIFT
Value:
4

Radio Scheduler Task shift.


Definition at line 530 of file common/rail_types.h

RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT#

#define RAIL_EVENT_SCHEDULED_TX_STARTED_SHIFT
Value:
RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT

Shift position of RAIL_EVENT_SCHEDULED_TX_STARTED bit.


Definition at line 921 of file common/rail_types.h

RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT#

#define RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT
Value:
RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT

Shift position of RAIL_EVENT_RX_DUTY_CYCLE_RX_END bit.


Definition at line 923 of file common/rail_types.h

RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT#

#define RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT
Value:
RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT

Shift position of RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT bit.


Definition at line 925 of file common/rail_types.h

RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT#

#define RAIL_EVENT_MFM_TX_BUFFER_DONE_SHIFT
Value:
RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT

Shift position of RAIL_EVENT_MFM_TX_BUFFER_DONE bit.


Definition at line 927 of file common/rail_types.h

RAIL_EVENTS_NONE#

#define RAIL_EVENTS_NONE
Value:
0ULL

A value representing no events.


Definition at line 932 of file common/rail_types.h

RAIL_EVENT_RSSI_AVERAGE_DONE#

#define RAIL_EVENT_RSSI_AVERAGE_DONE
Value:
(1ULL << RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT)

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

Call RAIL_GetAverageRssi() to get the result.


Definition at line 941 of file common/rail_types.h

RAIL_EVENT_RX_ACK_TIMEOUT#

#define RAIL_EVENT_RX_ACK_TIMEOUT
Value:
(1ULL << RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT)

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

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

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


Definition at line 954 of file common/rail_types.h

RAIL_EVENT_RX_FIFO_ALMOST_FULL#

#define RAIL_EVENT_RX_FIFO_ALMOST_FULL
Value:
(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


Definition at line 971 of file common/rail_types.h

RAIL_EVENT_RX_PACKET_RECEIVED#

#define RAIL_EVENT_RX_PACKET_RECEIVED
Value:
(1ULL << RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT)

Occurs whenever a packet is received with RAIL_RX_PACKET_READY_SUCCESS or RAIL_RX_PACKET_READY_CRC_ERROR.

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


Definition at line 982 of file common/rail_types.h

RAIL_EVENT_RX_PREAMBLE_LOST#

#define RAIL_EVENT_RX_PREAMBLE_LOST
Value:
(1ULL << RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT)

Occurs when the radio has lost a preamble.

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

Note


Definition at line 994 of file common/rail_types.h

RAIL_EVENT_RX_PREAMBLE_DETECT#

#define RAIL_EVENT_RX_PREAMBLE_DETECT
Value:
(1ULL << RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT)

Occurs when the radio has detected a preamble.

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

Warnings

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


Definition at line 1011 of file common/rail_types.h

RAIL_EVENT_RX_SYNC1_DETECT#

#define RAIL_EVENT_RX_SYNC1_DETECT
Value:
(1ULL << RAIL_EVENT_RX_SYNC1_DETECT_SHIFT)

Occurs when the first sync word is detected.

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


Definition at line 1019 of file common/rail_types.h

RAIL_EVENT_RX_SYNC2_DETECT#

#define RAIL_EVENT_RX_SYNC2_DETECT
Value:
(1ULL << RAIL_EVENT_RX_SYNC2_DETECT_SHIFT)

Occurs when the second sync word is detected.

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


Definition at line 1027 of file common/rail_types.h

RAIL_EVENT_RX_FRAME_ERROR#

#define RAIL_EVENT_RX_FRAME_ERROR
Value:
(1ULL << RAIL_EVENT_RX_FRAME_ERROR_SHIFT)

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

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

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


Definition at line 1041 of file common/rail_types.h

RAIL_EVENT_RX_FIFO_FULL#

#define RAIL_EVENT_RX_FIFO_FULL
Value:
(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.


Definition at line 1061 of file common/rail_types.h

RAIL_EVENT_RX_FIFO_OVERFLOW#

#define RAIL_EVENT_RX_FIFO_OVERFLOW
Value:
(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.


Definition at line 1080 of file common/rail_types.h

RAIL_EVENT_RX_ADDRESS_FILTERED#

#define RAIL_EVENT_RX_ADDRESS_FILTERED
Value:
(1ULL << RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT)

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

This event can only occur after calling RAIL_EnableAddressFilter().


Definition at line 1088 of file common/rail_types.h

RAIL_EVENT_RX_TIMEOUT#

#define RAIL_EVENT_RX_TIMEOUT
Value:
(1ULL << RAIL_EVENT_RX_TIMEOUT_SHIFT)

Occurs when an RX event times out.

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


Definition at line 1097 of file common/rail_types.h

RAIL_EVENT_SCHEDULED_RX_STARTED#

#define RAIL_EVENT_SCHEDULED_RX_STARTED
Value:
(1ULL << RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT)

Occurs when a scheduled RX begins turning on the receiver.

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


Definition at line 1104 of file common/rail_types.h

RAIL_EVENT_SCHEDULED_TX_STARTED#

#define RAIL_EVENT_SCHEDULED_TX_STARTED
Value:
(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.


Definition at line 1111 of file common/rail_types.h

RAIL_EVENT_RX_SCHEDULED_RX_END#

#define RAIL_EVENT_RX_SCHEDULED_RX_END
Value:
(1ULL << RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT)

Occurs when the scheduled RX window ends.

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


Definition at line 1128 of file common/rail_types.h

RAIL_EVENT_RX_SCHEDULED_RX_MISSED#

#define RAIL_EVENT_RX_SCHEDULED_RX_MISSED
Value:
(1ULL << RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT)

Occurs when start of a scheduled receive is missed.

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


Definition at line 1136 of file common/rail_types.h

RAIL_EVENT_RX_PACKET_ABORTED#

#define RAIL_EVENT_RX_PACKET_ABORTED
Value:
(1ULL << RAIL_EVENT_RX_PACKET_ABORTED_SHIFT)

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

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


Definition at line 1152 of file common/rail_types.h

RAIL_EVENT_RX_FILTER_PASSED#

#define RAIL_EVENT_RX_FILTER_PASSED
Value:
(1ULL << RAIL_EVENT_RX_FILTER_PASSED_SHIFT)

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

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


Definition at line 1166 of file common/rail_types.h

RAIL_EVENT_RX_TIMING_LOST#

#define RAIL_EVENT_RX_TIMING_LOST
Value:
(1ULL << RAIL_EVENT_RX_TIMING_LOST_SHIFT)

Occurs when the modem timing is lost.

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

Note


Definition at line 1178 of file common/rail_types.h

RAIL_EVENT_RX_TIMING_DETECT#

#define RAIL_EVENT_RX_TIMING_DETECT
Value:
(1ULL << RAIL_EVENT_RX_TIMING_DETECT_SHIFT)

Occurs when the modem timing is detected.

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

Warnings

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


Definition at line 1193 of file common/rail_types.h

RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE#

#define RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE
Value:
(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.

Warnings


Definition at line 1212 of file common/rail_types.h

RAIL_EVENT_RX_DUTY_CYCLE_RX_END#

#define RAIL_EVENT_RX_DUTY_CYCLE_RX_END
Value:
(1ULL << RAIL_EVENT_RX_DUTY_CYCLE_RX_END_SHIFT)

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

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


Definition at line 1221 of file common/rail_types.h

RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND#

#define RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND
Value:
(1ULL << RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT)

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

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

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


Definition at line 1237 of file common/rail_types.h

RAIL_EVENT_ZWAVE_BEAM#

#define RAIL_EVENT_ZWAVE_BEAM
Value:
(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


Definition at line 1254 of file common/rail_types.h

RAIL_EVENT_MFM_TX_BUFFER_DONE#

#define RAIL_EVENT_MFM_TX_BUFFER_DONE
Value:
(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.


Definition at line 1265 of file common/rail_types.h

RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND#

#define RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND
Value:
(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.


Definition at line 1275 of file common/rail_types.h

RAIL_EVENTS_RX_COMPLETION#

#define RAIL_EVENTS_RX_COMPLETION
Value:
(RAIL_EVENT_RX_PACKET_RECEIVED \
| RAIL_EVENT_RX_PACKET_ABORTED \
| RAIL_EVENT_RX_FRAME_ERROR \
| RAIL_EVENT_RX_FIFO_OVERFLOW \
| RAIL_EVENT_RX_ADDRESS_FILTERED \
| RAIL_EVENT_RX_SCHEDULED_RX_MISSED)

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

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


Definition at line 1290 of file common/rail_types.h

RAIL_EVENT_TX_FIFO_ALMOST_EMPTY#

#define RAIL_EVENT_TX_FIFO_ALMOST_EMPTY
Value:
(1ULL << RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT)

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

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

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


Definition at line 1311 of file common/rail_types.h

RAIL_EVENT_TX_PACKET_SENT#

#define RAIL_EVENT_TX_PACKET_SENT
Value:
(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


Definition at line 1322 of file common/rail_types.h

RAIL_EVENT_TXACK_PACKET_SENT#

#define RAIL_EVENT_TXACK_PACKET_SENT
Value:
(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


Definition at line 1334 of file common/rail_types.h

RAIL_EVENT_TX_ABORTED#

#define RAIL_EVENT_TX_ABORTED
Value:
(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.


Definition at line 1346 of file common/rail_types.h

RAIL_EVENT_TXACK_ABORTED#

#define RAIL_EVENT_TXACK_ABORTED
Value:
(1ULL << RAIL_EVENT_TXACK_ABORTED_SHIFT)

Occurs when an ACK transmit is aborted by the user.

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


Definition at line 1355 of file common/rail_types.h

RAIL_EVENT_TX_BLOCKED#

#define RAIL_EVENT_TX_BLOCKED
Value:
(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.


Definition at line 1365 of file common/rail_types.h

RAIL_EVENT_TXACK_BLOCKED#

#define RAIL_EVENT_TXACK_BLOCKED
Value:
(1ULL << RAIL_EVENT_TXACK_BLOCKED_SHIFT)

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

This event can only occur after calling RAIL_ConfigAutoAck().


Definition at line 1373 of file common/rail_types.h

RAIL_EVENT_TX_UNDERFLOW#

#define RAIL_EVENT_TX_UNDERFLOW
Value:
(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.


Definition at line 1387 of file common/rail_types.h

RAIL_EVENT_TXACK_UNDERFLOW#

#define RAIL_EVENT_TXACK_UNDERFLOW
Value:
(1ULL << RAIL_EVENT_TXACK_UNDERFLOW_SHIFT)

Occurs when the ACK transmit buffer underflows.

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

This event can only occur after calling RAIL_ConfigAutoAck().


Definition at line 1399 of file common/rail_types.h

RAIL_EVENT_TX_CHANNEL_CLEAR#

#define RAIL_EVENT_TX_CHANNEL_CLEAR
Value:
(1ULL << RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT)

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

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


Definition at line 1408 of file common/rail_types.h

RAIL_EVENT_TX_CHANNEL_BUSY#

#define RAIL_EVENT_TX_CHANNEL_BUSY
Value:
(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.


Definition at line 1420 of file common/rail_types.h

RAIL_EVENT_TX_CCA_RETRY#

#define RAIL_EVENT_TX_CCA_RETRY
Value:
(1ULL << RAIL_EVENT_TX_CCA_RETRY_SHIFT)

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

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


Definition at line 1431 of file common/rail_types.h

RAIL_EVENT_TX_START_CCA#

#define RAIL_EVENT_TX_START_CCA
Value:
(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().


Definition at line 1444 of file common/rail_types.h

RAIL_EVENT_TX_STARTED#

#define RAIL_EVENT_TX_STARTED
Value:
(1ULL << RAIL_EVENT_TX_STARTED_SHIFT)

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

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

Note

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


Definition at line 1457 of file common/rail_types.h

RAIL_TX_STARTED_BYTES#

#define RAIL_TX_STARTED_BYTES
Value:
0U

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


Definition at line 1463 of file common/rail_types.h

RAIL_EVENT_TX_SCHEDULED_TX_MISSED#

#define RAIL_EVENT_TX_SCHEDULED_TX_MISSED
Value:
(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.


Definition at line 1474 of file common/rail_types.h

RAIL_EVENTS_TX_COMPLETION#

#define RAIL_EVENTS_TX_COMPLETION
Value:
(RAIL_EVENT_TX_PACKET_SENT \
| RAIL_EVENT_TX_ABORTED \
| RAIL_EVENT_TX_BLOCKED \
| RAIL_EVENT_TX_UNDERFLOW \
| RAIL_EVENT_TX_CHANNEL_BUSY \
| RAIL_EVENT_TX_SCHEDULED_TX_MISSED)

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

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


Definition at line 1486 of file common/rail_types.h

RAIL_EVENTS_TXACK_COMPLETION#

#define RAIL_EVENTS_TXACK_COMPLETION
Value:
(RAIL_EVENT_TXACK_PACKET_SENT \
| RAIL_EVENT_TXACK_ABORTED \
| RAIL_EVENT_TXACK_BLOCKED \
| RAIL_EVENT_TXACK_UNDERFLOW)

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

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


Definition at line 1504 of file common/rail_types.h

RAIL_EVENT_CONFIG_UNSCHEDULED#

#define RAIL_EVENT_CONFIG_UNSCHEDULED
Value:
(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.


Definition at line 1524 of file common/rail_types.h

RAIL_EVENT_CONFIG_SCHEDULED#

#define RAIL_EVENT_CONFIG_SCHEDULED
Value:
(1ULL << RAIL_EVENT_CONFIG_SCHEDULED_SHIFT)

Occurs when the scheduler switches to this configuration.

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

Note

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


Definition at line 1538 of file common/rail_types.h

RAIL_EVENT_SCHEDULER_STATUS#

#define RAIL_EVENT_SCHEDULER_STATUS
Value:
(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


Definition at line 1556 of file common/rail_types.h

RAIL_EVENT_CAL_NEEDED#

#define RAIL_EVENT_CAL_NEEDED
Value:
(1ULL << RAIL_EVENT_CAL_NEEDED_SHIFT)

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

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


Definition at line 1566 of file common/rail_types.h

RAIL_EVENT_RF_SENSED#

#define RAIL_EVENT_RF_SENSED
Value:
(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.


Definition at line 1577 of file common/rail_types.h

RAIL_EVENT_PA_PROTECTION#

#define RAIL_EVENT_PA_PROTECTION
Value:
(1ULL << RAIL_EVENT_PA_PROTECTION_SHIFT)

Occurs when PA protection circuit kicks in.


Definition at line 1582 of file common/rail_types.h

RAIL_EVENT_SIGNAL_DETECTED#

#define RAIL_EVENT_SIGNAL_DETECTED
Value:
(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.


Definition at line 1591 of file common/rail_types.h

RAIL_EVENT_IEEE802154_MODESWITCH_START#

#define RAIL_EVENT_IEEE802154_MODESWITCH_START
Value:
(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.


Definition at line 1602 of file common/rail_types.h

RAIL_EVENT_IEEE802154_MODESWITCH_END#

#define RAIL_EVENT_IEEE802154_MODESWITCH_END
Value:
(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.


Definition at line 1614 of file common/rail_types.h

RAIL_EVENT_DETECT_RSSI_THRESHOLD#

#define RAIL_EVENT_DETECT_RSSI_THRESHOLD
Value:
(1ULL << RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT)

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


Definition at line 1620 of file common/rail_types.h

RAIL_EVENT_THERMISTOR_DONE#

#define RAIL_EVENT_THERMISTOR_DONE
Value:
(1ULL << RAIL_EVENT_THERMISTOR_DONE_SHIFT)

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


Definition at line 1626 of file common/rail_types.h

RAIL_EVENT_TX_BLOCKED_TOO_HOT#

#define RAIL_EVENT_TX_BLOCKED_TOO_HOT
Value:
(1ULL << RAIL_EVENT_TX_BLOCKED_TOO_HOT_SHIFT)

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

Deprecated


Definition at line 1633 of file common/rail_types.h

RAIL_EVENT_TEMPERATURE_TOO_HOT#

#define RAIL_EVENT_TEMPERATURE_TOO_HOT
Value:
(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.


Definition at line 1643 of file common/rail_types.h

RAIL_EVENT_TEMPERATURE_COOL_DOWN#

#define RAIL_EVENT_TEMPERATURE_COOL_DOWN
Value:
(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.


Definition at line 1653 of file common/rail_types.h

RAIL_EVENT_USER_MBOX#

#define RAIL_EVENT_USER_MBOX
Value:
(1ULL << RAIL_EVENT_USER_MBOX_SHIFT)

Occurs when the user received a mailbox message.


Definition at line 1658 of file common/rail_types.h

RAIL_EVENTS_ALL#

#define RAIL_EVENTS_ALL
Value:
0xFFFFFFFFFFFFFFFFULL

A value representing all possible events.


Definition at line 1661 of file common/rail_types.h

RAIL_TX_POWER_MAX#

#define RAIL_TX_POWER_MAX
Value:
((RAIL_TxPower_t)0x7FFF)

The maximum valid value for a RAIL_TxPower_t.


Definition at line 1721 of file common/rail_types.h

RAIL_TX_POWER_MIN#

#define RAIL_TX_POWER_MIN
Value:
((RAIL_TxPower_t)0x8000)

The minimum valid value for a RAIL_TxPower_t.


Definition at line 1723 of file common/rail_types.h

RAIL_TX_POWER_CURVE_DEFAULT_MAX#

#define RAIL_TX_POWER_CURVE_DEFAULT_MAX
Value:
((RAIL_TxPower_t)200)

The maximum power in deci-dBm the curve supports.


Definition at line 1726 of file common/rail_types.h

RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT#

#define RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT
Value:
((RAIL_TxPower_t)40)

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


Definition at line 1728 of file common/rail_types.h

RAIL_TX_POWER_VOLTAGE_SCALING_FACTOR#

#define RAIL_TX_POWER_VOLTAGE_SCALING_FACTOR
Value:
1000

mV are used for all TX power voltage values.

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


Definition at line 1732 of file common/rail_types.h

RAIL_TX_POWER_DBM_SCALING_FACTOR#

#define RAIL_TX_POWER_DBM_SCALING_FACTOR
Value:
10

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

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


Definition at line 1736 of file common/rail_types.h

RAIL_TX_POWER_LEVEL_INVALID#

#define RAIL_TX_POWER_LEVEL_INVALID
Value:
(255U)

Invalid RAIL_TxPowerLevel_t value returned when an error occurs with RAIL_GetTxPower.


Definition at line 1754 of file common/rail_types.h

RAIL_TX_POWER_LEVEL_MAX#

#define RAIL_TX_POWER_LEVEL_MAX
Value:
(254U)

Sentinel value that can be passed to RAIL_SetTxPower to set the highest power level available on the current PA, regardless of which one is selected.


Definition at line 1761 of file common/rail_types.h

RAIL_TX_PA_POWER_SETTING_UNSUPPORTED#

#define RAIL_TX_PA_POWER_SETTING_UNSUPPORTED
Value:
(0U)

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


Definition at line 1774 of file common/rail_types.h

RAIL_TX_POWER_MODE_NAMES#

#define RAIL_TX_POWER_MODE_NAMES
Value:
{ \
"RAIL_TX_POWER_MODE_2P4GIG_HP", \
"RAIL_TX_POWER_MODE_2P4GIG_MP", \
"RAIL_TX_POWER_MODE_2P4GIG_LP", \
"RAIL_TX_POWER_MODE_2P4GIG_LLP", \
"RAIL_TX_POWER_MODE_2P4GIG_HIGHEST", \
"RAIL_TX_POWER_MODE_SUBGIG_POWERSETTING_TABLE", \
"RAIL_TX_POWER_MODE_SUBGIG_HP", \
"RAIL_TX_POWER_MODE_SUBGIG_MP", \
"RAIL_TX_POWER_MODE_SUBGIG_LP", \
"RAIL_TX_POWER_MODE_SUBGIG_LLP", \
"RAIL_TX_POWER_MODE_SUBGIG_HIGHEST", \
"RAIL_TX_POWER_MODE_OFDM_PA_POWERSETTING_TABLE", \
"RAIL_TX_POWER_MODE_NONE" \
}

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.


Definition at line 1898 of file common/rail_types.h

RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_OFDM#

#define RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_OFDM
Value:
(x)

Convenience macro for any OFDM mapping table mode.


Definition at line 1933 of file common/rail_types.h

RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_SUBGIG#

#define RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_SUBGIG
Value:
(x)

Convenience macro for any Sub-GHz mapping table mode.


Definition at line 1936 of file common/rail_types.h

RAIL_POWER_MODE_IS_ANY_OFDM#

#define RAIL_POWER_MODE_IS_ANY_OFDM
Value:
(x)

Convenience macro for any OFDM mode.


Definition at line 1939 of file common/rail_types.h

RAIL_SETFIXEDLENGTH_INVALID#

#define RAIL_SETFIXEDLENGTH_INVALID
Value:
(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.


Definition at line 2006 of file common/rail_types.h

RADIO_CONFIG_ENABLE_CONC_PHY#

#define RADIO_CONFIG_ENABLE_CONC_PHY
Value:
1

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

Needed for backwards compatibility.


Definition at line 2042 of file common/rail_types.h

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.


Definition at line 2049 of file common/rail_types.h

RAIL_FIFO_ALIGNMENT_TYPE#

#define RAIL_FIFO_ALIGNMENT_TYPE
Value:
uint32_t

Fixed-width type indicating the needed alignment for RX and TX FIFOs.


Definition at line 2508 of file common/rail_types.h

RAIL_FIFO_ALIGNMENT#

#define RAIL_FIFO_ALIGNMENT
Value:
(sizeof(RAIL_FIFO_ALIGNMENT_TYPE))

Alignment that is needed for the RX and TX FIFOs.


Definition at line 2511 of file common/rail_types.h

RAIL_FIFO_THRESHOLD_DISABLED#

#define RAIL_FIFO_THRESHOLD_DISABLED
Value:
0xFFFFU

A FIFO threshold value that disables the threshold.


Definition at line 2623 of file common/rail_types.h

RAIL_TRANSITION_TIME_KEEP#

#define RAIL_TRANSITION_TIME_KEEP
Value:
((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.


Definition at line 2668 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_INACTIVE#

#define RAIL_RF_STATE_DETAIL_INACTIVE
Value:
(0U)

Radio is inactive.


Definition at line 2864 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_IDLE_STATE#

#define RAIL_RF_STATE_DETAIL_IDLE_STATE
Value:
(1U << RAIL_RF_STATE_DETAIL_IDLE_STATE_SHIFT)

Radio is in or headed to the idle state.


Definition at line 2866 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_RX_STATE#

#define RAIL_RF_STATE_DETAIL_RX_STATE
Value:
(1U << RAIL_RF_STATE_DETAIL_RX_STATE_SHIFT)

Radio is in or headed to the receive state.


Definition at line 2868 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_TX_STATE#

#define RAIL_RF_STATE_DETAIL_TX_STATE
Value:
(1U << RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT)

Radio is in or headed to the transmit state.


Definition at line 2870 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_TRANSITION#

#define RAIL_RF_STATE_DETAIL_TRANSITION
Value:
(1U << RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT)

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


Definition at line 2872 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_ACTIVE#

#define RAIL_RF_STATE_DETAIL_ACTIVE
Value:
(1U << RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT)

Radio is actively transmitting or receiving.


Definition at line 2874 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_NO_FRAMES#

#define RAIL_RF_STATE_DETAIL_NO_FRAMES
Value:
(1U << RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT)

Radio has frame detect disabled.


Definition at line 2876 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_LBT#

#define RAIL_RF_STATE_DETAIL_LBT
Value:
(1U << RAIL_RF_STATE_DETAIL_LBT_SHIFT)

LBT/CSMA operation is currently ongoing.


Definition at line 2878 of file common/rail_types.h

RAIL_RF_STATE_DETAIL_CORE_STATE_MASK#

#define RAIL_RF_STATE_DETAIL_CORE_STATE_MASK
Value:
(RAIL_RF_STATE_DETAIL_IDLE_STATE \
| RAIL_RF_STATE_DETAIL_RX_STATE \
| RAIL_RF_STATE_DETAIL_TX_STATE)

Mask for core radio state bits.


Definition at line 2880 of file common/rail_types.h

RAIL_CHANNEL_HOPPING_BUFFER_SIZE_PER_CHANNEL_WORST_CASE#

#define RAIL_CHANNEL_HOPPING_BUFFER_SIZE_PER_CHANNEL_WORST_CASE
Value:
(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.


Definition at line 3013 of file common/rail_types.h

RAIL_STOP_MODES_NONE#

#define RAIL_STOP_MODES_NONE
Value:
(0U)

Do not stop any radio operations.


Definition at line 3037 of file common/rail_types.h

RAIL_STOP_MODE_ACTIVE#

#define RAIL_STOP_MODE_ACTIVE
Value:
(1U << RAIL_STOP_MODE_ACTIVE_SHIFT)

Stop active radio operations only.


Definition at line 3039 of file common/rail_types.h

RAIL_STOP_MODE_PENDING#

#define RAIL_STOP_MODE_PENDING
Value:
(1U << RAIL_STOP_MODE_PENDING_SHIFT)

Stop pending radio operations.


Definition at line 3041 of file common/rail_types.h

RAIL_STOP_MODES_ALL#

#define RAIL_STOP_MODES_ALL
Value:
(0xFFU)

Stop all radio operations.


Definition at line 3043 of file common/rail_types.h

RAIL_TX_OPTIONS_NONE#

#define RAIL_TX_OPTIONS_NONE
Value:
0UL

A value representing no options enabled.


Definition at line 3075 of file common/rail_types.h

RAIL_TX_OPTIONS_DEFAULT#

#define RAIL_TX_OPTIONS_DEFAULT
Value:
RAIL_TX_OPTIONS_NONE

All options disabled by default.

This is the fastest TX option to apply.


Definition at line 3078 of file common/rail_types.h

RAIL_TX_OPTION_WAIT_FOR_ACK#

#define RAIL_TX_OPTION_WAIT_FOR_ACK
Value:
(1UL << 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 isAck flag in RAIL_RxPacketDetails_t of a received packet will always be false. If auto-ACK is enabled, for instance using RAIL_ConfigAutoAck() or RAIL_IEEE802154_Init(), and if this option is false, the radio transitions to RAIL_AutoAckConfig_t::txTransitions's RAIL_StateTransitions_t::success state directly after transmitting a packet and does not wait for an ACK.


Definition at line 3092 of file common/rail_types.h

RAIL_TX_OPTION_REMOVE_CRC#

#define RAIL_TX_OPTION_REMOVE_CRC
Value:
(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.


Definition at line 3099 of file common/rail_types.h

RAIL_TX_OPTION_SYNC_WORD_ID#

#define RAIL_TX_OPTION_SYNC_WORD_ID
Value:
(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.


Definition at line 3111 of file common/rail_types.h

RAIL_TX_OPTION_ANTENNA0#

#define RAIL_TX_OPTION_ANTENNA0
Value:
(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.


Definition at line 3124 of file common/rail_types.h

RAIL_TX_OPTION_ANTENNA1#

#define RAIL_TX_OPTION_ANTENNA1
Value:
(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.


Definition at line 3137 of file common/rail_types.h

RAIL_TX_OPTION_ALT_PREAMBLE_LEN#

#define RAIL_TX_OPTION_ALT_PREAMBLE_LEN
Value:
(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.


Definition at line 3144 of file common/rail_types.h

RAIL_TX_OPTION_CCA_PEAK_RSSI#

#define RAIL_TX_OPTION_CCA_PEAK_RSSI
Value:
(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.


Definition at line 3154 of file common/rail_types.h

RAIL_TX_OPTION_CCA_ONLY#

#define RAIL_TX_OPTION_CCA_ONLY
Value:
(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 auto-ACK response) is complete.


Definition at line 3172 of file common/rail_types.h

RAIL_TX_OPTION_RESEND#

#define RAIL_TX_OPTION_RESEND
Value:
(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.


Definition at line 3189 of file common/rail_types.h

RAIL_TX_OPTION_CONCURRENT_PHY_ID#

#define RAIL_TX_OPTION_CONCURRENT_PHY_ID
Value:
(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.


Definition at line 3196 of file common/rail_types.h

RAIL_TX_OPTIONS_ALL#

#define RAIL_TX_OPTIONS_ALL
Value:
0xFFFFFFFFUL

A value representing all possible options.


Definition at line 3199 of file common/rail_types.h

RAIL_MAX_LBT_TRIES#

#define RAIL_MAX_LBT_TRIES
Value:
(15U)

The maximum number of LBT/CSMA retries supported.


Definition at line 3276 of file common/rail_types.h

RAIL_MAX_CSMA_EXPONENT#

#define RAIL_MAX_CSMA_EXPONENT
Value:
(8U)

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


Definition at line 3282 of file common/rail_types.h

RAIL_CSMA_CONFIG_802_15_4_2003_2p4_GHz_OQPSK_CSMA#

#define RAIL_CSMA_CONFIG_802_15_4_2003_2p4_GHz_OQPSK_CSMA
Value:
{ \
/* CSMA per 802.15.4-2003 on 2.4 GHz OSPSK, commonly used by ZigBee */ \
.csmaMinBoExp = 3, /* 2^3-1 for 0..7 backoffs on 1st try */ \
.csmaMaxBoExp = 5, /* 2^5-1 for 0..31 backoffs on 3rd+ tries */ \
.csmaTries = 5, /* 5 tries overall (4 re-tries) */ \
.ccaThreshold = -75, /* 10 dB above sensitivity */ \
.ccaBackoff = 320, /* 20 symbols at 16 us/symbol */ \
.ccaDuration = 128, /* 8 symbols at 16 us/symbol */ \
.csmaTimeout = 0, /* No timeout */ \
}

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


Definition at line 3425 of file common/rail_types.h

RAIL_CSMA_CONFIG_SINGLE_CCA#

#define RAIL_CSMA_CONFIG_SINGLE_CCA
Value:
{ \
/* Perform a single CCA after 'fixed' delay */ \
.csmaMinBoExp = 0, /* Used for fixed backoff */ \
.csmaMaxBoExp = 0, /* Used for fixed backoff */ \
.csmaTries = 1, /* Single try */ \
.ccaThreshold = -75, /* Override if not desired choice */ \
.ccaBackoff = 0, /* No backoff (override with fixed value) */ \
.ccaDuration = 128, /* Override if not desired length */ \
.csmaTimeout = 0, /* no timeout */ \
}

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.


Definition at line 3443 of file common/rail_types.h

RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1#

#define RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1
Value:
{ \
/* LBT per ETSI 300 220-1 V2.4.1 */ \
/* LBT time = random backoff of 0-5 ms in .5 ms increments plus 5 ms fixed */ \
.lbtMinBoRand = 0, /* */ \
.lbtMaxBoRand = 10, /* */ \
.lbtTries = RAIL_MAX_LBT_TRIES, /* the maximum supported */ \
.lbtThreshold = -87, /* */ \
.lbtBackoff = 500, /* 0.5 ms */ \
.lbtDuration = 5000, /* 5 ms */ \
.lbtTimeout = 0, /* No timeout (recommend user override) */ \
}

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.


Definition at line 3545 of file common/rail_types.h

RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0#

#define RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0
Value:
{ \
/* LBT per ETSI 300 220-1 V3.1.0 */ \
/* LBT time = random backoff of 160-4960 us in 160 us increments */ \
.lbtMinBoRand = 1, /* */ \
.lbtMaxBoRand = 31, /* app-chosen; 31*lbtBackoff = 4960 us */ \
.lbtTries = RAIL_MAX_LBT_TRIES, /* the maximum supported */ \
.lbtThreshold = -85, /* 15 dB above Rx sensitivity per Table 45 */ \
.lbtDuragion = 160, /* 160 us per Table 48 Minimum CCA interval */ \
.lbtTimeout = 0, /* No timeout (recommend user override) */ \
}

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.


Definition at line 3564 of file common/rail_types.h

RAIL_TX_REPEAT_OPTIONS_NONE#

#define RAIL_TX_REPEAT_OPTIONS_NONE
Value:
0U

A value representing no repeat options enabled.


Definition at line 3609 of file common/rail_types.h

RAIL_TX_REPEAT_OPTIONS_DEFAULT#

#define RAIL_TX_REPEAT_OPTIONS_DEFAULT
Value:
RAIL_TX_REPEAT_OPTIONS_NONE

All repeat options disabled by default.


Definition at line 3611 of file common/rail_types.h

RAIL_TX_REPEAT_OPTION_HOP#

#define RAIL_TX_REPEAT_OPTION_HOP
Value:
(1U << RAIL_TX_REPEAT_OPTION_HOP_SHIFT)

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


Definition at line 3616 of file common/rail_types.h

RAIL_TX_REPEAT_OPTION_START_TO_START#

#define RAIL_TX_REPEAT_OPTION_START_TO_START
Value:
(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.


Definition at line 3622 of file common/rail_types.h

RAIL_TX_REPEAT_INFINITE_ITERATIONS#

#define RAIL_TX_REPEAT_INFINITE_ITERATIONS
Value:
(0xFFFFU)

RAIL_TxRepeatConfig_t::iterations initializer configuring infinite repeated transmissions.


Definition at line 3668 of file common/rail_types.h

ADDRCONFIG_MATCH_TABLE_SINGLE_FIELD#

#define ADDRCONFIG_MATCH_TABLE_SINGLE_FIELD
Value:
(0x1FFFFFE)

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

The truth table for address matching is shown below.

No Match

Address 0

Address 1

Address 2

Address 3

No Match

0

1

1

1

1

Address 0

1

1

1

1

1

Address 1

1

1

1

1

1

Address 2

1

1

1

1

1

Address 3

1

1

1

1

1


Definition at line 3696 of file common/rail_types.h

ADDRCONFIG_MATCH_TABLE_DOUBLE_FIELD#

#define ADDRCONFIG_MATCH_TABLE_DOUBLE_FIELD
Value:
(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.

No Match

Address 0

Address 1

Address 2

Address 3

No Match

0

0

0

0

0

Address 0

0

1

0

0

0

Address 1

0

0

1

0

0

Address 2

0

0

0

1

0

Address 3

0

0

0

0

1


Definition at line 3708 of file common/rail_types.h

ADDRCONFIG_MAX_ADDRESS_FIELDS#

#define ADDRCONFIG_MAX_ADDRESS_FIELDS
Value:
(2)

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


Definition at line 3712 of file common/rail_types.h

RAIL_RX_OPTIONS_NONE#

#define RAIL_RX_OPTIONS_NONE
Value:
0

A value representing no options enabled.


Definition at line 3811 of file common/rail_types.h

RAIL_RX_OPTIONS_DEFAULT#

#define RAIL_RX_OPTIONS_DEFAULT
Value:
RAIL_RX_OPTIONS_NONE

All options are disabled by default.


Definition at line 3813 of file common/rail_types.h

RAIL_RX_OPTION_STORE_CRC#

#define RAIL_RX_OPTION_STORE_CRC
Value:
(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.


Definition at line 3820 of file common/rail_types.h

RAIL_RX_OPTION_IGNORE_CRC_ERRORS#

#define RAIL_RX_OPTION_IGNORE_CRC_ERRORS
Value:
(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


Definition at line 3831 of file common/rail_types.h

RAIL_RX_OPTION_ENABLE_DUALSYNC#

#define RAIL_RX_OPTION_ENABLE_DUALSYNC
Value:
(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.


Definition at line 3846 of file common/rail_types.h

RAIL_RX_OPTION_TRACK_ABORTED_FRAMES#

#define RAIL_RX_OPTION_TRACK_ABORTED_FRAMES
Value:
(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.


Definition at line 3859 of file common/rail_types.h

RAIL_RX_OPTION_REMOVE_APPENDED_INFO#

#define RAIL_RX_OPTION_REMOVE_APPENDED_INFO
Value:
(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


Definition at line 3873 of file common/rail_types.h

RAIL_RX_OPTION_ANTENNA0#

#define RAIL_RX_OPTION_ANTENNA0
Value:
(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().


Definition at line 3882 of file common/rail_types.h

RAIL_RX_OPTION_ANTENNA1#

#define RAIL_RX_OPTION_ANTENNA1
Value:
(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().


Definition at line 3891 of file common/rail_types.h

RAIL_RX_OPTION_ANTENNA_AUTO#

#define RAIL_RX_OPTION_ANTENNA_AUTO
Value:
(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().


Definition at line 3903 of file common/rail_types.h

RAIL_RX_OPTION_DISABLE_FRAME_DETECTION#

#define RAIL_RX_OPTION_DISABLE_FRAME_DETECTION
Value:
(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.


Definition at line 3911 of file common/rail_types.h

RAIL_RX_OPTION_CHANNEL_SWITCHING#

#define RAIL_RX_OPTION_CHANNEL_SWITCHING
Value:
(1U << RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT)

An option to enable IEEE 802.15.4 RX channel switching.

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

Note


Definition at line 3945 of file common/rail_types.h

RAIL_RX_OPTION_FAST_RX2RX#

#define RAIL_RX_OPTION_FAST_RX2RX
Value:
(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


Definition at line 3957 of file common/rail_types.h

RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION#

#define RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION
Value:
(1U << 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


Definition at line 3969 of file common/rail_types.h

RAIL_RX_OPTIONS_ALL#

#define RAIL_RX_OPTIONS_ALL
Value:
0xFFFFFFFFUL

A value representing all possible options.


Definition at line 3972 of file common/rail_types.h

RAIL_RSSI_INVALID_DBM#

#define RAIL_RSSI_INVALID_DBM
Value:
(-128)

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


Definition at line 3975 of file common/rail_types.h

RAIL_RSSI_INVALID#

#define RAIL_RSSI_INVALID
Value:
((int16_t)(RAIL_RSSI_INVALID_DBM * 4))

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


Definition at line 3977 of file common/rail_types.h

RAIL_RSSI_LOWEST#

#define RAIL_RSSI_LOWEST
Value:
((int16_t)(RAIL_RSSI_INVALID + 1))

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


Definition at line 3979 of file common/rail_types.h

RAIL_RSSI_OFFSET_MAX#

#define RAIL_RSSI_OFFSET_MAX
Value:
35

Maximum absolute value for RSSI offset.


Definition at line 3982 of file common/rail_types.h

RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT#

#define RAIL_GET_RSSI_WAIT_WITHOUT_TIMEOUT
Value:
((RAIL_Time_t)0xFFFFFFFFU)

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


Definition at line 3985 of file common/rail_types.h

RAIL_GET_RSSI_NO_WAIT#

#define RAIL_GET_RSSI_NO_WAIT
Value:
((RAIL_Time_t)0U)

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


Definition at line 3987 of file common/rail_types.h

RAIL_RX_PACKET_HANDLE_INVALID#

#define RAIL_RX_PACKET_HANDLE_INVALID
Value:
(NULL)

An invalid RX packet handle value.


Definition at line 4156 of file common/rail_types.h

RAIL_RX_PACKET_HANDLE_OLDEST#

#define RAIL_RX_PACKET_HANDLE_OLDEST
Value:
((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().


Definition at line 4163 of file common/rail_types.h

RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE#

#define RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE
Value:
((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.)


Definition at line 4171 of file common/rail_types.h

RAIL_RX_PACKET_HANDLE_NEWEST#

#define RAIL_RX_PACKET_HANDLE_NEWEST
Value:
((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.


Definition at line 4180 of file common/rail_types.h

RAIL_AUTOACK_MAX_LENGTH#

#define RAIL_AUTOACK_MAX_LENGTH
Value:
(64U)

Acknowledgment packets cannot be longer than 64 bytes.


Definition at line 4488 of file common/rail_types.h

ant0Loc#

#define ant0Loc
Value:
defaultPath

DeprecatedBackwards compatible name for RAIL_AntennaConfig_t::defaultPath field.


Definition at line 4559 of file common/rail_types.h

RAIL_INVALID_THERMISTOR_VALUE#

#define RAIL_INVALID_THERMISTOR_VALUE
Value:
(0xFFFFFFFFU)

A sentinel value to indicate an invalid thermistor measurement value.


Definition at line 4572 of file common/rail_types.h

RAIL_INVALID_PPM_VALUE#

#define RAIL_INVALID_PPM_VALUE
Value:
(-128)

A sentinel value to indicate an invalid PPM calculation value.


Definition at line 4574 of file common/rail_types.h

RAIL_CAL_TEMP_VCO#

#define RAIL_CAL_TEMP_VCO
Value:
(0x00000001U)

EFR32-specific temperature calibration bit.


Definition at line 4655 of file common/rail_types.h

RAIL_CAL_TEMP_HFXO#

#define RAIL_CAL_TEMP_HFXO
Value:
(0x00000002U)

EFR32-specific HFXO temperature check bit.

(Ignored if platform lacks RAIL_SUPPORTS_HFXO_COMPENSATION.)


Definition at line 4658 of file common/rail_types.h

RAIL_CAL_COMPENSATE_HFXO#

#define RAIL_CAL_COMPENSATE_HFXO
Value:
(0x00000004U)

EFR32-specific HFXO compensation bit.

(Ignored if platform lacks RAIL_SUPPORTS_HFXO_COMPENSATION.)


Definition at line 4661 of file common/rail_types.h

RAIL_CAL_RX_IRCAL#

#define RAIL_CAL_RX_IRCAL
Value:
(0x00010000U)

EFR32-specific IR calibration bit.


Definition at line 4663 of file common/rail_types.h

RAIL_CAL_OFDM_TX_IRCAL#

#define RAIL_CAL_OFDM_TX_IRCAL
Value:
(0x00100000U)

EFR32-specific Tx IR calibration bit.

(Ignored if platform lacks RAIL_SUPPORTS_OFDM_PA.)


Definition at line 4666 of file common/rail_types.h

RAIL_CAL_ONETIME_IRCAL#

#define RAIL_CAL_ONETIME_IRCAL
Value:
(RAIL_CAL_RX_IRCAL | RAIL_CAL_OFDM_TX_IRCAL)

A mask to run EFR32-specific IR calibrations.


Definition at line 4669 of file common/rail_types.h

RAIL_CAL_TEMP#

#define RAIL_CAL_TEMP
Value:
(RAIL_CAL_TEMP_VCO | RAIL_CAL_TEMP_HFXO | RAIL_CAL_COMPENSATE_HFXO)

A mask to run temperature-dependent calibrations.


Definition at line 4671 of file common/rail_types.h

RAIL_CAL_ONETIME#

#define RAIL_CAL_ONETIME
Value:
(RAIL_CAL_ONETIME_IRCAL)

A mask to run one-time calibrations.


Definition at line 4673 of file common/rail_types.h

RAIL_CAL_PERF#

#define RAIL_CAL_PERF
Value:
(0)

A mask to run optional performance calibrations.


Definition at line 4675 of file common/rail_types.h

RAIL_CAL_OFFLINE#

#define RAIL_CAL_OFFLINE
Value:
(RAIL_CAL_ONETIME_IRCAL)

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


Definition at line 4677 of file common/rail_types.h

RAIL_CAL_ALL#

#define RAIL_CAL_ALL
Value:
(RAIL_CAL_TEMP | RAIL_CAL_ONETIME)

A mask to run all possible calibrations for this chip.


Definition at line 4679 of file common/rail_types.h

RAIL_CAL_ALL_PENDING#

#define RAIL_CAL_ALL_PENDING
Value:
(0x00000000U)

A mask to run all pending calibrations.


Definition at line 4681 of file common/rail_types.h

RAIL_CAL_INVALID_VALUE#

#define RAIL_CAL_INVALID_VALUE
Value:
(0xFFFFFFFFU)

An invalid calibration value.


Definition at line 4683 of file common/rail_types.h

RAIL_MAX_RF_PATHS#

#define RAIL_MAX_RF_PATHS
Value:
2

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


Definition at line 4690 of file common/rail_types.h

RAIL_IRCALVALUES_RX_UNINIT#

#define RAIL_IRCALVALUES_RX_UNINIT
Value:
{ \
[0 ... RAIL_MAX_RF_PATHS - 1] = RAIL_CAL_INVALID_VALUE, \
}

A define to set all RAIL_RxIrCalValues_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.


Definition at line 4708 of file common/rail_types.h

RAIL_IRCALVALUES_TX_UNINIT#

#define RAIL_IRCALVALUES_TX_UNINIT
Value:
{ \
.dcOffsetIQ = RAIL_CAL_INVALID_VALUE, \
.phiEpsilon = RAIL_CAL_INVALID_VALUE, \
}

A define to set all RAIL_TxIrCalValues_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.


Definition at line 4737 of file common/rail_types.h

RAIL_IRCALVALUES_UNINIT#

#define RAIL_IRCALVALUES_UNINIT
Value:
{ \
.rxIrCalValues = RAIL_IRCALVALUES_RX_UNINIT, \
.txIrCalValues = RAIL_IRCALVALUES_TX_UNINIT, \
}

A define to set all RAIL_IrCalValues_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.


Definition at line 4764 of file common/rail_types.h

RAIL_IRCALVAL#

#define RAIL_IRCALVAL
Value:
(irCalStruct, rfPath)

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


Definition at line 4773 of file common/rail_types.h

RAIL_CALVALUES_UNINIT#

#define RAIL_CALVALUES_UNINIT
Value:
RAIL_IRCALVALUES_UNINIT

A define to set all RAIL_CalValues_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.


Definition at line 4793 of file common/rail_types.h

RAIL_PACTUNE_IGNORE#

#define RAIL_PACTUNE_IGNORE
Value:
(255U)

Use this value with either TX or RX values in RAIL_SetPaCTune to use whatever value is already set and do no update.

This value is provided to provide consistency across EFR32 chips, but technically speaking, all PA capacitance tuning values are invalid on EFR32XG21 parts, as RAIL_SetPaCTune is not supported on those parts.


Definition at line 4801 of file common/rail_types.h

RAIL_RFSENSE_LOW_SENSITIVITY_OFFSET#

#define RAIL_RFSENSE_LOW_SENSITIVITY_OFFSET
Value:
(0x20U)

RF Sense low sensitivity offset.


Definition at line 4823 of file common/rail_types.h

RAIL_RFSENSE_USE_HW_SYNCWORD#

#define RAIL_RFSENSE_USE_HW_SYNCWORD
Value:
(0U)

Use the MODEM default sync word.


Definition at line 4864 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US#

#define RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US
Value:
0x08000000UL

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


Definition at line 5088 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE#

#define RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE
Value:
0U

A value representing no options enabled.


Definition at line 5133 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT#

#define RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT
Value:
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.


Definition at line 5139 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT
Value:
RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT

DeprecatedPlease use RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT instead.


Definition at line 5143 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL
Value:
(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.


Definition at line 5148 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL
Value:
(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.


Definition at line 5153 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD
Value:
(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.


Definition at line 5161 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_STOP#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_STOP
Value:
(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT)

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


Definition at line 5166 of file common/rail_types.h

RAIL_CHANNEL_HOPPING_INVALID_INDEX#

#define RAIL_CHANNEL_HOPPING_INVALID_INDEX
Value:
(0xFEU)

A sentinel value to flag an invalid channel hopping index.


Definition at line 5436 of file common/rail_types.h

RAIL_FREQUENCY_OFFSET_MAX#

#define RAIL_FREQUENCY_OFFSET_MAX
Value:
((RAIL_FrequencyOffset_t) 0x3FFF)

The maximum frequency offset value supported.


Definition at line 5464 of file common/rail_types.h

RAIL_FREQUENCY_OFFSET_MIN#

#define RAIL_FREQUENCY_OFFSET_MIN
Value:
((RAIL_FrequencyOffset_t) -RAIL_FREQUENCY_OFFSET_MAX)

The minimum frequency offset value supported.


Definition at line 5469 of file common/rail_types.h

RAIL_FREQUENCY_OFFSET_INVALID#

#define RAIL_FREQUENCY_OFFSET_INVALID
Value:
((RAIL_FrequencyOffset_t) 0x8000)

Specify an invalid frequency offset value.

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


Definition at line 5475 of file common/rail_types.h

RAIL_VERIFY_DURATION_MAX#

#define RAIL_VERIFY_DURATION_MAX
Value:
0xFFFFFFFFUL

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


Definition at line 5549 of file common/rail_types.h

RAIL_VDET_MODE_ENUM_NAMES#

#define RAIL_VDET_MODE_ENUM_NAMES
Value:
{ \
"RAIL_VDET_MODE_DISABLED", \
"RAIL_VDET_MODE_AUTOMATIC", \
"RAIL_VDET_MODE_IMMEDIATE", \
}

A macro that is string versions of the calibration enums.


Definition at line 5637 of file common/rail_types.h

RAIL_VDET_RESOLUTION_ENUM_NAMES#

#define RAIL_VDET_RESOLUTION_ENUM_NAMES
Value:
{ \
"RAIL_VDET_RESOLUTION_10_BIT", \
"RAIL_VDET_RESOLUTION_11_BIT", \
"RAIL_VDET_RESOLUTION_12_BIT", \
}

A macro that is string versions of the resolution enums.


Definition at line 5673 of file common/rail_types.h

RAIL_VDET_STATUS_ENUM_NAMES#

#define RAIL_VDET_STATUS_ENUM_NAMES
Value:
{ \
"RAIL_VDET_STATUS_IDLE", \
"RAIL_VDET_STATUS_START", \
"RAIL_VDET_STATUS_10_BIT_DONE", \
"RAIL_VDET_STATUS_11_BIT_DONE", \
"RAIL_VDET_STATUS_12_BIT_DONE", \
"RAIL_VDET_STATUS_BLOCKED", \
"RAIL_VDET_STATUS_ERROR", \
}

A macro that is string versions of the status enums.


Definition at line 5722 of file common/rail_types.h

RAIL_CHIP_TEMP_THRESHOLD_MAX#

#define RAIL_CHIP_TEMP_THRESHOLD_MAX
Value:
(398U)

Maximum junction temperature in Kelvin.

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


Definition at line 5760 of file common/rail_types.h

RAIL_CHIP_TEMP_COOLDOWN_DEFAULT#

#define RAIL_CHIP_TEMP_COOLDOWN_DEFAULT
Value:
(7U)

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


Definition at line 5765 of file common/rail_types.h

RAIL_CHIP_TEMP_MEASURE_COUNT#

#define RAIL_CHIP_TEMP_MEASURE_COUNT
Value:
(3U)

Number of temperature values provided for the chip thermal protection.


Definition at line 5781 of file common/rail_types.h

RAIL_RETIME_OPTION_HFXO#

#define RAIL_RETIME_OPTION_HFXO
Value:
  (1U << RAIL_RETIME_OPTION_HFXO_SHIFT)

An option to configure HFXO retiming.


Definition at line 5830 of file common/rail_types.h

RAIL_RETIME_OPTION_HFRCO#

#define RAIL_RETIME_OPTION_HFRCO
Value:
  (1U << RAIL_RETIME_OPTION_HFRCO_SHIFT)

An option to configure HFRCO retiming.


Definition at line 5836 of file common/rail_types.h

RAIL_RETIME_OPTION_DCDC#

#define RAIL_RETIME_OPTION_DCDC
Value:
  (1U << RAIL_RETIME_OPTION_DCDC_SHIFT)

An option to configure DCDC retiming.

Ignored on platforms that lack DCDC.


Definition at line 5843 of file common/rail_types.h

RAIL_RETIME_OPTION_LCD#

#define RAIL_RETIME_OPTION_LCD
Value:
  (1U << RAIL_RETIME_OPTION_LCD_SHIFT)

An option to configure LCD retiming.

Ignored on platforms that lack LCD.


Definition at line 5850 of file common/rail_types.h

RAIL_RETIME_OPTIONS_NONE#

#define RAIL_RETIME_OPTIONS_NONE
Value:
0x0U

A value representing no retiming options.


Definition at line 5854 of file common/rail_types.h

RAIL_RETIME_OPTIONS_ALL#

#define RAIL_RETIME_OPTIONS_ALL
Value:
0xFFU

A value representing all retiming options.


Definition at line 5857 of file common/rail_types.h

Enumeration Documentation#

RAIL_Status_t#

RAIL_Status_t

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

Enumerator
RAIL_STATUS_NO_ERROR

RAIL function reports no error.

RAIL_STATUS_INVALID_PARAMETER

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

RAIL_STATUS_INVALID_STATE

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

RAIL_STATUS_INVALID_CALL

RAIL function is called in an invalid order.

RAIL_STATUS_SUSPENDED

RAIL function did not finish in the allotted time.

RAIL_STATUS_SCHED_ERROR

RAIL function could not be scheduled by the Radio scheduler.


Definition at line 125 of file common/rail_types.h

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.

Enumerator
RAIL_TIME_ABSOLUTE

The time specified is an exact time in the RAIL timebase.

RAIL_TIME_DELAY

The time specified is relative to the current time.

RAIL_TIME_DISABLED

The specified time is invalid and should be ignored.


Definition at line 229 of file common/rail_types.h

RAIL_PacketTimePosition_t#

RAIL_PacketTimePosition_t

The available packet timestamp position choices.

Enumerator
RAIL_PACKET_TIME_INVALID

Indicate that a timestamp is not to be or was not provided.

RAIL_PACKET_TIME_DEFAULT

Request the choice most expedient for RAIL to calculate, which may depend on the radio and/or its configuration.

RAIL_PACKET_TIME_AT_PREAMBLE_START

Request the timestamp corresponding to the first preamble bit sent or received.

RAIL_PACKET_TIME_AT_PREAMBLE_START_USED_TOTAL

Request the timestamp corresponding to the first preamble bit sent or received.

RAIL_PACKET_TIME_AT_SYNC_END

Request the timestamp corresponding to right after its last SYNC word bit has been sent or received.

RAIL_PACKET_TIME_AT_SYNC_END_USED_TOTAL

Request the timestamp corresponding to right after its last SYNC word bit has been sent or received.

RAIL_PACKET_TIME_AT_PACKET_END

Request the timestamp corresponding to right after its last bit has been sent or received.

RAIL_PACKET_TIME_AT_PACKET_END_USED_TOTAL

Request the timestamp corresponding to right after its last bit has been sent or received.

RAIL_PACKET_TIME_COUNT

A count of the choices in this enumeration.


Definition at line 312 of file common/rail_types.h

RAIL_SleepConfig_t#

RAIL_SleepConfig_t

The configuration.

Enumerator
RAIL_SLEEP_CONFIG_TIMERSYNC_DISABLED

Disable timer sync before and after sleep.

RAIL_SLEEP_CONFIG_TIMERSYNC_ENABLED

Enable timer sync before and after sleep.


Definition at line 435 of file common/rail_types.h

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.

Enumerator
RAIL_SCHEDULER_STATUS_NO_ERROR

Multiprotocol scheduler reports no error.

RAIL_SCHEDULER_STATUS_UNSUPPORTED

The scheduler is disabled or the requested scheduler operation is unsupported.

RAIL_SCHEDULER_STATUS_EVENT_INTERRUPTED

The scheduled task was started but was interrupted by a higher-priority event before it could be completed.

RAIL_SCHEDULER_STATUS_SCHEDULE_FAIL

Scheduled task could not be scheduled given its priority and the other tasks running on the system.

RAIL_SCHEDULER_STATUS_TASK_FAIL

Calling the RAIL API associated with the Radio scheduler task returned an error code.

RAIL_SCHEDULER_STATUS_INTERNAL_ERROR

An internal error occurred in scheduler data structures, which should not happen and indicates a problem.

RAIL_SCHEDULER_TASK_EMPTY

Radio scheduler has no task.

RAIL_SCHEDULER_TASK_SCHEDULED_RX

Radio scheduler calls RAIL_ScheduleRx().

RAIL_SCHEDULER_TASK_SCHEDULED_TX

Radio scheduler calls RAIL_StartScheduledTx().

RAIL_SCHEDULER_TASK_SINGLE_TX

Radio scheduler calls RAIL_StartTx().

RAIL_SCHEDULER_TASK_SINGLE_CCA_CSMA_TX

Radio scheduler calls RAIL_StartCcaCsmaTx().

RAIL_SCHEDULER_TASK_SINGLE_CCA_LBT_TX

Radio scheduler calls RAIL_StartCcaLbtTx().

RAIL_SCHEDULER_TASK_SCHEDULED_CCA_CSMA_TX

Radio scheduler calls RAIL_StartScheduledCcaCsmaTx().

RAIL_SCHEDULER_TASK_SCHEDULED_CCA_LBT_TX

Radio scheduler calls RAIL_StartScheduledCcaLbtTx().

RAIL_SCHEDULER_TASK_TX_STREAM

Radio scheduler calls RAIL_StartTxStream().

RAIL_SCHEDULER_TASK_AVERAGE_RSSI

Radio scheduler calls RAIL_StartAverageRssi().

RAIL_SCHEDULER_STATUS_SCHEDULED_TX_FAIL

RAIL_StartScheduledTx() returned error status.

RAIL_SCHEDULER_STATUS_SINGLE_TX_FAIL

RAIL_StartTx() returned error status.

RAIL_SCHEDULER_STATUS_CCA_CSMA_TX_FAIL

RAIL_StartCcaCsmaTx() returned error status.

RAIL_SCHEDULER_STATUS_CCA_LBT_TX_FAIL

RAIL_StartCcaLbtTx() returned error status.

RAIL_SCHEDULER_STATUS_SCHEDULED_RX_FAIL

RAIL_ScheduleRx() returned error status.

RAIL_SCHEDULER_STATUS_TX_STREAM_FAIL

RAIL_StartTxStream() returned error status.

RAIL_SCHEDULER_STATUS_AVERAGE_RSSI_FAIL

RAIL_StartAverageRssi() returned error status.

RAIL_SCHEDULER_SCHEDULED_RX_INTERNAL_ERROR

Multiprotocol scheduled receive function internal error.

RAIL_SCHEDULER_SCHEDULED_RX_SCHEDULING_ERROR

Multiprotocol scheduled receive scheduling error.

RAIL_SCHEDULER_SCHEDULED_RX_INTERRUPTED

RAIL_ScheduleRx() operation interrupted

RAIL_SCHEDULER_SCHEDULED_TX_INTERNAL_ERROR

Multiprotocol scheduled TX internal error.

RAIL_SCHEDULER_SCHEDULED_TX_SCHEDULING_ERROR

Multiprotocol scheduled TX scheduling error.

RAIL_SCHEDULER_SCHEDULED_TX_INTERRUPTED

RAIL_StartScheduledTx() operation interrupted

RAIL_SCHEDULER_SINGLE_TX_INTERNAL_ERROR

Multiprotocol instantaneous TX internal error.

RAIL_SCHEDULER_SINGLE_TX_SCHEDULING_ERROR

Multiprotocol instantaneous TX scheduling error.

RAIL_SCHEDULER_SINGLE_TX_INTERRUPTED

RAIL_StartTx() operation interrupted

RAIL_SCHEDULER_SINGLE_CCA_CSMA_TX_INTERNAL_ERROR

Multiprotocol single CSMA transmit function internal error.

RAIL_SCHEDULER_SINGLE_CCA_CSMA_TX_SCHEDULING_ERROR

Multiprotocol single CSMA transmit scheduling error.

RAIL_SCHEDULER_SINGLE_CCA_CSMA_TX_INTERRUPTED

RAIL_StartCcaCsmaTx() operation interrupted

RAIL_SCHEDULER_SINGLE_CCA_LBT_TX_INTERNAL_ERROR

Multiprotocol single LBT transmit function internal error.

RAIL_SCHEDULER_SINGLE_CCA_LBT_TX_SCHEDULING_ERROR

Multiprotocol single LBT transmit scheduling error.

RAIL_SCHEDULER_SINGLE_CCA_LBT_TX_INTERRUPTED

RAIL_StartCcaLbtTx() operation interrupted

RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_INTERNAL_ERROR

Multiprotocol scheduled CSMA transmit function internal error.

RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_FAIL

RAIL_StartScheduledCcaCsmaTx() returned error status.

RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_SCHEDULING_ERROR

Multiprotocol scheduled CSMA transmit scheduling error.

RAIL_SCHEDULER_SCHEDULED_CCA_CSMA_TX_INTERRUPTED

RAIL_StartScheduledCcaCsmaTx() operation interrupted

RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_INTERNAL_ERROR

Multiprotocol scheduled LBT transmit function internal error.

RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_FAIL

RAIL_StartScheduledCcaLbtTx() returned error status.

RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_SCHEDULING_ERROR

Multiprotocol scheduled LBT transmit scheduling error.

RAIL_SCHEDULER_SCHEDULED_CCA_LBT_TX_INTERRUPTED

RAIL_StartScheduledCcaLbtTx() operation interrupted

RAIL_SCHEDULER_TX_STREAM_INTERNAL_ERROR

Multiprotocol stream transmit function internal error.

RAIL_SCHEDULER_TX_STREAM_SCHEDULING_ERROR

Multiprotocol stream transmit scheduling error.

RAIL_SCHEDULER_TX_STREAM_INTERRUPTED

RAIL_StartTxStream() operation interrupted

RAIL_SCHEDULER_AVERAGE_RSSI_INTERNAL_ERROR

Multiprotocol RSSI averaging function internal error.

RAIL_SCHEDULER_AVERAGE_RSSI_SCHEDULING_ERROR

Multiprotocol RSSI average scheduling error.

RAIL_SCHEDULER_AVERAGE_RSSI_INTERRUPTED

RAIL_StartAverageRssi() operation interrupted


Definition at line 540 of file common/rail_types.h

RAIL_TaskType_t#

RAIL_TaskType_t

Multiprotocol radio operation task types, used with RAIL_SetTaskPriority.

Enumerator
RAIL_TASK_TYPE_START_RX

Indicate a task started using RAIL_StartRx.

RAIL_TASK_TYPE_OTHER

Indicate a task started functions other than RAIL_StartRx.


Definition at line 772 of file common/rail_types.h

RAIL_Events_t#

RAIL_Events_t

RAIL events passed to the event callback.

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

Enumerator
RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT

Shift position of RAIL_EVENT_RSSI_AVERAGE_DONE bit.

RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT

Shift position of RAIL_EVENT_RX_ACK_TIMEOUT bit.

RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT

Shift position of RAIL_EVENT_RX_FIFO_ALMOST_FULL bit.

RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT

Shift position of RAIL_EVENT_RX_PACKET_RECEIVED bit.

RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT

Shift position of RAIL_EVENT_RX_PREAMBLE_LOST bit.

RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT

Shift position of RAIL_EVENT_RX_PREAMBLE_DETECT bit.

RAIL_EVENT_RX_SYNC1_DETECT_SHIFT

Shift position of RAIL_EVENT_RX_SYNC1_DETECT bit.

RAIL_EVENT_RX_SYNC2_DETECT_SHIFT

Shift position of RAIL_EVENT_RX_SYNC2_DETECT bit.

RAIL_EVENT_RX_FRAME_ERROR_SHIFT

Shift position of RAIL_EVENT_RX_FRAME_ERROR bit.

RAIL_EVENT_RX_FIFO_FULL_SHIFT

Shift position of RAIL_EVENT_RX_FIFO_FULL bit.

RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT

Shift position of RAIL_EVENT_RX_FIFO_OVERFLOW bit.

RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT

Shift position of RAIL_EVENT_RX_ADDRESS_FILTERED bit.

RAIL_EVENT_RX_TIMEOUT_SHIFT

Shift position of RAIL_EVENT_RX_TIMEOUT bit.

RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT

Shift position of RAIL_EVENT_SCHEDULED_RX_STARTED bit.

RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT

Shift position of RAIL_EVENT_RX_SCHEDULED_RX_END bit.

RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT

Shift position of RAIL_EVENT_RX_SCHEDULED_RX_MISSED bit.

RAIL_EVENT_RX_PACKET_ABORTED_SHIFT

Shift position of RAIL_EVENT_RX_PACKET_ABORTED bit.

RAIL_EVENT_RX_FILTER_PASSED_SHIFT

Shift position of RAIL_EVENT_RX_FILTER_PASSED bit.

RAIL_EVENT_RX_TIMING_LOST_SHIFT

Shift position of RAIL_EVENT_RX_TIMING_LOST bit.

RAIL_EVENT_RX_TIMING_DETECT_SHIFT

Shift position of RAIL_EVENT_RX_TIMING_DETECT bit.

RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT

Shift position of RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE bit.

RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT

Shift position of RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND bit.

RAIL_EVENT_ZWAVE_BEAM_SHIFT

Shift position of RAIL_EVENT_ZWAVE_BEAM bit.

RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT

Shift position of RAIL_EVENT_TX_FIFO_ALMOST_EMPTY bit.

RAIL_EVENT_TX_PACKET_SENT_SHIFT

Shift position of RAIL_EVENT_TX_PACKET_SENT bit.

RAIL_EVENT_TXACK_PACKET_SENT_SHIFT

Shift position of RAIL_EVENT_TXACK_PACKET_SENT bit.

RAIL_EVENT_TX_ABORTED_SHIFT

Shift position of RAIL_EVENT_TX_ABORTED bit.

RAIL_EVENT_TXACK_ABORTED_SHIFT

Shift position of RAIL_EVENT_TXACK_ABORTED bit.

RAIL_EVENT_TX_BLOCKED_SHIFT

Shift position of RAIL_EVENT_TX_BLOCKED bit.

RAIL_EVENT_TXACK_BLOCKED_SHIFT

Shift position of RAIL_EVENT_TXACK_BLOCKED bit.

RAIL_EVENT_TX_UNDERFLOW_SHIFT

Shift position of RAIL_EVENT_TX_UNDERFLOW bit.

RAIL_EVENT_TXACK_UNDERFLOW_SHIFT

Shift position of RAIL_EVENT_TXACK_UNDERFLOW bit.

RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT

Shift position of RAIL_EVENT_TX_CHANNEL_CLEAR bit.

RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT

Shift position of RAIL_EVENT_TX_CHANNEL_BUSY bit.

RAIL_EVENT_TX_CCA_RETRY_SHIFT

Shift position of RAIL_EVENT_TX_CCA_RETRY bit.

RAIL_EVENT_TX_START_CCA_SHIFT

Shift position of RAIL_EVENT_TX_START_CCA bit.

RAIL_EVENT_TX_STARTED_SHIFT

Shift position of RAIL_EVENT_TX_STARTED bit.

RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT

Shift position of RAIL_EVENT_TX_SCHEDULED_TX_MISSED bit.

RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT

Shift position of RAIL_EVENT_CONFIG_UNSCHEDULED bit.

RAIL_EVENT_CONFIG_SCHEDULED_SHIFT

Shift position of RAIL_EVENT_CONFIG_SCHEDULED bit.

RAIL_EVENT_SCHEDULER_STATUS_SHIFT

Shift position of RAIL_EVENT_SCHEDULER_STATUS bit.

RAIL_EVENT_CAL_NEEDED_SHIFT

Shift position of RAIL_EVENT_CAL_NEEDED bit.

RAIL_EVENT_RF_SENSED_SHIFT

Shift position of RAIL_EVENT_RF_SENSED bit.

RAIL_EVENT_PA_PROTECTION_SHIFT

Shift position of RAIL_EVENT_PA_PROTECTION bit.

RAIL_EVENT_SIGNAL_DETECTED_SHIFT

Shift position of RAIL_EVENT_SIGNAL_DETECTED bit.

RAIL_EVENT_IEEE802154_MODESWITCH_START_SHIFT

Shift position of RAIL_EVENT_IEEE802154_MODESWITCH_START bit.

RAIL_EVENT_IEEE802154_MODESWITCH_END_SHIFT

Shift position of RAIL_EVENT_IEEE802154_MODESWITCH_END bit.

RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT

Shift position of RAIL_EVENT_DETECT_RSSI_THRESHOLD bit.

RAIL_EVENT_THERMISTOR_DONE_SHIFT

Shift position of RAIL_EVENT_THERMISTOR_DONE bit.

RAIL_EVENT_TX_BLOCKED_TOO_HOT_SHIFT

Shift position of RAIL_EVENT_TX_BLOCKED_TOO_HOT bit.

RAIL_EVENT_TEMPERATURE_TOO_HOT_SHIFT

Shift position of RAIL_EVENT_TEMPERATURE_TOO_HOT bit.

RAIL_EVENT_TEMPERATURE_COOL_DOWN_SHIFT

Shift position of RAIL_EVENT_TEMPERATURE_COOL_DOWN bit.

RAIL_EVENT_USER_MBOX_SHIFT

Shift position of RAIL_EVENT_USER_MBOX bit.


Definition at line 800 of file common/rail_types.h

RAIL_TxPowerMode_t#

RAIL_TxPowerMode_t

An enumeration of the EFR32 power modes.

The power modes on the EFR32 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.

Enumerator
RAIL_TX_POWER_MODE_2P4GIG_HP

High-power 2.4 GHz amplifier EFR32xG21: up to 20 dBm, raw values: 1-180 EFR32xG22: up to 6 dBm, raw values: 1-128 EFR32xG24: up to 20 dBm, raw values: 0-180, or up to 10 dBm, raw values: 0-90 EFR32xG26: same as EFR32xG24 EFR32xG27: up to 6 dBm, raw values: 1-128 EFR32xG28: up to 10 dBm, raw values: 0-240 Not supported on other platforms.

RAIL_TX_POWER_MODE_2P4_HP

DeprecatedPlease use RAIL_TX_POWER_MODE_2P4GIG_HP instead.

RAIL_TX_POWER_MODE_2P4GIG_MP

Mid-power 2.4 GHz amplifier EFR32xG21: up to 10 dBm, raw values: 1-90 Not supported on other platforms.

RAIL_TX_POWER_MODE_2P4_MP

DeprecatedPlease use RAIL_TX_POWER_MODE_2P4GIG_MP instead.

RAIL_TX_POWER_MODE_2P4GIG_LP

Low-power 2.4 GHz amplifier EFR32xG21: up to 0 dBm, raw values: 1-64 EFR32xG22: up to 0 dBm, raw values: 1-16 EFR32xG24: up to 0 dBm, raw values: 1-16 EFR32xG26: same as EFR32xG24 EFR32xG27: up to 0 dBm, raw values: 1-16 Not supported on other platforms.

RAIL_TX_POWER_MODE_2P4_LP

DeprecatedPlease use RAIL_TX_POWER_MODE_2P4GIG_LP instead.

RAIL_TX_POWER_MODE_2P4GIG_LLP

Low-Low-power 2.4 GHz amplifier Not currently supported on any EFR32 platform.

RAIL_TX_POWER_MODE_2P4GIG_HIGHEST

Select the highest 2.4 GHz power PA available on the current chip.

RAIL_TX_POWER_MODE_2P4_HIGHEST

DeprecatedPlease use RAIL_TX_POWER_MODE_2P4GIG_HIGHEST instead.

RAIL_TX_POWER_MODE_SUBGIG_POWERSETTING_TABLE

PA for all Sub-GHz dBm values in range, using RAIL_PaPowerSetting_t table.

RAIL_TX_POWER_MODE_SUBGIG_HP

High-power Sub-GHz amplifier (Class D mode) Supported on FR32xG23 and EFR32xG28.

RAIL_TX_POWER_MODE_SUBGIG

DeprecatedPlease use RAIL_TX_POWER_MODE_SUBGIG_HP instead.

RAIL_TX_POWER_MODE_SUBGIG_MP

Mid-power Sub-GHz amplifier Supported only on EFR32xG23 and EFR32xG28.

RAIL_TX_POWER_MODE_SUBGIG_LP

Low-power Sub-GHz amplifier Supported only on EFR32xG23 and EFR32xG28.

RAIL_TX_POWER_MODE_SUBGIG_LLP

Low-Low-power Sub-GHz amplifier Supported only on EFR32xG23 and EFR32xG28.

RAIL_TX_POWER_MODE_SUBGIG_HIGHEST

Select the highest Sub-GHz power PA available on the current chip.

RAIL_TX_POWER_MODE_OFDM_PA_POWERSETTING_TABLE

PA for all OFDM Sub-GHz dBm values in range, using RAIL_PaPowerSetting_t table.

RAIL_TX_POWER_MODE_OFDM_PA

DeprecatedPlease use RAIL_TX_POWER_MODE_OFDM_PA_POWERSETTING_TABLE instead.

RAIL_TX_POWER_MODE_NONE

Invalid amplifier Selection.


Definition at line 1784 of file common/rail_types.h

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.

Enumerator
RAIL_CH_TYPE_NORMAL

Not a concurrent PHY.

RAIL_CH_TYPE_CONC_BASE

Base concurrent PHY.

RAIL_CH_TYPE_CONC_VIRTUAL

Virtual concurrent PHY.


Definition at line 2021 of file common/rail_types.h

RAIL_PtiMode_t#

RAIL_PtiMode_t

A channel type enumeration.

Enumerator
RAIL_PTI_MODE_DISABLED

Turn PTI off entirely.

RAIL_PTI_MODE_SPI

8-bit SPI mode.

RAIL_PTI_MODE_UART

8-bit UART mode.

RAIL_PTI_MODE_UART_ONEWIRE

9-bit UART mode.


Definition at line 2412 of file common/rail_types.h

RAIL_PtiProtocol_t#

RAIL_PtiProtocol_t

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

Enumerator
RAIL_PTI_PROTOCOL_CUSTOM

PTI output for a custom protocol.

RAIL_PTI_PROTOCOL_THREAD

PTI output for the Thread protocol.

RAIL_PTI_PROTOCOL_BLE

PTI output for the Bluetooth Smart protocol.

RAIL_PTI_PROTOCOL_CONNECT

PTI output for the Connect protocol.

RAIL_PTI_PROTOCOL_ZIGBEE

PTI output for the Zigbee protocol.

RAIL_PTI_PROTOCOL_ZWAVE

PTI output for the Z-Wave protocol.

RAIL_PTI_PROTOCOL_WISUN

PTI output for the Wi-SUN protocol.

RAIL_PTI_PROTOCOL_802154

PTI output for a custom protocol using a built-in 802.15.4 radio config.

RAIL_PTI_PROTOCOL_SIDEWALK

PTI output for Sidewalk protocol.


Definition at line 2464 of file common/rail_types.h

RAIL_TxDataSource_t#

RAIL_TxDataSource_t

Transmit data sources supported by RAIL.

Enumerator
TX_PACKET_DATA

Uses the frame hardware to packetize data.

TX_MFM_DATA

Uses the multi-level frequency modulation data.

RAIL_TX_DATA_SOURCE_COUNT

A count of the choices in this enumeration.


Definition at line 2517 of file common/rail_types.h

RAIL_RxDataSource_t#

RAIL_RxDataSource_t

Receive data sources supported by RAIL.

Note

Enumerator
RX_PACKET_DATA

Uses the frame hardware to packetize data.

RX_DEMOD_DATA

Gets 8-bit data output from the demodulator.

RX_IQDATA_FILTLSB

Gets lower 16 bits of I/Q data provided to the demodulator.

RX_IQDATA_FILTMSB

Gets highest 16 bits of I/Q data provided to the demodulator.

RX_DIRECT_MODE_DATA

Gets RX direct mode data output from the demodulator.

RX_DIRECT_SYNCHRONOUS_MODE_DATA

Gets synchronous RX direct mode data output from the demodulator.

RAIL_RX_DATA_SOURCE_COUNT

A count of the choices in this enumeration.


Definition at line 2546 of file common/rail_types.h

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.

Enumerator
PACKET_MODE

Packet-based data method.

FIFO_MODE

FIFO-based data method.

RAIL_DATA_METHOD_COUNT

A count of the choices in this enumeration.


Definition at line 2603 of file common/rail_types.h

RAIL_RadioState_t#

RAIL_RadioState_t

The state of the radio.

Enumerator
RAIL_RF_STATE_INACTIVE

Radio is inactive.

RAIL_RF_STATE_ACTIVE

Radio is either idle or, in combination with the RX and TX states, receiving or transmitting a frame.

RAIL_RF_STATE_RX

Radio is in receive.

RAIL_RF_STATE_TX

Radio is in transmit.

RAIL_RF_STATE_IDLE

Radio is idle.

RAIL_RF_STATE_RX_ACTIVE

Radio is actively receiving a frame.

RAIL_RF_STATE_TX_ACTIVE

Radio is actively transmitting a frame.


Definition at line 2713 of file common/rail_types.h

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.

Enumerator
RAIL_RF_STATE_DETAIL_IDLE_STATE_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_IDLE_STATE bit.

RAIL_RF_STATE_DETAIL_RX_STATE_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_RX_STATE bit.

RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_TX_STATE bit.

RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_TRANSITION bit.

RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_ACTIVE bit.

RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_NO_FRAMES bit.

RAIL_RF_STATE_DETAIL_LBT_SHIFT

Shift position of RAIL_RF_STATE_DETAIL_LBT bit.


Definition at line 2846 of file common/rail_types.h

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.

Enumerator
RAIL_IDLE

Idle the radio by turning off receive and canceling any future scheduled receive or transmit operations.

RAIL_IDLE_ABORT

Idle the radio by turning off receive and any scheduled events.

RAIL_IDLE_FORCE_SHUTDOWN

Force the radio into a shutdown mode by stopping whatever state is in progress.

RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS

Similar to the RAIL_IDLE_FORCE_SHUTDOWN command, however, it will also clear any pending RAIL events related to receive and transmit.


Definition at line 2889 of file common/rail_types.h

RAIL_StopMode_t#

RAIL_StopMode_t

Stop radio operation options bit mask.

Enumerator
RAIL_STOP_MODE_ACTIVE_SHIFT

Shift position of RAIL_STOP_MODE_ACTIVE bit.

RAIL_STOP_MODE_PENDING_SHIFT

Shift position of RAIL_STOP_MODE_PENDING bit.


Definition at line 3029 of file common/rail_types.h

RAIL_TxOptions_t#

RAIL_TxOptions_t

Transmit options, in reality a bitmask.

Enumerator
RAIL_TX_OPTION_WAIT_FOR_ACK_SHIFT

Shift position of RAIL_TX_OPTION_WAIT_FOR_ACK bit.

RAIL_TX_OPTION_REMOVE_CRC_SHIFT

Shift position of RAIL_TX_OPTION_REMOVE_CRC bit.

RAIL_TX_OPTION_SYNC_WORD_ID_SHIFT

Shift position of RAIL_TX_OPTION_SYNC_WORD_ID bit.

RAIL_TX_OPTION_ANTENNA0_SHIFT

Shift position of RAIL_TX_OPTION_ANTENNA0 bit.

RAIL_TX_OPTION_ANTENNA1_SHIFT

Shift position of RAIL_TX_OPTION_ANTENNA1 bit.

RAIL_TX_OPTION_ALT_PREAMBLE_LEN_SHIFT

Shift position of RAIL_TX_OPTION_ALT_PREAMBLE_LEN bit.

RAIL_TX_OPTION_CCA_PEAK_RSSI_SHIFT

Shift position of RAIL_TX_OPTION_CCA_PEAK_RSSI bit.

RAIL_TX_OPTION_CCA_ONLY_SHIFT

Shift position of RAIL_TX_OPTION_CCA_ONLY bit.

RAIL_TX_OPTION_RESEND_SHIFT

Shift position of RAIL_TX_OPTION_RESEND bit.

RAIL_TX_OPTION_CONCURRENT_PHY_ID_SHIFT

Shift position of RAIL_TX_OPTION_CONCURRENT_PHY_ID bit.

RAIL_TX_OPTIONS_COUNT

A count of the choices in this enumeration.


Definition at line 3049 of file common/rail_types.h

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.

Enumerator
RAIL_SCHEDULED_TX_DURING_RX_POSTPONE_TX

The scheduled TX will be postponed until RX completes and then sent.

RAIL_SCHEDULED_TX_DURING_RX_ABORT_TX

The scheduled TX will be aborted and a RAIL_EVENT_TX_BLOCKED event will fire.


Definition at line 3230 of file common/rail_types.h

RAIL_TxRepeatOptions_t#

RAIL_TxRepeatOptions_t

Transmit repeat options, in reality a bitmask.

Enumerator
RAIL_TX_REPEAT_OPTION_HOP_SHIFT

Shift position of RAIL_TX_REPEAT_OPTION_HOP bit.

RAIL_TX_REPEAT_OPTION_START_TO_START_SHIFT

Shift position of the RAIL_TX_REPEAT_OPTION_START_TO_START bit.


Definition at line 3601 of file common/rail_types.h

RAIL_RxOptions_t#

RAIL_RxOptions_t

Receive options, in reality a bitmask.

Enumerator
RAIL_RX_OPTION_STORE_CRC_SHIFT

Shift position of RAIL_RX_OPTION_STORE_CRC bit.

RAIL_RX_OPTION_IGNORE_CRC_ERRORS_SHIFT

Shift position of RAIL_RX_OPTION_IGNORE_CRC_ERRORS bit.

RAIL_RX_OPTION_ENABLE_DUALSYNC_SHIFT

Shift position of RAIL_RX_OPTION_ENABLE_DUALSYNC bit.

RAIL_RX_OPTION_TRACK_ABORTED_FRAMES_SHIFT

Shift position of RAIL_RX_OPTION_TRACK_ABORTED_FRAMES bit.

RAIL_RX_OPTION_REMOVE_APPENDED_INFO_SHIFT

Shift position of RAIL_RX_OPTION_REMOVE_APPENDED_INFO bit.

RAIL_RX_OPTION_ANTENNA0_SHIFT

Shift position of RAIL_RX_OPTION_ANTENNA0 bit.

RAIL_RX_OPTION_ANTENNA1_SHIFT

Shift position of RAIL_RX_OPTION_ANTENNA1 bit.

RAIL_RX_OPTION_DISABLE_FRAME_DETECTION_SHIFT

Shift position of RAIL_RX_OPTION_DISABLE_FRAME_DETECTION bit.

RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT

Shift position of RAIL_RX_OPTION_CHANNEL_SWITCHING bit.

RAIL_RX_OPTION_FAST_RX2RX_SHIFT

Shift position of RAIL_RX_OPTION_FAST_RX2RX bit.

RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION_SHIFT

Shift position of RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION bit.


Definition at line 3779 of file common/rail_types.h

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.

Enumerator
RAIL_RX_PACKET_NONE

The radio is idle or searching for a packet.

RAIL_RX_PACKET_ABORT_FORMAT

The packet was aborted during filtering because of illegal frame length, CRC or block decoding errors, other RAIL built-in protocol-specific packet content errors, or by the application or multiprotocol scheduler idling the radio with RAIL_IDLE_ABORT or higher.

RAIL_RX_PACKET_ABORT_FILTERED

The packet failed address filtering.

RAIL_RX_PACKET_ABORT_ABORTED

The packet passed any filtering but was aborted by the application or multiprotocol scheduler idling the radio with RAIL_IDLE_ABORT or higher.

RAIL_RX_PACKET_ABORT_OVERFLOW

The packet overflowed the receive buffer.

RAIL_RX_PACKET_ABORT_CRC_ERROR

The packet passed any filtering but subsequently failed CRC check(s) block decoding, or illegal frame length, and was aborted.

RAIL_RX_PACKET_READY_CRC_ERROR

The packet passed any filtering but subsequently failed CRC check(s) with RAIL_RX_OPTION_IGNORE_CRC_ERRORS in effect.

RAIL_RX_PACKET_READY_SUCCESS

The packet was successfully received, passing CRC check(s).

RAIL_RX_PACKET_RECEIVING

A packet is being received and is not yet complete.


Definition at line 4068 of file common/rail_types.h

RAIL_AntennaSel_t#

RAIL_AntennaSel_t

Antenna path Selection enumeration.

Enumerator
RAIL_ANTENNA_0

Enum for antenna path 0.

RAIL_ANTENNA_1

Enum for antenna path 1.

RAIL_ANTENNA_AUTO

Enum for antenna path auto.


Definition at line 4504 of file common/rail_types.h

RAIL_RfSenseBand_t#

RAIL_RfSenseBand_t

An enumeration for specifying the RF Sense frequency band.

Enumerator
RAIL_RFSENSE_OFF

RF Sense is disabled.

RAIL_RFSENSE_2_4GHZ

RF Sense is in 2.4 GHz band.

RAIL_RFSENSE_SUBGHZ

RF Sense is in sub-GHz band.

RAIL_RFSENSE_ANY

RF Sense is in both bands.

RAIL_RFSENSE_MAX

Must be last before sensitivity options.

RAIL_RFSENSE_2_4GHZ_LOW_SENSITIVITY

RF Sense is in low sensitivity 2.4 GHz band.

RAIL_RFSENSE_SUBGHZ_LOW_SENSITIVITY

RF Sense is in low sensitivity sub-GHz band.

RAIL_RFENSE_ANY_LOW_SENSITIVITY

RF Sense is in low sensitivity for both bands.


Definition at line 4829 of file common/rail_types.h

RAIL_RxChannelHoppingMode_t#

RAIL_RxChannelHoppingMode_t

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

Enumerator
RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL

Switch to the next channel each time the radio re-enters RX after packet reception or a transmit based on the corresponding State Transitions.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT

Switch to the next channel after a certain amount of time passes.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE

Listen in receive RX for at least a specified timeout.

RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE

Listen in receive RX for at least a specified timeout.

RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1

Placeholder for a reserved hopping mode that is not supported.

RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE

A mode that combines modes TIMING_SENSE, PREAMBLE_SENSE, and TIMEOUT (sync detect) all running in parallel.

RAIL_RX_CHANNEL_HOPPING_MODE_SQ

Switch to the next channel based on the demodulation settings in the PHY config.

RAIL_RX_CHANNEL_HOPPING_MODE_CONC

Marks that the channel is concurrent with another channel, and otherwise behaves identically to RAIL_RX_CHANNEL_HOPPING_MODE_SQ.

RAIL_RX_CHANNEL_HOPPING_MODE_VT

Indicates that this channel is a virtual channel that is concurrently detected with the channel indicated by the RAIL_RxChannelHoppingConfigEntry_t::parameter.

RAIL_RX_CHANNEL_HOPPING_MODE_TX

This is the transmit channel used for auto-ACK if the regular channel, specified in RAIL_RxChannelHoppingConfigEntry::parameter, is optimized for RX which may degrade some TX performance.

RAIL_RX_CHANNEL_HOPPING_MODES_COUNT

A count of the basic choices in this enumeration.

RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE

The start of equivalent modes requiring non-default RAIL_RxDutyCycleConfig_t::options, needed for backwards-compatibility with earlier RAIL_RxDutyCycleConfig_t format.

RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL with options.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT with options.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE with options.

RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE with options.

RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1 with options.

RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE with options.

RAIL_RX_CHANNEL_HOPPING_MODE_SQ_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_SQ with options.

RAIL_RX_CHANNEL_HOPPING_MODE_CONC_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_CONC with options.

RAIL_RX_CHANNEL_HOPPING_MODE_VT_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_VT with options.

RAIL_RX_CHANNEL_HOPPING_MODE_TX_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_TX with options.


Definition at line 4912 of file common/rail_types.h

RAIL_RxChannelHoppingDelayMode_t#

RAIL_RxChannelHoppingDelayMode_t

DeprecatedSet only to RAIL_RX_CHANNEL_DELAY_MODE_STATIC.

Enumerator
RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC

Always delay for exactly the amount of time specified in the delay parameter, regardless of how other channel hopping channels were extended via preamble sense or other means.


Definition at line 5094 of file common/rail_types.h

RAIL_RxChannelHoppingOptions_t#

RAIL_RxChannelHoppingOptions_t

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

Enumerator
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT

Shift position of RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL bit.

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT

Shift position of RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL bit.

RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT

Shift position of RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD bit.

RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT

Stop hopping on this hop.

RAIL_RX_CHANNEL_HOPPING_OPTIONS_COUNT

A count of the choices in this enumeration.


Definition at line 5119 of file common/rail_types.h

RAIL_StreamMode_t#

RAIL_StreamMode_t

Possible stream output modes.

Enumerator
RAIL_STREAM_CARRIER_WAVE

An unmodulated carrier wave.

RAIL_STREAM_PN9_STREAM

PN9 byte sequence.

RAIL_STREAM_10_STREAM

101010 sequence.

RAIL_STREAM_CARRIER_WAVE_PHASENOISE

An unmodulated carrier wave with no change to PLL BW.

RAIL_STREAM_RAMP_STREAM

ramp sequence starting at a different offset for consecutive packets.

RAIL_STREAM_CARRIER_WAVE_SHIFTED

An unmodulated carrier wave not centered on DC but shifted roughly by channel_bandwidth/6 allowing an easy check of the residual DC.

RAIL_STREAM_MODES_COUNT

A count of the choices in this enumeration.


Definition at line 5515 of file common/rail_types.h

RAIL_Vdet_Mode_t#

RAIL_Vdet_Mode_t

VDET Modes.

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

Enumerator
RAIL_VDET_MODE_DISABLED

VDET is completely disabled.

RAIL_VDET_MODE_AUTOMATIC

AUTOMATIC causes VDET measurements to be taken every Tx packet at the specified time.

RAIL_VDET_MODE_IMMEDIATE

IMMEDIATE causes an immediate VDET measurement.

RAIL_VDET_MODE_COUNT

A count of the choices in this enumeration.


Definition at line 5614 of file common/rail_types.h

RAIL_Vdet_Resolution_t#

RAIL_Vdet_Resolution_t

VDET Resolution for the AuxADC.

The VDET Resolution is passed to RAIL_ConfigVdet() via RAIL_VdetConfig_t. Shows available resolution options.

Enumerator
RAIL_VDET_RESOLUTION_10_BIT

~10 bit resolution.

RAIL_VDET_RESOLUTION_11_BIT

~11 bit resolution.

RAIL_VDET_RESOLUTION_12_BIT

~12 bit resolution.

RAIL_VDET_RESOLUTION_COUNT

A count of the choices in this enumeration.


Definition at line 5650 of file common/rail_types.h

RAIL_Vdet_Status_t#

RAIL_Vdet_Status_t

VDET Status.

The VDET Status for internal debug. Shows states.

Enumerator
RAIL_VDET_STATUS_IDLE

IDLE - Waiting for next command/measurement.

RAIL_VDET_STATUS_START

START of the VDET measurement activity.

RAIL_VDET_STATUS_10_BIT_DONE

Completion of a 10 bit measurement.

RAIL_VDET_STATUS_11_BIT_DONE

Completion of a 11 bit measurement.

RAIL_VDET_STATUS_12_BIT_DONE

Completion of a 12 bit measurement.

RAIL_VDET_STATUS_BLOCKED

Conflict with another AuxADC user.

RAIL_VDET_STATUS_ERROR

An error has occurred.

RAIL_VDET_STATUS_COUNT

A count of the choices in this enumeration.


Definition at line 5687 of file common/rail_types.h

RAIL_RetimeOptions_t#

RAIL_RetimeOptions_t

Retiming options bit shifts.

Enumerator
RAIL_RETIME_OPTION_HFXO_SHIFT

Shift position of RAIL_RETIME_OPTION_HFXO bit.

RAIL_RETIME_OPTION_HFRCO_SHIFT

Shift position of RAIL_RETIME_OPTION_HFRCO bit.

RAIL_RETIME_OPTION_DCDC_SHIFT

Shift position of RAIL_RETIME_OPTION_DCDC bit.

RAIL_RETIME_OPTION_LCD_SHIFT

Shift position of RAIL_RETIME_OPTION_LCD bit.


Definition at line 5815 of file common/rail_types.h

Typedef Documentation#

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.


Definition at line 108 of file common/rail_types.h

RAIL_InitCompleteCallbackPtr_t#

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

A pointer to init complete callback function.

Parameters
[in]railHandle

The initialized RAIL instance handle.


Definition at line 162 of file common/rail_types.h

RAIL_StateBuffer_t#

RAIL_StateBuffer_t [1]

Provided for backwards compatibility.


Definition at line 180 of file common/rail_types.h

RAIL_Time_t#

RAIL_Time_t

Time in microseconds.


Definition at line 213 of file common/rail_types.h

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.

Parameters
[in]cbArg

The argument passed to the callback.


Definition at line 220 of file common/rail_types.h

RAIL_MultiTimerCallback_t#

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

Callback fired when timer expires.

Parameters
[in]tmr

A pointer to an expired timer.

[in]expectedTimeOfEvent

An absolute time event fired.

[in]cbArg

A user-supplied callback argument.


Definition at line 278 of file common/rail_types.h

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.


Definition at line 1718 of file common/rail_types.h

RAIL_TxPowerLevel_t#

typedef uint8_t RAIL_TxPowerLevel_t

Raw power levels used directly by the RAIL_Get/SetTxPower API where a higher numerical value corresponds to a higher output power.

These are referred to as 'raw (values/units)'. On EFR32, they can range from one of RAIL_TX_POWER_LEVEL_2P4_LP_MIN, RAIL_TX_POWER_LEVEL_2P4_HP_MIN, or RAIL_TX_POWER_LEVEL_SUBGIG_HP_MIN to one of RAIL_TX_POWER_LEVEL_2P4_LP_MAX, RAIL_TX_POWER_LEVEL_2P4_HP_MAX, and RAIL_TX_POWER_LEVEL_SUBGIG_HP_MAX, respectively, depending on the selected RAIL_TxPowerMode_t.


Definition at line 1748 of file common/rail_types.h

RAIL_PaPowerSetting_t#

typedef uint32_t RAIL_PaPowerSetting_t

PA power setting used directly by the RAIL_GetPaPowerSetting() and RAIL_SetPaPowerSetting() APIs which is decoded to the actual hardware register value(s).


Definition at line 1768 of file common/rail_types.h

RAIL_RadioConfig_t#

typedef const uint32_t* RAIL_RadioConfig_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.


Definition at line 1959 of file common/rail_types.h

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.

Parameters
[in]railHandle

The corresponding RAIL instance handle.

[in]entry

A pointer to the radio configuration entry being changed to.


Definition at line 2394 of file common/rail_types.h

RAIL_TransitionTime_t#

RAIL_TransitionTime_t

Suitable type for the supported transition time range.

Refer to platform-specific RAIL_MINIMUM_TRANSITION_US and RAIL_MAXIMUM_TRANSITION_US for the valid range of this type.


Definition at line 2660 of file common/rail_types.h

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


Definition at line 3771 of file common/rail_types.h

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.


Definition at line 4153 of file common/rail_types.h

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.

Parameters
[in]lqi

The LQI value obtained by hardware and being readied for application consumption. This LQI value is in integral units ranging from 0 to 255.

[in]rssi

The RSSI value corresponding to the packet from which the hardware LQI value was obtained. This RSSI value is in integral dBm units.

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.


Definition at line 4369 of file common/rail_types.h

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.


Definition at line 4652 of file common/rail_types.h

RAIL_RxIrCalValues_t#

typedef uint32_t RAIL_RxIrCalValues_t[2] [2]

RAIL_RxIrCalValues_t.

RX IR calibration values.

Platforms with fewer RAIL_RF_PATHS than RAIL_MAX_RF_PATHS will only respect and update RAIL_RF_PATHS indices and ignore the rest.


Definition at line 4700 of file common/rail_types.h

RAIL_CalValues_t#

RAIL_CalValues_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 RAIL_CAL_INVALID_VALUE to force the code to compute that calibration value.


Definition at line 4785 of file common/rail_types.h

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.


Definition at line 4818 of file common/rail_types.h

RAIL_RxChannelHoppingParameter_t#

RAIL_RxChannelHoppingParameter_t

Rx channel hopping on-channel time.


Definition at line 5112 of file common/rail_types.h

RAIL_FrequencyOffset_t#

RAIL_FrequencyOffset_t

Type that represents the number of Frequency Offset units.

It is used with RAIL_GetRxFreqOffset() and RAIL_SetFreqOffset().

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


Definition at line 5459 of file common/rail_types.h

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.

Parameters
[in]address

The address of the data in question.

[in]expectedValue

The expected value of the data in question.

[in]actualValue

The actual value of the data in question.

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

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


Definition at line 5574 of file common/rail_types.h