RX Channel Hopping
RAIL API

Hardware accelerated hopping between channels while waiting for a packet in receive.

Data Structures

struct RAIL_RxChannelHoppingConfigEntry_t
Structure that represents one of the channels that is part of a sequence of channels used in channel hopping.
struct RAIL_RxChannelHoppingConfig_t
Wrapper struct that will contain the sequence of RAIL_RxChannelHoppingConfig_t that represent the channel sequence to use during RX Channel Hopping.

Enumerations

enum RAIL_RxChannelHoppingMode_t {
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
}
Modes by which RAIL can determine when to proceed to the next channel during channel hopping.
enum RAIL_RxChannelHoppingDelayMode_t { RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC }
Modes by which RAIL_RxChannelHoppingConfigEntry_t::delay timing can be applied to the time gap between channels.

Functions

RAIL_Status_t RAIL_ConfigRxChannelHopping ( RAIL_Handle_t railHandle, RAIL_RxChannelHoppingConfig_t *config)
Configure RX Channel Hopping.
RAIL_Status_t RAIL_EnableRxChannelHopping ( RAIL_Handle_t railHandle, bool enable, bool reset)
Enable RX Channel Hopping.

Detailed Description

Hardware accelerated hopping between channels while waiting for a packet in receive.

Channel hopping provides a hardware accelerated method for scanning across multiple channels quickly, as part of a receive protocol. While it is possible to call RAIL_StartRx on different channels, back to back, and listen on many channels sequentially in that way, the time it takes to switch channels with that method may be too long for some protocols. This API pre-computes necessary channel change operations for a given list of channels, so that the radio can move from channel to channel much faster. Additionally, it leads to more succinct code as channel changes will be done implicitly, without requiring numerous calls to RAIL_StartRx . Currently, while this feature is enabled, the radio will hop channels in the given sequence each time it enters RX.

The following code gives an example of how to use the RX Channel Hopping API.

// The channel hopping buffer requires 30 words of overhead per channel,
// plus 3 words overall plus the size of the radioConfigDeltaSubtract of the
// whole PHY, plus the sum of the sizes of all the radioConfigDeltaAdds of
// all the channel hopping channels.
#define CHANNEL_HOPPING_NUMBER_OF_CHANNELS 4
#define CHANNEL_HOPPING_BUFFER_SIZE do { \
3 + \
(30 * CHANNEL_HOPPING_NUMBER_OF_CHANNELS) + \
SIZEOF_UINT32_DELTA_SUBTRACT + \
SIZEOF_UINT32_DELTA_ADD_0 + \
SIZEOF_UINT32_DELTA_ADD_1 + \
SIZEOF_UINT32_DELTA_ADD_2 + \
SIZEOF_UINT32_DELTA_ADD_3 + \
} while (0)
RAIL_RxChannelHoppingConfigEntry_t channelHoppingEntries[CHANNEL_HOPPING_NUMBER_OF_CHANNELS];
uint32_t channelHoppingBuffer[CHANNEL_HOPPING_BUFFER_SIZE];
RAIL_RxChannelHoppingConfig_t channelHoppingConfig = {
. buffer = channelHoppingBuffer,
.bufferLength = CHANNEL_HOPPING_BUFFER_SIZE,
.numberOfChannels = CHANNEL_HOPPING_NUMBER_OF_CHANNELS,
.entries = channelHoppingEntries
};
channelHoppingEntries[0]. channel = 1;
channelHoppingEntries[1]. channel = 2;
channelHoppingEntries[2]. channel = 3;
RAIL_ConfigRxChannelHopping (railHandle, &channelHoppingConfig);
RAIL_EnableRxChannelHopping (railHandle, true , true )

Enumeration Type Documentation

enum RAIL_RxChannelHoppingDelayMode_t

Modes by which RAIL_RxChannelHoppingConfigEntry_t::delay timing can be applied to the time gap between channels.

Enumerator
RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC

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

Definition at line 2304 of file rail_types.h .

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

The time should be specified in microseconds in RAIL_RxChannelHoppingConfigEntry::parameter. There will be up to 30us error on the value requested, specifically, up to 30us more than requested.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE

Wait a for a specified timeout, then check to see if we've got timing, if so, remain in the current channel until we lose it.

The timeout should be specified in microseconds in RAIL_RxChannelHoppingConfigEntry::parameter.

RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE

Wait a for a specified timeout, then check to see if we've got a valid preamble, if so, remain in the current channel until we lose it.

The timeout should be specified in microseconds in RAIL_RxChannelHoppingConfigEntry::parameter.

Definition at line 2270 of file rail_types.h .

Function Documentation

RAIL_Status_t RAIL_ConfigRxChannelHopping ( RAIL_Handle_t railHandle,
RAIL_RxChannelHoppingConfig_t * config
)

Configure RX Channel Hopping.

Parameters
[in] railHandle A RAIL instance handle.
[in] config Configuration parameters for RX Channel Hopping.
Returns
Status code indicating success of the function call.

Configure Channel Hopping channels, conditions, and parameters. This API must be called before RAIL_EnableChannelHopping. This API must never be called while Channel Hopping is enabled.

Note
This feature/API is not supported on the EFR32XG1 family of chips.
This feature/API is currently not supported in multiprotocol.
RAIL_Status_t RAIL_EnableRxChannelHopping ( RAIL_Handle_t railHandle,
bool enable,
bool reset
)

Enable RX Channel Hopping.

Parameters
[in] railHandle A RAIL instance handle.
[in] enable Enable (true) or disable (false) RX Channel Hopping.
[in] reset Start from the first channel of the channel hopping sequence (true) or from wherever hopping left off last time the code left RX.
Returns
Status code indicating success of the function call.

Enable or disable Channel Hopping. Additionally, specify whether hopping should be reset to start from the channel at index zero, or continue from the channel last hopped to. The radio should not be in receive when this API is called. RAIL_ConfigChannelHopping must be called before this API is called.

Note
This feature/API is not supported on the EFR32XG1 family of chips.
This feature/API is currently not supported in multiprotocol.
RX Channel Hopping may not be enabled while Auto Acking is enabled.