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_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_EffCalConfig_t

RAIL_EffClpcSensorConfig_t

RAIL_EffClpcConfig_t

RAIL_EffClpcResults_t

RAIL_EffConfig_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 chip-specific RAIL handle.

#define
RAIL_DMA_INVALID (0xFFU)

A value to signal that RAIL should not use DMA.

#define
RAIL_SCHEDULER_STATUS_MASK 0x0FU

Radio Scheduler Status mask.

#define
RAIL_SCHEDULER_STATUS_SHIFT 0

Radio Scheduler Status shift.

#define
RAIL_SCHEDULER_TASK_MASK 0xF0U

Radio Scheduler Task mask.

#define
RAIL_SCHEDULER_TASK_SHIFT 4

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
RAIL_EVENTS_NONE 0ULL

A value representing no events.

#define
RAIL_EVENT_RSSI_AVERAGE_DONE (1ULL << RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT)

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

#define
RAIL_EVENT_RX_ACK_TIMEOUT (1ULL << RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT)

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

#define
RAIL_EVENT_RX_FIFO_ALMOST_FULL (1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT)

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
RAIL_EVENTS_RX_COMPLETION undefined

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
RAIL_TX_STARTED_BYTES 0U

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

#define
RAIL_EVENT_TX_SCHEDULED_TX_MISSED (1ULL << RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT)

Occurs when the start of a scheduled transmit is missed.

#define
RAIL_EVENTS_TX_COMPLETION undefined

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

#define
RAIL_EVENTS_TXACK_COMPLETION undefined

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_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
RAIL_TX_POWER_CURVE_DEFAULT_INCREMENT ((RAIL_TxPower_t)40)

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

#define
RAIL_TX_POWER_VOLTAGE_SCALING_FACTOR 1000

mV are used for all TX power voltage values.

#define
RAIL_TX_POWER_DBM_SCALING_FACTOR 10

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

#define
RAIL_TX_POWER_LEVEL_INVALID (255U)

Invalid RAIL_TxPowerLevel_t value returned when an error occurs with RAIL_GetTxPower.

#define
RAIL_TX_POWER_LEVEL_MAX (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.

#define
RAIL_TX_PA_POWER_SETTING_UNSUPPORTED (0U)

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

#define
RAIL_TX_POWER_MODE_NAMES undefined

The names of the TX power modes.

#define
RAIL_POWER_MODE_IS_ANY_EFF (x)

Convenience macro for any EFF power mode.

#define
RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_OFDM (x)

Convenience macro for any OFDM mapping table mode.

#define
RAIL_POWER_MODE_IS_DBM_POWERSETTING_MAPPING_TABLE_SUBGIG (x)

Convenience macro for any Sub-GHz mapping table mode.

#define
RAIL_POWER_MODE_IS_ANY_DBM_POWERSETTING_MAPPING_TABLE (x)

Convenience macro for any mapping table mode.

#define
RAIL_POWER_MODE_IS_ANY_OFDM (x)

Convenience macro for any OFDM mode.

#define
RAIL_SETFIXEDLENGTH_INVALID (0xFFFFU)

An invalid return value when calling RAIL_SetFixedLength().

#define
RADIO_CONFIG_ENABLE_CONC_PHY 1

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

#define
RADIO_CONFIG_ENABLE_STACK_INFO

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

#define
RAIL_FIFO_ALIGNMENT_TYPE uint32_t

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
RAIL_FIFO_THRESHOLD_DISABLED 0xFFFFU

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
RAIL_RF_STATE_DETAIL_INACTIVE (0U)

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
RAIL_RF_STATE_DETAIL_CORE_STATE_MASK undefined

Mask for core radio state bits.

#define
RAIL_CHANNEL_HOPPING_BUFFER_SIZE_PER_CHANNEL_WORST_CASE (65U)

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

#define
RAIL_STOP_MODES_NONE (0U)

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
RAIL_STOP_MODES_ALL (0xFFU)

Stop all radio operations.

#define
RAIL_TX_OPTIONS_NONE 0UL

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 to configure whether or not the TXing node will listen for an ACK.

#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
RAIL_MAX_LBT_TRIES (15U)

The maximum number of LBT/CSMA retries supported.

#define
RAIL_MAX_CSMA_EXPONENT (8U)

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

#define
RAIL_CSMA_CONFIG_802_15_4_2003_2p4_GHz_OQPSK_CSMA undefined

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

#define
RAIL_CSMA_CONFIG_SINGLE_CCA undefined

RAIL_CsmaConfig_t initializer configuring a single CCA prior to TX.

#define
RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V2_4_1 undefined

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

#define
RAIL_LBT_CONFIG_ETSI_EN_300_220_1_V3_1_0 undefined

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

#define
RAIL_TX_REPEAT_OPTIONS_NONE 0U

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_TX_REPEAT_INFINITE_ITERATIONS (0xFFFFU)

RAIL_TxRepeatConfig_t::iterations initializer configuring infinite repeated transmissions.

#define
ADDRCONFIG_MATCH_TABLE_SINGLE_FIELD (0x1FFFFFE)

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

#define
ADDRCONFIG_MATCH_TABLE_DOUBLE_FIELD (0x1041040)

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

#define
ADDRCONFIG_MAX_ADDRESS_FIELDS (2)

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

#define
RAIL_RX_OPTIONS_NONE 0

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
RAIL_RSSI_INVALID_DBM (-128)

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
RAIL_RSSI_OFFSET_MAX 35

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
RAIL_RX_PACKET_HANDLE_INVALID (NULL)

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
RAIL_AUTOACK_MAX_LENGTH (64U)

Acknowledgment packets cannot be longer than 64 bytes.

#define
defaultPath ant0Loc

Maps EFR32 Series 2 defaultPath onto Series 1 ant0Loc field.

#define
RAIL_INVALID_THERMISTOR_VALUE (0xFFFFFFFFU)

A sentinel value to indicate an invalid thermistor measurement value.

#define
RAIL_INVALID_PPM_VALUE (-128)

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
RAIL_CAL_COMPENSATE_HFXO (0x00000004U)

EFR32-specific HFXO compensation bit.

#define
RAIL_CAL_RX_IRCAL (0x00010000U)

EFR32-specific IR calibration bit.

#define
RAIL_CAL_OFDM_TX_IRCAL (0x00100000U)

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
RAIL_CAL_PERF (0)

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
RAIL_CAL_INVALID_VALUE (0xFFFFFFFFU)

An invalid calibration value.

#define
RAIL_MAX_RF_PATHS 2

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

#define
RAIL_IRCALVALUES_RX_UNINIT undefined

A define to set all RAIL_RxIrCalValues_t values to uninitialized.

#define
RAIL_IRCALVALUES_TX_UNINIT undefined

A define to set all RAIL_TxIrCalValues_t values to uninitialized.

#define
RAIL_IRCALVALUES_UNINIT undefined

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
RAIL_PACTUNE_IGNORE (255U)

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

#define
RAIL_RFSENSE_LOW_SENSITIVITY_OFFSET (0x20U)

RF Sense low sensitivity offset.

#define
RAIL_RFSENSE_USE_HW_SYNCWORD (0U)

Use the MODEM default sync word.

#define
RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US 0x08000000UL

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

#define
RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE 0U

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
RAIL_CHANNEL_HOPPING_INVALID_INDEX (0xFEU)

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
RAIL_VERIFY_DURATION_MAX 0xFFFFFFFFUL

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

#define
RAIL_EFF_SUPPORTS_TRANSMIT (x)

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

#define
RAIL_EFF_SUPPORTS_RECEIVE (x)

A macro that checks for EFFxx devices that support receive.

#define
RAIL_EFF_TEMP_THRESHOLD_MAX (383U)

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

#define
RAIL_EFF_MODE_SENSOR_ENUM_NAMES undefined

A macro that is string versions of the calibration enums.

#define
RAIL_EFF_CLPC_ENABLE_ENUM_NAMES undefined

A macro that is string versions of the calibration enums.

#define
RAIL_CHIP_TEMP_THRESHOLD_MAX (398U)

Maximum junction temperature in Kelvin.

#define
RAIL_CHIP_TEMP_COOLDOWN_DEFAULT (7U)

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

#define
RAIL_CHIP_TEMP_MEASURE_COUNT (3U)

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
RAIL_RETIME_OPTIONS_NONE 0x0U

A value representing no retiming options.

#define
RAIL_RETIME_OPTIONS_ALL 0xFFU

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
RAIL_TIME_DELAY
RAIL_TIME_DISABLED
}

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
}

The available packet timestamp position choices.

enum
RAIL_SLEEP_CONFIG_TIMERSYNC_DISABLED
RAIL_SLEEP_CONFIG_TIMERSYNC_ENABLED
}

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
RAIL_TASK_TYPE_OTHER
}

Multiprotocol radio operation task types, used with RAIL_SetTaskPriority.

enum
RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT = 0
RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT
RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT
RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT
RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT
RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT
RAIL_EVENT_RX_SYNC1_DETECT_SHIFT
RAIL_EVENT_RX_SYNC2_DETECT_SHIFT
RAIL_EVENT_RX_FRAME_ERROR_SHIFT
RAIL_EVENT_RX_FIFO_FULL_SHIFT
RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT
RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT
RAIL_EVENT_RX_TIMEOUT_SHIFT
RAIL_EVENT_SCHEDULED_RX_STARTED_SHIFT
RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT
RAIL_EVENT_RX_SCHEDULED_RX_MISSED_SHIFT
RAIL_EVENT_RX_PACKET_ABORTED_SHIFT
RAIL_EVENT_RX_FILTER_PASSED_SHIFT
RAIL_EVENT_RX_TIMING_LOST_SHIFT
RAIL_EVENT_RX_TIMING_DETECT_SHIFT
RAIL_EVENT_RX_CHANNEL_HOPPING_COMPLETE_SHIFT
RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT
RAIL_EVENT_ZWAVE_BEAM_SHIFT
RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT
RAIL_EVENT_TX_PACKET_SENT_SHIFT
RAIL_EVENT_TXACK_PACKET_SENT_SHIFT
RAIL_EVENT_TX_ABORTED_SHIFT
RAIL_EVENT_TXACK_ABORTED_SHIFT
RAIL_EVENT_TX_BLOCKED_SHIFT
RAIL_EVENT_TXACK_BLOCKED_SHIFT
RAIL_EVENT_TX_UNDERFLOW_SHIFT
RAIL_EVENT_TXACK_UNDERFLOW_SHIFT
RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT
RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT
RAIL_EVENT_TX_CCA_RETRY_SHIFT
RAIL_EVENT_TX_START_CCA_SHIFT
RAIL_EVENT_TX_STARTED_SHIFT
RAIL_EVENT_TX_SCHEDULED_TX_MISSED_SHIFT
RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT
RAIL_EVENT_CONFIG_SCHEDULED_SHIFT
RAIL_EVENT_SCHEDULER_STATUS_SHIFT
RAIL_EVENT_CAL_NEEDED_SHIFT
RAIL_EVENT_RF_SENSED_SHIFT
RAIL_EVENT_PA_PROTECTION_SHIFT
RAIL_EVENT_SIGNAL_DETECTED_SHIFT
RAIL_EVENT_IEEE802154_MODESWITCH_START_SHIFT
RAIL_EVENT_IEEE802154_MODESWITCH_END_SHIFT
RAIL_EVENT_DETECT_RSSI_THRESHOLD_SHIFT
RAIL_EVENT_THERMISTOR_DONE_SHIFT
RAIL_EVENT_TX_BLOCKED_TOO_HOT_SHIFT
RAIL_EVENT_TEMPERATURE_TOO_HOT_SHIFT
RAIL_EVENT_TEMPERATURE_COOL_DOWN_SHIFT
}

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
RAIL_PTI_MODE_SPI
RAIL_PTI_MODE_UART
RAIL_PTI_MODE_UART_ONEWIRE
}

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
TX_MFM_DATA
RAIL_TX_DATA_SOURCE_COUNT
}

Transmit data sources supported by RAIL.

enum
RX_PACKET_DATA
RX_DEMOD_DATA
RX_IQDATA_FILTLSB
RX_IQDATA_FILTMSB
RX_DIRECT_MODE_DATA
RX_DIRECT_SYNCHRONOUS_MODE_DATA
RAIL_RX_DATA_SOURCE_COUNT
}

Receive data sources supported by RAIL.

enum
PACKET_MODE
FIFO_MODE
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
RAIL_RF_STATE_DETAIL_TX_STATE_SHIFT
RAIL_RF_STATE_DETAIL_TRANSITION_SHIFT
RAIL_RF_STATE_DETAIL_ACTIVE_SHIFT
RAIL_RF_STATE_DETAIL_NO_FRAMES_SHIFT
RAIL_RF_STATE_DETAIL_LBT_SHIFT
}

The detailed state of the radio.

enum
RAIL_IDLE
RAIL_IDLE_ABORT
RAIL_IDLE_FORCE_SHUTDOWN
RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS
}

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
RAIL_TX_OPTION_SYNC_WORD_ID_SHIFT
RAIL_TX_OPTION_ANTENNA0_SHIFT
RAIL_TX_OPTION_ANTENNA1_SHIFT
RAIL_TX_OPTION_ALT_PREAMBLE_LEN_SHIFT
RAIL_TX_OPTION_CCA_PEAK_RSSI_SHIFT
RAIL_TX_OPTION_CCA_ONLY_SHIFT
RAIL_TX_OPTION_RESEND_SHIFT
RAIL_TX_OPTION_CONCURRENT_PHY_ID_SHIFT
RAIL_TX_OPTIONS_COUNT
}

Transmit options, in reality a bitmask.

enum
RAIL_SCHEDULED_TX_DURING_RX_POSTPONE_TX
RAIL_SCHEDULED_TX_DURING_RX_ABORT_TX
}

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
RAIL_RX_OPTION_ENABLE_DUALSYNC_SHIFT
RAIL_RX_OPTION_TRACK_ABORTED_FRAMES_SHIFT
RAIL_RX_OPTION_REMOVE_APPENDED_INFO_SHIFT
RAIL_RX_OPTION_ANTENNA0_SHIFT
RAIL_RX_OPTION_ANTENNA1_SHIFT
RAIL_RX_OPTION_DISABLE_FRAME_DETECTION_SHIFT
RAIL_RX_OPTION_CHANNEL_SWITCHING_SHIFT
RAIL_RX_OPTION_FAST_RX2RX_SHIFT
RAIL_RX_OPTION_ENABLE_COLLISION_DETECTION_SHIFT
}

Receive options, in reality a bitmask.

enum
RAIL_RX_PACKET_NONE = 0
RAIL_RX_PACKET_ABORT_FORMAT
RAIL_RX_PACKET_ABORT_FILTERED
RAIL_RX_PACKET_ABORT_ABORTED
RAIL_RX_PACKET_ABORT_OVERFLOW
RAIL_RX_PACKET_ABORT_CRC_ERROR
RAIL_RX_PACKET_READY_CRC_ERROR
RAIL_RX_PACKET_READY_SUCCESS
RAIL_RX_PACKET_RECEIVING
}

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
RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT
RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE
RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE
RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1
RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE
RAIL_RX_CHANNEL_HOPPING_MODE_SQ
RAIL_RX_CHANNEL_HOPPING_MODE_CONC
RAIL_RX_CHANNEL_HOPPING_MODE_VT
RAIL_RX_CHANNEL_HOPPING_MODE_TX
RAIL_RX_CHANNEL_HOPPING_MODES_COUNT
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_TIMEOUT_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_SQ_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_CONC_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_VT_WITH_OPTIONS
RAIL_RX_CHANNEL_HOPPING_MODE_TX_WITH_OPTIONS
}

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

enum
RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC
}
enum
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT
RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT
RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT
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_EFF_DEVICE_NONE = 0
RAIL_EFF_DEVICE_EFF01A11NMFA0
RAIL_EFF_DEVICE_EFF01B11NMFA0
RAIL_EFF_DEVICE_EFF01A11IMFB0
RAIL_EFF_DEVICE_EFF01B11IMFB0
RAIL_EFF_DEVICE_COUNT
}

EFF part numbers.

enum
RAIL_EFF_LNA_MODE_RURAL = (0x01U << 0)
RAIL_EFF_LNA_MODE_URBAN = (0x01U << 1)
RAIL_EFF_LNA_MODE_BYPASS = (0x01U << 2)
RAIL_EFF_LNA_MODE_COUNT = (0x01U << 3)
}

EFF LNA Modes.

enum
RAIL_EFF_CLPC_DISABLED = 0
RAIL_EFF_CLPC_MODE_CHANGE = 1
RAIL_EFF_CLPC_POWER_SLOW = 2
RAIL_EFF_CLPC_POWER_FAST = 3
RAIL_EFF_CLPC_POWER_BOTH = 4
RAIL_EFF_CLPC_POWER_SLOW_STOPPED = 5
RAIL_EFF_CLPC_POWER_FAST_STOPPED = 6
RAIL_EFF_CLPC_POWER_BOTH_STOPPED = 7
RAIL_EFF_CLPC_COUNT = 8
}

EFF Closed Loop Power Control (CLPC) Enable states.

enum
RAIL_EFF_MODE_SENSOR_FSK_ANTV = 0
RAIL_EFF_MODE_SENSOR_FSK_SAW2 = 1
RAIL_EFF_MODE_SENSOR_OFDM_ANTV = 2
RAIL_EFF_MODE_SENSOR_OFDM_SAW2 = 3
RAIL_EFF_MODE_SENSOR_COUNT
}

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

enum
RAIL_RETIME_OPTION_HFXO_SHIFT = 0
RAIL_RETIME_OPTION_HFRCO_SHIFT
RAIL_RETIME_OPTION_DCDC_SHIFT
RAIL_RETIME_OPTION_LCD_SHIFT
}

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.

Functions#

RAIL_ConfigRetimeOptions(RAIL_Handle_t railHandle, RAIL_RetimeOptions_t mask, RAIL_RetimeOptions_t options)

Configure retiming options.

RAIL_GetRetimeOptions(RAIL_Handle_t railHandle, RAIL_RetimeOptions_t *pOptions)

Get the currently configured retiming option.

Indicate that the DCDC peripheral bus clock enable has changed allowing RAIL to react accordingly.

 

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.


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.


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.


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.


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

Lower 4 bits of uint8_t capture the different Radio Scheduler errors.

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

Upper 4 bits of uint8_t capture the different Radio Scheduler tasks.

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


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.


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_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 EFR32xG1X: up to 20 dBm, raw values: 0-252 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 EFR32xG1x: up to 0 dBm, raw values: 1-7 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) EFR32xG1x: up to 20 dBm, raw values: 0-248 Also 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.


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.


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.


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

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.


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.


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.


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.


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.


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.


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.


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.


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.


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.


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.


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.


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.


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 G band.

RAIL_RFSENSE_SUBGHZ

RF Sense is in subgig band.

RAIL_RFSENSE_ANY

RF Sense is in both bands.

RAIL_RFSENSE_MAX
RAIL_RFSENSE_2_4GHZ_LOW_SENSITIVITY

RF Sense is in low sensitivity 2.4 G band.

RAIL_RFSENSE_SUBGHZ_LOW_SENSITIVITY

RF Sense is in low sensitivity subgig band.

RAIL_RFENSE_ANY_LOW_SENSITIVITY

RF Sense is in low sensitivity for both bands.


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.


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.


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.


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.


RAIL_EffDevice_t#

RAIL_EffDevice_t

EFF part numbers.

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

Enumerator
RAIL_EFF_DEVICE_NONE

No EFF device attached.

RAIL_EFF_DEVICE_EFF01A11NMFA0

+30 dBm, LNA, QFN24, +105C max ambient

RAIL_EFF_DEVICE_EFF01B11NMFA0

PA Bypass, LNA, QFN24, +105C max ambient.

RAIL_EFF_DEVICE_EFF01A11IMFB0

+30 dBm, LNA, QFN24, +125C max ambient

RAIL_EFF_DEVICE_EFF01B11IMFB0

PA Bypass, LNA, QFN24, +125C max ambient.

RAIL_EFF_DEVICE_COUNT

A count of the choices in this enumeration.


RAIL_EffLnaMode_t#

RAIL_EffLnaMode_t

EFF LNA Modes.

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

Enumerator
RAIL_EFF_LNA_MODE_RURAL

Rural LNA Mode.

RAIL_EFF_LNA_MODE_URBAN

Urban LNA Mode.

RAIL_EFF_LNA_MODE_BYPASS

Bypass LNA Mode.

RAIL_EFF_LNA_MODE_COUNT

A count of the choices in this enumeration.


RAIL_ClpcEnable_t#

RAIL_ClpcEnable_t

EFF Closed Loop Power Control (CLPC) Enable states.

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

Enumerator
RAIL_EFF_CLPC_DISABLED

CLPC actions are completely disabled.

RAIL_EFF_CLPC_MODE_CHANGE

CLPC actions are completely disabled.

RAIL_EFF_CLPC_POWER_SLOW

CLPC actions allows Slow Loop.

RAIL_EFF_CLPC_POWER_FAST

CLPC actions allows Fast Loop.

RAIL_EFF_CLPC_POWER_BOTH

CLPC actions are completely enabled.

RAIL_EFF_CLPC_POWER_SLOW_STOPPED

CLPC actions allows Slow Loop.

RAIL_EFF_CLPC_POWER_FAST_STOPPED

CLPC actions allows Fast Loop.

RAIL_EFF_CLPC_POWER_BOTH_STOPPED

CLPC actions are completely enabled.

RAIL_EFF_CLPC_COUNT

A count of the choices in this enumeration.


RAIL_EffModeSensor_t#

RAIL_EffModeSensor_t

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

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

Enumerator
RAIL_EFF_MODE_SENSOR_FSK_ANTV

CLPC FSK ANTV Sensor.

RAIL_EFF_MODE_SENSOR_FSK_SAW2

CLPC FSK SAW2 Sensor.

RAIL_EFF_MODE_SENSOR_OFDM_ANTV

CLPC OFDM ANTV power calibration entry 1.

RAIL_EFF_MODE_SENSOR_OFDM_SAW2

CLPC OFDM SAW2 power calibration entry 1.

RAIL_EFF_MODE_SENSOR_COUNT

A count of the choices in this enumeration.


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.


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.


RAIL_InitCompleteCallbackPtr_t#

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

A pointer to init complete callback function.

Parameters
TypeDirectionArgument NameDescription
[in]railHandle

The initialized RAIL instance handle.


RAIL_StateBuffer_t#

RAIL_StateBuffer_t [1]

Provided for backwards compatibility.


RAIL_Time_t#

RAIL_Time_t

Time in microseconds.


RAIL_TimerCallback_t#

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

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

Parameters
TypeDirectionArgument NameDescription
[in]cbArg

The argument passed to the callback.


RAIL_MultiTimerCallback_t#

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

Callback fired when timer expires.

Parameters
TypeDirectionArgument NameDescription
[in]tmr

A pointer to an expired timer.

[in]expectedTimeOfEvent

An absolute time event fired.

[in]cbArg

A user-supplied callback argument.


RAIL_TxPower_t#

typedef int16_t RAIL_TxPower_t

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

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


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


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


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.


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
TypeDirectionArgument NameDescription
[in]railHandle

A handle for RAIL instance.

[in]entry

The radio configuration entry being changed to.


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.


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


RAIL_RxPacketHandle_t#

RAIL_RxPacketHandle_t

A handle used to reference a packet during reception processing.

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


RAIL_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
TypeDirectionArgument NameDescription
[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.


RAIL_CalMask_t#

RAIL_CalMask_t

A calibration mask type.

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


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


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.


RAIL_RfSense_CallbackPtr_t#

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

A pointer to an RF Sense callback function.

Consider using the event RAIL_EVENT_RF_SENSED as an alternative.


RAIL_RxChannelHoppingParameter_t#

RAIL_RxChannelHoppingParameter_t

Rx channel hopping on-channel time.


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


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
TypeDirectionArgument NameDescription
[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

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

Note

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


Function Documentation#

RAIL_ConfigRetimeOptions#

RAIL_Status_t RAIL_ConfigRetimeOptions (RAIL_Handle_t railHandle, RAIL_RetimeOptions_t mask, RAIL_RetimeOptions_t options)

Configure retiming options.

Parameters
TypeDirectionArgument NameDescription
RAIL_Handle_t[in]railHandle

A handle of RAIL instance.

RAIL_RetimeOptions_t[in]mask

A bitmask containing which options should be modified.

RAIL_RetimeOptions_t[in]options

A bitmask containing desired configuration settings. Bit positions for each option are found in the RAIL_RetimeOptions_t.

Returns

  • Status code indicating success of the function call.


RAIL_GetRetimeOptions#

RAIL_Status_t RAIL_GetRetimeOptions (RAIL_Handle_t railHandle, RAIL_RetimeOptions_t * pOptions)

Get the currently configured retiming option.

Parameters
TypeDirectionArgument NameDescription
RAIL_Handle_t[in]railHandle

A handle of RAIL instance.

RAIL_RetimeOptions_t *[out]pOptions

A pointer to configured retiming options bitmask indicating which are enabled.

Returns

  • Status code indicating success of the function call.


RAIL_ChangedDcdc#

RAIL_Status_t RAIL_ChangedDcdc (void )

Indicate that the DCDC peripheral bus clock enable has changed allowing RAIL to react accordingly.

Parameters
TypeDirectionArgument NameDescription
voidN/A

Note

  • This should be called after DCDC has been enabled or disabled.

Returns

  • Status code indicating success of the function call.