Events
APIs related to events.
Macros | |
#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) |
Notifies the application when searching for an ACK packet has timed out. | |
#define | RAIL_EVENT_RX_FIFO_ALMOST_FULL (1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT) |
Occurs when 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. | |
#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 packet being received has a frame error. | |
#define | RAIL_EVENT_RX_FIFO_OVERFLOW (1ULL << RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT) |
Occurs when the RX buffer is full, which causes the radio to stop receiving packets until the packet causing the overflow is processed. | |
#define | RAIL_EVENT_RX_ADDRESS_FILTERED (1ULL << RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT) |
Occurs when a packet's 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_RX_SCHEDULED_RX_END (1ULL << RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT) |
Occurs when the scheduled RX window ends. | |
#define | RAIL_EVENT_RX_PACKET_ABORTED (1ULL << RAIL_EVENT_RX_PACKET_ABORTED_SHIFT) |
Occurs when a packet is aborted, but a more specific reason (such as RAIL_EVENT_RX_ADDRESS_FILTERED) isn't known. | |
#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) |
Indicates a Data Request is received when using IEEE 802.15.4 functionality and occurs when the command byte of an incoming frame is for a data request, which requests an ACK. | |
#define | RAIL_EVENT_ZWAVE_BEAM (1ULL << RAIL_EVENT_ZWAVE_BEAM_SHIFT) |
Indicates a Z-Wave Beam Request relevant to the node was received. | |
#define | RAIL_EVENTS_RX_COMPLETION |
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, which can happen due to calling RAIL_Idle() or due to a scheduler pre-emption. | |
#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, which can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to RAIL_WriteTxFifo() calls not keeping up with the transmit rate if the entire packet isn't loaded at once. | |
#define | RAIL_EVENT_TXACK_UNDERFLOW (1ULL << RAIL_EVENT_TXACK_UNDERFLOW_SHIFT) |
Occurs when the ACK transmit buffer underflows, which can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to RAIL_WriteAutoAckFifo() not being called at all before an ACK transmit. | |
#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 a Clear Channel Assessment (CCA) check begins. | |
#define | RAIL_EVENTS_TX_COMPLETION |
A mask representing all events that determine the end of a transmitted packet. | |
#define | RAIL_EVENTS_TXACK_COMPLETION |
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_EVENTS_ALL 0xFFFFFFFFFFFFFFFFULL |
A value representing all possible events. |
Functions | |
RAIL_Status_t | RAIL_ConfigEvents (RAIL_Handle_t railHandle, RAIL_Events_t mask, RAIL_Events_t events) |
Configures radio events. |
Detailed Description
APIs related to events.
Macro Definition Documentation
#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.
The application determines a valid window to call RAIL_Calibrate().
Definition at line 959
of file rail_types.h
.
#define RAIL_EVENT_CONFIG_SCHEDULED (1ULL << RAIL_EVENT_CONFIG_SCHEDULED_SHIFT) |
Occurs when the scheduler switches to this configuration.
This event can occur often in dynamic multiprotocol scenarios and can be used to influence the stack's operation.
Definition at line 941
of file rail_types.h
.
#define RAIL_EVENT_CONFIG_UNSCHEDULED (1ULL << RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT) |
Occurs when the scheduler switches away from this configuration.
This event can occur often in dynamic multiprotocol scenarios and can give the current stack an opportunity to release hardware resources.
Definition at line 934
of file rail_types.h
.
#define RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND (1ULL << RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT) |
Indicates a Data Request is received when using IEEE 802.15.4 functionality and occurs when the command byte of an incoming frame is for a data request, which requests an ACK.
This callback is called before the packet is fully received to allow the node to have more time to decide whether to indicate a frame is pending in the outgoing ACK. This event only occurs if the RAIL IEEE 802.15.4 functionality is enabled, but will never occur if promiscuous mode is enabled via RAIL_IEEE802154_SetPromiscuousMode().
Call RAIL_IEEE802154_GetAddress() to get the source address of the packet.
Definition at line 755
of file rail_types.h
.
#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.
Call RAIL_GetAverageRssi() to get the result.
Definition at line 592
of file rail_types.h
.
#define RAIL_EVENT_RX_ACK_TIMEOUT (1ULL << RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT) |
Notifies the application when searching for an ACK packet has timed out.
This event occurs whenever the timeout for searching for an ACK packet is exceeded, which only occurs after calling RAIL_ConfigAutoAck() and transmitting a packet.
Definition at line 600
of file rail_types.h
.
#define RAIL_EVENT_RX_ADDRESS_FILTERED (1ULL << RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT) |
Occurs when a packet's address does not match the filtering settings.
After this event, the packet will not be received and no other events should occur for the packet. This event can only occur after calling RAIL_EnableAddressFilter().
Definition at line 670
of file rail_types.h
.
#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.
The intent behind this event is to allow the user to keep the radio on for as short a time as possible. That is, once the channel sequence is complete, the application will receive this event and can trigger a sleep/idle until it is necessary to cycle through the channels again. If this event is left on indefinitely and not handled it will likely be a fairly noisy event, as it continues to fire each time the hopping algorithm cycles through the channel sequence.
Definition at line 734
of file rail_types.h
.
#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.
The application can then trigger a sleep/idle until it needs to listen again.
Definition at line 741
of file rail_types.h
.
#define RAIL_EVENT_RX_FIFO_ALMOST_FULL (1ULL << RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT) |
Occurs when the number of bytes in the receive FIFO exceeds the configured threshold value.
Call RAIL_GetRxFifoBytesAvailable() to get the number of bytes available. When using this event, the threshold should be set via RAIL_SetRxFifoThreshold().
Definition at line 608
of file rail_types.h
.
#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.
This event will only occur between the start of the packet, indicated by RAIL_EVENT_RX_SYNC1_DETECT or RAIL_EVENT_RX_SYNC2_DETECT and one of the events in the RAIL_EVENTS_RX_COMPLETION mask. It will always occur before or concurrently with RAIL_EVENT_RX_PACKET_RECEIVED. If IEEE 802.15.4 frame and address filtering are enabled, this event will occur immediately after destination address filtering.
Definition at line 708
of file rail_types.h
.
#define RAIL_EVENT_RX_FRAME_ERROR (1ULL << RAIL_EVENT_RX_FRAME_ERROR_SHIFT) |
Occurs when a packet being received has a frame error.
For EFR32 parts, frame errors include violations of variable length minimum/maximum limits and CRC errors. If RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, RAIL_EVENT_RX_FRAME_ERROR will not occur for CRC errors.
Definition at line 656
of file rail_types.h
.
#define RAIL_EVENT_RX_PACKET_RECEIVED (1ULL << RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT) |
Occurs whenever a packet is received.
Call RAIL_GetRxPacketInfo() to get basic information about the packet along with a handle to this packet for subsequent use with RAIL_PeekRxPacket(), RAIL_GetRxPacketDetails(), RAIL_HoldRxPacket(), and RAIL_ReleaseRxPacket() as needed. If RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event also occurs for packets with CRC errors.
Definition at line 618
of file rail_types.h
.
#define RAIL_EVENT_RX_PREAMBLE_DETECT (1ULL << RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT) |
Occurs when the radio has detected a preamble.
This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a RAIL_EVENT_RX_TIMING_DETECT event has already occurred.
Definition at line 634
of file rail_types.h
.
#define RAIL_EVENT_RX_PREAMBLE_LOST (1ULL << RAIL_EVENT_RX_PREAMBLE_LOST_SHIFT) |
Occurs when the radio has lost a preamble.
This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a RAIL_EVENT_RX_PREAMBLE_DETECT event has already occurred.
Definition at line 626
of file rail_types.h
.
#define RAIL_EVENT_RX_SCHEDULED_RX_END (1ULL << RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT) |
Occurs when the scheduled RX window ends.
This event only occurs in response to a scheduled receive timeout after calling RAIL_ScheduleRx(). If RAIL_ScheduleRxConfig_t::rxTransitionEndSchedule was passed as false, this event will occur unless the receive is aborted (due to a call to RAIL_Idle() or a scheduler pre-emption, for instance). If RAIL_ScheduleRxConfig_t::rxTransitionEndSchedule was passed as true, any of the RAIL_EVENTS_RX_COMPLETION events occurring will also cause this event not to occur, since the scheduled receive will end with the transition at the end of the packet.
Definition at line 690
of file rail_types.h
.
#define RAIL_EVENT_RX_SYNC1_DETECT (1ULL << RAIL_EVENT_RX_SYNC1_DETECT_SHIFT) |
Occurs when the first sync word is detected.
After this event occurs, one of the events in the RAIL_EVENTS_RX_COMPLETION mask will occur.
Definition at line 640
of file rail_types.h
.
#define RAIL_EVENT_RX_SYNC2_DETECT (1ULL << RAIL_EVENT_RX_SYNC2_DETECT_SHIFT) |
Occurs when the second sync word is detected.
After this event occurs, one of the events in the RAIL_EVENTS_RX_COMPLETION mask will occur.
Definition at line 646
of file rail_types.h
.
#define RAIL_EVENT_RX_TIMEOUT (1ULL << RAIL_EVENT_RX_TIMEOUT_SHIFT) |
Occurs when an RX event times out.
This event can only occur if the RAIL_StateTiming_t::rxSearchTimeout passed to RAIL_SetStateTiming() is not zero.
Definition at line 677
of file rail_types.h
.
#define RAIL_EVENT_RX_TIMING_DETECT (1ULL << RAIL_EVENT_RX_TIMING_DETECT_SHIFT) |
Occurs when the modem timing is detected.
This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes.
Definition at line 722
of file rail_types.h
.
#define RAIL_EVENT_RX_TIMING_LOST (1ULL << RAIL_EVENT_RX_TIMING_LOST_SHIFT) |
Occurs when the modem timing is lost.
This event can occur multiple times while searching for a packet and is generally used for diagnostic purposes. It can only occur after a RAIL_EVENT_RX_TIMING_DETECT event has already occurred.
Definition at line 716
of file rail_types.h
.
#define RAIL_EVENT_SCHEDULER_STATUS (1ULL << RAIL_EVENT_SCHEDULER_STATUS_SHIFT) |
Occurs when the scheduler has a status to report.
The exact status can be found with RAIL_GetSchedulerStatus(). See RAIL_SchedulerStatus_t for more details.
- Note
- RAIL_GetSchedulerStatus() is only valid to call during the timeframe of the RAIL_Config_t::eventsCallback.
Definition at line 950
of file rail_types.h
.
#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.
This event can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx().
Definition at line 885
of file rail_types.h
.
#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.
This event can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx().
Definition at line 875
of file rail_types.h
.
#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.
This event can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx().
Definition at line 868
of file rail_types.h
.
#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.
This event does not occur on initialization or after resetting the transmit FIFO with RAIL_ResetFifo(). Call RAIL_GetTxFifoSpaceAvailable() to get the number of bytes available in the transmit FIFO at the time of the callback dispatch. When using this event, the threshold should be set via RAIL_SetTxFifoThreshold().
Definition at line 801
of file rail_types.h
.
#define RAIL_EVENT_TX_PACKET_SENT (1ULL << RAIL_EVENT_TX_PACKET_SENT_SHIFT) |
Occurs after a packet has been transmitted.
Call RAIL_GetTxPacketDetails() to get information about the packet that was transmitted.
- Note
- RAIL_GetTxPacketDetails() is only valid to call during the timeframe of the RAIL_Config_t::eventsCallback.
Definition at line 809
of file rail_types.h
.
#define RAIL_EVENT_TX_START_CCA (1ULL << RAIL_EVENT_TX_START_CCA_SHIFT) |
Occurs when a Clear Channel Assessment (CCA) check begins.
This event can occur multiple times based on the configuration of the ongoing CSMA or LBT transmission. It can only happen after calling RAIL_StartCcaCsmaTx() or RAIL_StartCcaLbtTx().
Definition at line 893
of file rail_types.h
.
#define RAIL_EVENT_TXACK_ABORTED (1ULL << RAIL_EVENT_TXACK_ABORTED_SHIFT) |
Occurs when an ACK transmit is aborted by the user.
This event can only occur after calling RAIL_ConfigAutoAck(), which can happen due to calling RAIL_Idle() or due to a scheduler pre-emption.
Definition at line 831
of file rail_types.h
.
#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.
This event can only occur after calling RAIL_ConfigAutoAck().
Definition at line 844
of file rail_types.h
.
#define RAIL_EVENT_TXACK_PACKET_SENT (1ULL << RAIL_EVENT_TXACK_PACKET_SENT_SHIFT) |
Occurs after an ACK packet has been transmitted.
Call RAIL_GetTxPacketDetails() to get information about the packet that was transmitted. This event can only occur after calling RAIL_ConfigAutoAck().
- Note
- RAIL_GetTxPacketDetails() is only valid to call during the timeframe of the RAIL_Config_t::eventsCallback.
Definition at line 818
of file rail_types.h
.
#define RAIL_EVENT_TXACK_UNDERFLOW (1ULL << RAIL_EVENT_TXACK_UNDERFLOW_SHIFT) |
Occurs when the ACK transmit buffer underflows, which can happen due to the transmitted packet specifying an unintended length based on the current radio configuration or due to RAIL_WriteAutoAckFifo() not being called at all before an ACK transmit.
This event can only occur after calling RAIL_ConfigAutoAck().
Definition at line 861
of file rail_types.h
.
#define RAIL_EVENT_ZWAVE_BEAM (1ULL << RAIL_EVENT_ZWAVE_BEAM_SHIFT) |
Indicates a Z-Wave Beam Request relevant to the node was received.
This event only occurs if the RAIL Z-Wave functionality is enabled and its RAIL_ZWAVE_OPTION_DETECT_BEAM_FRAMES is enabled. This event is used in lieu of RAIL_EVENT_RX_PACKET_RECEIVED, which is reserved for Z-Wave packets other than Beams.
Call RAIL_ZWAVE_GetBeamNodeId() to get the NodeId to which the Beam was targeted, which would be either the broadcast id 0xFF or the node's own single-cast id.
- Note
- All Z-Wave Beam requests are generally discarded, triggering RAIL_EVENT_RX_PACKET_ABORTED.
Definition at line 771
of file rail_types.h
.
#define RAIL_EVENTS_RX_COMPLETION |
rail_types.h:656
rail_types.h:618
rail_types.h:670
rail_types.h:662
rail_types.h:696
The mask representing all events that determine the end of a received packet.
After a RAIL_EVENT_RX_SYNC1_DETECT or a RAIL_EVENT_RX_SYNC2_DETECT, exactly one of the following events will occur. When one of these events occurs, a state transition will take place based on the parameter passed to RAIL_SetRxTransitions(). The RAIL_StateTransitions_t::success transition will be followed only if the RAIL_EVENT_RX_PACKET_RECEIVED event occurs. Any of the other events will trigger the RAIL_StateTransitions_t::error transition.
Definition at line 784
of file rail_types.h
.
#define RAIL_EVENTS_TX_COMPLETION |
rail_types.h:852
rail_types.h:809
rail_types.h:837
rail_types.h:875
rail_types.h:824
A mask representing all events that determine the end of a transmitted packet.
After a RAIL_STATUS_NO_ERROR return value from one of the transmit functions, exactly one of the following events will occur. When one of these events occurs, a state transition takes place based on the parameter passed to RAIL_SetTxTransitions(). The RAIL_StateTransitions_t::success transition will be followed only if the RAIL_EVENT_TX_PACKET_SENT event occurs. Any of the other events will trigger the RAIL_StateTransitions_t::error transition.
Definition at line 905
of file rail_types.h
.
#define RAIL_EVENTS_TXACK_COMPLETION |
rail_types.h:818
rail_types.h:831
rail_types.h:861
rail_types.h:844
A mask representing all events that determine the end of a transmitted ACK packet.
After an ACK-requesting receive, exactly one of the following events will occur. When one of these events occurs, a state transition takes place based on the RAIL_AutoAckConfig_t::rxTransitions passed to RAIL_ConfigAutoAck(). The receive transitions are used because the transmitted ACK packet is considered a part of the ACK-requesting received packet. The RAIL_StateTransitions_t::success transition will be followed only if the RAIL_EVENT_TXACK_PACKET_SENT event occurs. Any of the other events will trigger the RAIL_StateTransitions_t::error transition.
Definition at line 922
of file rail_types.h
.
Enumeration Type Documentation
enum 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_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_RX_SCHEDULED_RX_END_SHIFT |
Shift position of RAIL_EVENT_RX_SCHEDULED_RX_END 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_RX_DUTY_CYCLE_RX_END_SHIFT |
Shift position of RAIL_EVENT_RX_DUTY_CYCLE_RX_END 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_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. |
Definition at line 492
of file rail_types.h
.
Function Documentation
RAIL_Status_t RAIL_ConfigEvents | ( | RAIL_Handle_t | railHandle, |
RAIL_Events_t | mask, |
||
RAIL_Events_t | events |
||
) |
Configures radio events.
- Parameters
-
[in] railHandle
A RAIL instance handle. [in] mask
A bitmask of events to configure. [in] events
A bitmask of events to trigger RAIL_Config_t::eventsCallback For a full list of available callbacks, see RAIL_EVENT_* set of defines.
- Returns
- Status code indicating success of the function call.
Sets up which radio interrupts generate a RAIL event. The full list of options is in RAIL_Events_t.