RX Channel Hopping#

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. Note that RX Channel hopping and EFR32xG25's concurrent mode / collision detection are mutually exclusive.

The channel hopping buffer requires RAIL_CHANNEL_HOPPING_BUFFER_SIZE_PER_CHANNEL number of 32-bit words of overhead per channel, plus 3 words overall plus the twice the size of the radioConfigDeltaSubtract of the whole radio configuration, plus the twice the sum of the sizes of all the radioConfigDeltaAdd's of all the channel hopping channels.

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

#define CHANNEL_HOPPING_NUMBER_OF_CHANNELS 4
#define CHANNEL_HOPPING_BUFFER_SIZE do {        \
  3 +                                           \
  (RAIL_CHANNEL_HOPPING_BUFFER_SIZE_PER_CHANNEL \
   * CHANNEL_HOPPING_NUMBER_OF_CHANNELS) +      \
  2 * (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)

Modules#

RAIL_RxChannelHoppingConfigMultiMode_t

RAIL_RxChannelHoppingConfigEntry_t

RAIL_RxChannelHoppingConfig_t

RAIL_RxDutyCycleConfig_t

EFR32XG2X

Enumerations#

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

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

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

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

Typedefs#

typedef uint32_t

Rx channel hopping on-channel time.

Functions#

RAIL_ConfigRxChannelHopping(RAIL_Handle_t railHandle, RAIL_RxChannelHoppingConfig_t *config)

Configure RX channel hopping.

RAIL_EnableRxChannelHopping(RAIL_Handle_t railHandle, bool enable, bool reset)

Enable RX channel hopping.

int16_t
RAIL_GetChannelHoppingRssi(RAIL_Handle_t railHandle, uint8_t channelIndex)

Get RSSI in deci-dBm of one channel in the channel hopping sequence, during channel hopping.

RAIL_ConfigRxDutyCycle(RAIL_Handle_t railHandle, const RAIL_RxDutyCycleConfig_t *config)

Configure RX duty cycle mode.

RAIL_EnableRxDutyCycle(RAIL_Handle_t railHandle, bool enable)

Enable RX duty cycle mode.

RAIL_GetDefaultRxDutyCycleConfig(RAIL_Handle_t railHandle, RAIL_RxDutyCycleConfig_t *config)

Get the default RX duty cycle configuration.

Macros#

#define

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

#define

A value representing no options enabled.

#define
RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE

All options disabled by default.

#define
RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT
#define
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL (1U << RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT)

An option to skip synth calibration while hopping into the channel specified in the current entry.

#define
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL (1U << RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT)

An option to skip DC calibration while hopping into the channel specified in the current entry.

#define
RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD (1U << RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT)

An option to check RSSI after hopping into the channel specified in the current entry and hop if that RSSI is below the threshold specified in RAIL_RxChannelHoppingConfigEntry_t::rssiThresholdDbm.

#define
RAIL_RX_CHANNEL_HOPPING_OPTION_STOP (1U << RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT)

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

#define

A sentinel value to flag an invalid channel hopping index.

Enumeration Documentation#

RAIL_RxChannelHoppingMode_t#

RAIL_RxChannelHoppingMode_t

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

Enumerator
RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL

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

RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT

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

RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE

Listen in receive RX for at least a specified timeout.

RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE

Listen in receive RX for at least a specified timeout.

RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1

Placeholder for a reserved hopping mode that is not supported.

RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE

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

RAIL_RX_CHANNEL_HOPPING_MODE_SQ

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

RAIL_RX_CHANNEL_HOPPING_MODE_CONC

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

RAIL_RX_CHANNEL_HOPPING_MODE_VT

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

RAIL_RX_CHANNEL_HOPPING_MODE_TX

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

RAIL_RX_CHANNEL_HOPPING_MODES_COUNT

A count of the basic choices in this enumeration.

RAIL_RX_CHANNEL_HOPPING_MODES_WITH_OPTIONS_BASE

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

RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_MANUAL with options.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_TIMEOUT with options.

RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_TIMING_SENSE with options.

RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE with options.

RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_RESERVED1 with options.

RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_MULTI_SENSE with options.

RAIL_RX_CHANNEL_HOPPING_MODE_SQ_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_SQ with options.

RAIL_RX_CHANNEL_HOPPING_MODE_CONC_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_CONC with options.

RAIL_RX_CHANNEL_HOPPING_MODE_VT_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_VT with options.

RAIL_RX_CHANNEL_HOPPING_MODE_TX_WITH_OPTIONS

Variant of RAIL_RX_CHANNEL_HOPPING_MODE_TX with options.


Definition at line 4859 of file common/rail_types.h

RAIL_RxChannelHoppingDelayMode_t#

RAIL_RxChannelHoppingDelayMode_t

DeprecatedSet only to RAIL_RX_CHANNEL_DELAY_MODE_STATIC.

Enumerator
RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC

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


Definition at line 5041 of file common/rail_types.h

RAIL_RxChannelHoppingOptions_t#

RAIL_RxChannelHoppingOptions_t

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

Enumerator
RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT

Shift position of RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL bit.

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT

Shift position of RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL bit.

RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT

Shift position of RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD bit.

RAIL_RX_CHANNEL_HOPPING_OPTION_STOP_SHIFT

Stop hopping on this hop.

RAIL_RX_CHANNEL_HOPPING_OPTIONS_COUNT

A count of the choices in this enumeration.


Definition at line 5066 of file common/rail_types.h

Typedef Documentation#

RAIL_RxChannelHoppingParameter_t#

RAIL_RxChannelHoppingParameter_t

Rx channel hopping on-channel time.


Definition at line 5059 of file common/rail_types.h

Function Documentation#

RAIL_ConfigRxChannelHopping#

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

A pointer to the 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_EnableRxChannelHopping(). This API must never be called while the radio is on with RX Duty Cycle or Channel Hopping enabled.

Note


Definition at line 5449 of file common/rail.h

RAIL_EnableRxChannelHopping#

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 first channel index, or continue from the channel last hopped to. The radio should not be on when this API is called. RAIL_ConfigRxChannelHopping must be called successfully before this API is called.

Note


Definition at line 5477 of file common/rail.h

RAIL_GetChannelHoppingRssi#

int16_t RAIL_GetChannelHoppingRssi (RAIL_Handle_t railHandle, uint8_t channelIndex)

Get RSSI in deci-dBm of one channel in the channel hopping sequence, during channel hopping.

Parameters
[in]railHandle

A RAIL instance handle.

[in]channelIndex

Index in the channel hopping sequence of the channel of interest

Returns

  • Latest RSSI in deci-dBm for the channel at the specified index.

Note


Definition at line 5504 of file common/rail.h

RAIL_ConfigRxDutyCycle#

RAIL_Status_t RAIL_ConfigRxDutyCycle (RAIL_Handle_t railHandle, const RAIL_RxDutyCycleConfig_t *config)

Configure RX duty cycle mode.

Parameters
[in]railHandle

A RAIL instance handle.

[in]config

A non-NULL pointer to a configuration structure specifying duty cycle parameters.

Returns

  • Status code indicating success of the function call.

Configure RX duty cycle mode. With this mode enabled, every time the radio enters RX, it will duty cycle on and off to save power. The duty cycle ratio can be altered dynamically and intelligently by the hardware by staying on longer if a preamble or other packet segments are detected in the air. This API must never be called while the radio is on with RX Duty Cycle or Channel Hopping enabled. For short delays (in the order of microseconds), RAIL_RxDutyCycleConfig_t::delay, this can be used to save receive current while having little impact on the radio performance, for protocols with long preambles. For long delays (in the order of milliseconds or higher) the chip can be put into EM2 energy mode before re-entering RX, to save extra power, with some application hooks as shown below.

#include "rail.h"

extern RAIL_Handle_t railHandle;
RAIL_Time_t periodicWakeupUs;

volatile bool dutyCycleEnd = true;

void RAILCb_Event(RAIL_Handle_t railHandle, RAIL_Events_t events)
{
  // Omitting other event handlers
  if (events & RAIL_EVENT_RX_DUTY_CYCLE_RX_END) {
    dutyCycleEnd = true;
  }
}

void main(void)
{
  RAIL_Status_t status;
  bool shouldSleep = false;

  initializeRail(); // Call RAIL_Init() and such

  // This function depends on your board/chip but it must enable the LFCLK
  // you intend to use for RTCC sync before we configure sleep as that
  // function will attempt to auto detect the clock.
  BoardSetupLFCLK();
  // Initialize Power Manager module
  sl_power_manager_init();
  // Initialize RAIL Power Manager
  RAIL_InitPowerManager();

  // Configure sleep for timer synchronization
  RAIL_TimerSyncConfig_t timerSyncConfig = RAIL_TIMER_SYNC_DEFAULT;
  status = RAIL_ConfigSleep(railHandle, &timerSyncConfig);
  assert(status == RAIL_STATUS_NO_ERROR);

  // Configure RX duty-cycling
  RAIL_RxDutyCycleConfig_t duty_cycle_config = {
    .mode = RAIL_RX_CHANNEL_HOPPING_MODE_PREAMBLE_SENSE,
    .parameter = DUTY_CYCLE_ON_TIME,
    .delay_us = DUTY_CYCLE_OFF_TIME,
    .delay_mode = RAIL_RX_CHANNEL_HOPPING_DELAY_MODE_STATIC,
    .options = RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE,
  };
  status = RAIL_ConfigRxDutyCycle(rail_handle, &duty_cycle_config);
  assert(status == RAIL_STATUS_NO_ERROR);
  status = RAIL_EnableRxDutyCycle(rail_handle, true);
  assert(status == RAIL_STATUS_NO_ERROR);

  // Application main loop
  while (1) {
    if (dutyCycleEnd) {
      dutyCycleEnd = false;
      // Schedule the next receive.
      RAIL_ScheduleRxConfig_t rxConfig = {
        .start = periodicWakeupUs,
        .startMode = RAIL_TIME_DELAY,
        .end = 0U,
        .endMode = RAIL_TIME_DISABLED,
        .rxTransitionEndSchedule = 0U,
        .hardWindowEnd = 0U
      };
      RAIL_Idle(railHandle, RAIL_IDLE_ABORT, true);
      RAIL_StartScheduledRx(railHandle, channel, &rxConfig, NULL);
    }
    // ... do normal app stuff and set shouldSleep when we want to sleep
    if (shouldSleep) {
      // Let the CPU go to sleep if the system allows it.
      sl_power_manager_sleep();
    }
  }
}

Note


Definition at line 5608 of file common/rail.h

RAIL_EnableRxDutyCycle#

RAIL_Status_t RAIL_EnableRxDutyCycle (RAIL_Handle_t railHandle, bool enable)

Enable RX duty cycle mode.

Parameters
[in]railHandle

A RAIL instance handle.

[in]enable

Enable (true) or disable (false) RX Duty Cycling.

Returns

  • Status code indicating success of the function call.

Enable or disable RX duty cycle mode. After this is called, the radio will begin duty cycling each time it enters RX, based on the configuration passed to RAIL_ConfigRxDutyCycle. This API must not be called while the radio is on.

Note


Definition at line 5630 of file common/rail.h

RAIL_GetDefaultRxDutyCycleConfig#

RAIL_Status_t RAIL_GetDefaultRxDutyCycleConfig (RAIL_Handle_t railHandle, RAIL_RxDutyCycleConfig_t *config)

Get the default RX duty cycle configuration.

Parameters
[in]railHandle

A RAIL instance handle.

[out]config

An application-provided non-NULL pointer to store the default RX duty cycle configuration.

Returns

  • Status code indicating success of the function call. Note that RAIL_STATUS_INVALID_PARAMETER will be returned if the current channel's radio configuration does not support the requested information.

To save power during RX, an application may want to go to low power as long as possible by periodically waking up and trying to "sense" if there are any incoming packets. This API returns the recommended RX duty cycle configuration, so the application can enter low power mode periodically without missing packets. To wake up earlier, the application can reduce the delay parameter. Note that these value might be different if any configuration / channel has changed.


Definition at line 5652 of file common/rail.h

Macro Definition Documentation#

RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US#

#define RAIL_RX_CHANNEL_HOPPING_MAX_SENSE_TIME_US
Value:
0x08000000UL

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


Definition at line 5035 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE#

#define RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE
Value:
0U

A value representing no options enabled.


Definition at line 5080 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT#

#define RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT
Value:
RAIL_RX_CHANNEL_HOPPING_OPTIONS_NONE

All options disabled by default.

Channel hopping will behave as described by other parameters as it did in RAIL 2.7 and earlier.


Definition at line 5086 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_DEFAULT
Value:
RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT

DeprecatedPlease use RAIL_RX_CHANNEL_HOPPING_OPTIONS_DEFAULT instead.


Definition at line 5090 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL
Value:
(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_SYNTH_CAL_SHIFT)

An option to skip synth calibration while hopping into the channel specified in the current entry.


Definition at line 5095 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL
Value:
(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_SKIP_DC_CAL_SHIFT)

An option to skip DC calibration while hopping into the channel specified in the current entry.


Definition at line 5100 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD#

#define RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD
Value:
(1U << RAIL_RX_CHANNEL_HOPPING_OPTION_RSSI_THRESHOLD_SHIFT)

An option to check RSSI after hopping into the channel specified in the current entry and hop if that RSSI is below the threshold specified in RAIL_RxChannelHoppingConfigEntry_t::rssiThresholdDbm.

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


Definition at line 5108 of file common/rail_types.h

RAIL_RX_CHANNEL_HOPPING_OPTION_STOP#

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

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


Definition at line 5113 of file common/rail_types.h

RAIL_CHANNEL_HOPPING_INVALID_INDEX#

#define RAIL_CHANNEL_HOPPING_INVALID_INDEX
Value:
(0xFEU)

A sentinel value to flag an invalid channel hopping index.


Definition at line 5383 of file common/rail_types.h