Modules#
RAIL_TxChannelHoppingConfigEntry_t
RAIL_RfSenseSelectiveOokConfig_t
RAIL_RxChannelHoppingConfigMultiMode_t
RAIL_RxChannelHoppingConfigEntry_t
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:
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.
Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
This notice may not be removed or altered from any source distribution.
Macros#
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.
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.
A value to signal that RAIL should not use DMA.
Radio Scheduler Status mask.
Radio Scheduler Status shift.
Radio Scheduler Task mask.
Radio Scheduler Task shift.
Shift position of RAIL_EVENT_SCHEDULED_TX_STARTED bit.
Shift position of RAIL_EVENT_RX_DUTY_CYCLE_RX_END bit.
Shift position of RAIL_EVENT_ZWAVE_LR_ACK_REQUEST_COMMAND_SHIFT bit.
Shift position of RAIL_EVENT_MFM_TX_BUFFER_DONE bit.
A value representing no events.
Occurs when the hardware-averaged RSSI is done in response to RAIL_StartAverageRssi() to indicate that the hardware has completed averaging.
Occurs when the ACK timeout expires while waiting to receive the sync word of an expected ACK.
Occurs when the number of bytes in the receive FIFO exceeds the configured threshold value.
Occurs whenever a packet is received with RAIL_RX_PACKET_READY_SUCCESS or RAIL_RX_PACKET_READY_CRC_ERROR.
Occurs when the radio has lost a preamble.
Occurs when the radio has detected a preamble.
Occurs when the first sync word is detected.
Occurs when the second sync word is detected.
Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_CRC_ERROR which only happens after any filtering has passed.
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.
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).
Occurs when a receive is aborted with RAIL_RX_PACKET_ABORT_FILTERED because its address does not match the filtering settings.
Occurs when an RX event times out.
Occurs when a scheduled RX begins turning on the transmitter.
Occurs when a scheduled TX begins turning on the transmitter.
Occurs when the scheduled RX window ends.
Occurs when start of a scheduled receive is missed.
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).
Occurs when the packet has passed any configured address and frame filtering options.
Occurs when the modem timing is lost.
Occurs when the modem timing is detected.
Occurs when RX Channel Hopping is enabled and channel hopping finishes receiving on the last channel in its sequence.
Occurs during RX duty cycle mode when the radio finishes its time in receive mode.
Indicate a Data Request is received when using IEEE 802.15.4 functionality.
Indicate a Z-Wave Beam Request relevant to the node was received.
Indicate a MFM buffer has completely transmitted.
Indicate a request for populating Z-Wave LR ACK packet.
The mask representing all events that determine the end of a received packet.
Occurs when the number of bytes in the transmit FIFO falls below the configured threshold value.
Occurs after a packet has been transmitted.
Occurs after an ACK packet has been transmitted.
Occurs when a transmit is aborted by the user.
Occurs when an ACK transmit is aborted by the user.
Occurs when a transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called.
Occurs when an ACK transmit is blocked from occurring because RAIL_EnableTxHoldOff() was called.
Occurs when the transmit buffer underflows.
Occurs when the ACK transmit buffer underflows.
Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) succeeds.
Occurs when Carrier Sense Multiple Access (CSMA) or Listen Before Talk (LBT) fails.
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.
Occurs when the receiver is activated to perform a Clear Channel Assessment (CCA) check.
Occurs when the radio starts transmitting a normal packet on the air.
A value to pass as RAIL_GetTxTimePreambleStart() totalPacketBytes parameter to retrieve the RAIL_EVENT_TX_STARTED timestamp.
Occurs when the start of a scheduled transmit is missed.
A mask representing all events that determine the end of a transmitted packet.
A mask representing all events that determine the end of a transmitted ACK packet.
Occurs when the scheduler switches away from this configuration.
Occurs when the scheduler switches to this configuration.
Occurs when the scheduler has a status to report.
Occurs when the application needs to run a calibration, as determined by the RAIL library.
Occurs when RF energy is sensed from the radio.
Occurs when PA protection circuit kicks in.
Occurs after enabling the signal detection using RAIL_BLE_EnableSignalDetection or RAIL_IEEE802154_EnableSignalDetection when a signal is detected.
Occurs when a Wi-SUN mode switch packet has been received, after switching to the new PHY.
Occurs when switching back to the original base PHY in effect prior to the Wi-SUN mode switch reception.
Occurs when the sampled RSSI is above the threshold set by RAIL_SetRssiDetectThreshold().
Occurs when the thermistor has finished its measurement in response to RAIL_StartThermistorMeasurement().
Occurs when a Tx has been blocked because of temperature exceeding the safety threshold.
Occurs when die internal temperature exceeds the temperature threshold subtracted by the cool down parameter from RAIL_ChipTempConfig_t.
Occurs when die internal temperature falls below the temperature threshold subtracted by the cool down parameter from RAIL_ChipTempConfig_t.
A value representing all possible events.
The maximum valid value for a RAIL_TxPower_t.
The minimum valid value for a RAIL_TxPower_t.
The maximum power in deci-dBm the curve supports.
The increment step in deci-dBm for calculating power level.
mV are used for all TX power voltage values.
deci-dBm are used for all TX power dBm values.
An invalid return value when calling RAIL_SetFixedLength().
Indicates this version of RAIL supports concurrent PHY information in radio configurator output.
Indicates this version of RAIL supports stack info feature in radio configurator output.
A FIFO threshold value that disables the threshold.
Radio is inactive.
Radio is in or headed to the idle state.
Radio is in or headed to the receive state.
Radio is in or headed to the transmit state.
Radio is headed to the idle, receive, or transmit state.
Radio is actively transmitting or receiving.
Radio has frame detect disabled.
LBT/CSMA operation is currently ongoing.
Mask for core radio state bits.
Do not stop any radio operations.
Stop active radio operations only.
Stop pending radio operations.
Stop all radio operations.
A value representing no options enabled.
All options disabled by default.
An option to configure whether or not the TXing node will listen for an ACK.
An option to remove CRC bytes from TX packets.
An option to select which sync word is used during the transmission.
An option to select antenna 0 for transmission.
An option to select antenna 1 for transmission.
An option to dynamically set an alternate preamble length for the transmission.
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.
An option to only perform the CCA (CSMA/LBT) operation but not automatically transmit if the channel is clear.
An option to resend packet at the beginning of the Transmit FIFO.
An option to specify which PHY is used to transmit in the case of concurrent mode.
A value representing all possible options.
The maximum number of LBT/CSMA retries supported.
The maximum power-of-2 exponent for CSMA backoffs.
RAIL_CsmaConfig_t initializer configuring CSMA per IEEE 802.15.4-2003 on 2.4 GHz OSPSK, commonly used by ZigBee.
RAIL_CsmaConfig_t initializer configuring a single CCA prior to TX.
RAIL_LbtConfig_t initializer configuring LBT per ETSI 300 220-1 V2.4.1 for a typical Sub-GHz band.
A default address filtering match table for configurations that use only one address field.
A default address filtering match table for configurations that use two address fields and want to match the same index in each.
The maximum number of address fields that can be used by the address filtering logic.
A value representing no options enabled.
All options are disabled by default.
An option to configure whether the CRC portion of the packet is included in the packet payload exposed to the app on packet reception.
An option to configure whether CRC errors will be ignored.
An option to control which sync words will be accepted.
An option to configure whether frames which are aborted during reception should continue to be tracked.
An option to suppress capturing the appended information after received frames.
An option to select the use of antenna 0 during receive (including Auto-ACK receive).
An option to select the use of antenna 1 during receive (including Auto-ACK receive).
An option combination to automatically choose an antenna during receive (including Auto-ACK receive).
An option to disable frame detection.
An option to enable IEEE 802.15.4 RX channel switching.
A value representing all possible options.
The value returned by RAIL for an invalid RSSI, in dBm.
The value returned by RAIL for an invalid RSSI: in quarter dBm.
The lowest RSSI value returned by RAIL: in quarter dBm.
Maximum absolute value for RSSI offset.
A sentinel value to indicate waiting for a valid RSSI without a timeout.
A sentinel value to indicate no waiting for a valid RSSI.
An invalid RX packet handle value.
A special RX packet handle to refer to the oldest unreleased packet.
A special RX packet handle to refer to the oldest unreleased complete packet.
A special RX packet handle to refer to the newest unreleased packet when in callback context.
Acknowledgment packets cannot be longer than 64 bytes.
A sentinel value to indicate an invalid thermistor measurement value.
A sentinel value to indicate an invalid PPM calculation value.
RF Sense low sensitivity offset.
Use the MODEM default sync word.
The maximum sense time supported for those RAIL_RxChannelHoppingMode_t modes whose parameter(s) specify a sensing time.
A value representing no options enabled.
All options disabled by default.
An option to skip synth calibration while hopping into the channel specified in the current entry.
An option to skip DC calibration while hopping into the channel specified in the current entry.
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.
An option to stop the hopping sequence at this entry in the hop table.
A sentinel value to flag an invalid channel hopping index.
This radio state verification duration indicates to RAIL that all memory contents should be verified by RAIL before returning to the application.
A macro that checks for EFFxx devices that support high power transmit.
A macro that checks for EFFxx devices that support receive.
Maximum EFF internal temperature in Kelvin, allowing transmissions when RAIL_SUPPORTS_EFF is enabled.
A macro that is string versions of the calibration enums.
Maximum junction temperature in Kelvin.
Default number of Kelvin degrees below threshold needed to allow transmissions.
Number of temperature values provided for the chip thermal protection.
A value to use in RAIL_StateTiming_t fields when calling RAIL_SetStateTiming() to keep that timing parameter at it current setting.
A value representing no repeat options enabled.
All repeat options disabled by default.
An option to configure whether or not to channel-hop before each repeated transmit.
RAIL_TxRepeatConfig_t::iterations initializer configuring infinite repeated transmissions.
Enumerations#
A status returned by many RAIL API calls indicating their success or failure.
Specify a time offset in RAIL APIs.
The available packet timestamp position choices.
The configuration.
Multiprotocol scheduler status returned by RAIL_GetSchedulerStatus().
Multiprotocol radio operation task types, used with RAIL_SetTaskPriority.
RAIL events passed to the event callback.
Define if the channel support using concurrent PHY during channel hopping.
The protocol that RAIL outputs via the Packet Trace Interface (PTI).
Transmit data sources supported by RAIL.
Receive data sources supported by RAIL.
Methods for the application to provide and retrieve data from RAIL.
The state of the radio.
The detailed state of the radio.
An enumeration for the different types of supported idle modes.
Stop radio operation options bit mask.
Transmit options, in reality a bitmask.
Enumerates the possible outcomes of what will occur if a scheduled TX ends up firing during RX.
Receive options, in reality a bitmask.
The packet status code associated with a packet received or currently being received.
An enumeration for specifying the RF Sense frequency band.
Modes by which RAIL can determine when to proceed to the next channel during channel hopping.
Options that can customize channel hopping behavior on a per-hop basis.
Possible stream output modes.
EFF part numbers.
EFF LNA Modes.
EFF Closed Loop Power Control (CLPC) Enable states.
EFF Closed Loop Power Control (CLPC) Mode Sensor Indices.
Transmit repeat options, in reality a bitmask.
Typedefs#
A generic handle to a particular radio (e.g.
A pointer to init complete callback function.
Time in microseconds.
A pointer to the callback called when the RAIL timer expires.
Callback fired when timer expires.
The transmit power in deci-dBm units (e.g., 4.5 dBm -> 45 deci-dBm).
A pointer to a function called whenever a radio configuration change occurs.
A bitmask representation of which 4 filters passed for each ADDRCONFIG_MAX_ADDRESS_FIELDS when filtering has completed successfully.
A handle used to reference a packet during reception processing.
A calibration mask type.
A pointer to a function called before LQI is copied into the RAIL_RxPacketDetails_t structure.
A pointer to an RF Sense callback function.
Rx channel hopping on-channel time.
A pointer to a verification callback function.
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_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_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_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
Data sources other than RX_PACKET_DATA require use of RAIL_DataMethod_t::FIFO_MODE.
| 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. |
| 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_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_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_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 enters RX. |
| 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_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. |
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.
| Type | Direction | Argument Name | Description |
|---|---|---|---|
| [in] | railHandle | The initialized RAIL instance handle. |
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.
| Type | Direction | Argument Name | Description |
|---|---|---|---|
| [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.
| Type | Direction | Argument Name | Description |
|---|---|---|---|
| [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_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.
| Type | Direction | Argument Name | Description |
|---|---|---|---|
| [in] | railHandle | A handle for RAIL instance. | |
| [in] | entry | The radio configuration entry being changed to. |
RAIL_AddrFilterMask_t#
typedef uint8_t RAIL_AddrFilterMask_t
A bitmask representation of which 4 filters passed for each ADDRCONFIG_MAX_ADDRESS_FIELDS when filtering has completed successfully.
It's layout is: | Bit 7 | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | Bit 0 | |-----—+-----—+-----—+-----—+-----—+-----—+-----—+-----—| | Second Address Field Nibble | First Address Field Nibble | | Addr 3 | Addr 2 | Addr 1 | Addr 0 | Addr 3 | Addr 2 | Addr 1 | Addr 0 | | match | match | match | match | match | match | match | match | |-----—+-----—+-----—+-----—+-----—+-----—+-----—+-----—|
Note
This information is valid in RAIL_IEEE802154_Address_t on all platforms, but is only valid in RAIL_RxPacketInfo_t on platforms where RAIL_SUPPORTS_ADDR_FILTER_MASK is true.
RAIL_RxPacketHandle_t#
RAIL_RxPacketHandle_t
A handle used to reference a packet during reception processing.
There are several sentinel handle values that pertain to certain circumstances: RAIL_RX_PACKET_HANDLE_INVALID, RAIL_RX_PACKET_HANDLE_OLDEST, RAIL_RX_PACKET_HANDLE_OLDEST_COMPLETE and RAIL_RX_PACKET_HANDLE_NEWEST.
RAIL_CalMask_t#
RAIL_CalMask_t
A calibration mask type.
This type is a bitmask of different RAIL calibration values. The exact meaning of these bits depends on what a particular chip supports.
RAIL_ConvertLqiCallback_t#
RAIL_ConvertLqiCallback_t )(uint8_t lqi, int8_t rssi)
A pointer to a function called before LQI is copied into the RAIL_RxPacketDetails_t structure.
| Type | Direction | Argument Name | Description |
|---|---|---|---|
| [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_RfSense_CallbackPtr_t#
typedef void(* RAIL_RfSense_CallbackPtr_t) (void) )(void)
A pointer to an RF Sense callback function.
Consider using the event RAIL_EVENT_RF_SENSED as an alternative.
RAIL_RxChannelHoppingParameter_t#
RAIL_RxChannelHoppingParameter_t
Rx channel hopping on-channel time.
RAIL_VerifyCallbackPtr_t#
typedef bool(* RAIL_VerifyCallbackPtr_t) (uint32_t address, uint32_t expectedValue, uint32_t actualValue) )(uint32_t address, uint32_t expectedValue, uint32_t actualValue)
A pointer to a verification callback function.
| Type | Direction | Argument Name | Description |
|---|---|---|---|
| [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.