rf_prop_cmd.h

/******************************************************************************
*  Filename:       rf_prop_cmd.h
*  Revised:        2017-11-10 10:42:47 +0100 (Fri, 10 Nov 2017)
*  Revision:       18052
*
*  Description:    CC2640R2F API for Proprietary mode commands
*
*  Copyright (c) 2015 - 2017, Texas Instruments Incorporated
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions are met:
*
*  1) Redistributions of source code must retain the above copyright notice,
*     this list of conditions and the following disclaimer.
*
*  2) Redistributions in binary form must reproduce the above copyright notice,
*     this list of conditions and the following disclaimer in the documentation
*     and/or other materials provided with the distribution.
*
*  3) Neither the name of the ORGANIZATION nor the names of its contributors may
*     be used to endorse or promote products derived from this software without
*     specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
*  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
*  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
*  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
*  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
*  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
*  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/

#ifndef __PROP_CMD_H
#define __PROP_CMD_H

#ifndef __RFC_STRUCT
#define __RFC_STRUCT
#endif

#ifndef __RFC_STRUCT_ATTR
#if defined(__GNUC__)
#define __RFC_STRUCT_ATTR __attribute__ ((aligned (4)))
#elif defined(__TI_ARM__)
#define __RFC_STRUCT_ATTR __attribute__ ((__packed__,aligned (4)))
#else
#define __RFC_STRUCT_ATTR
#endif
#endif

//! \addtogroup rfc
//! @{

//! \addtogroup prop_cmd
//! @{

#include <stdint.h>
#include "rf_mailbox.h"
#include "rf_common_cmd.h"

typedef struct __RFC_STRUCT rfc_carrierSense_s rfc_carrierSense_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_TX_s rfc_CMD_PROP_TX_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RX_s rfc_CMD_PROP_RX_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_TX_ADV_s rfc_CMD_PROP_TX_ADV_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RX_ADV_s rfc_CMD_PROP_RX_ADV_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_CS_s rfc_CMD_PROP_CS_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RADIO_SETUP_s rfc_CMD_PROP_RADIO_SETUP_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RADIO_DIV_SETUP_s rfc_CMD_PROP_RADIO_DIV_SETUP_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RX_SNIFF_s rfc_CMD_PROP_RX_SNIFF_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RX_ADV_SNIFF_s rfc_CMD_PROP_RX_ADV_SNIFF_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_SET_LEN_s rfc_CMD_PROP_SET_LEN_t;
typedef struct __RFC_STRUCT rfc_CMD_PROP_RESTART_RX_s rfc_CMD_PROP_RESTART_RX_t;
typedef struct __RFC_STRUCT rfc_propRxOutput_s rfc_propRxOutput_t;
typedef struct __RFC_STRUCT rfc_propRxStatus_s rfc_propRxStatus_t;

//! \addtogroup carrierSense
//! @{
struct __RFC_STRUCT rfc_carrierSense_s {
   struct {
      uint8_t bEnaRssi:1;               //!<        If 1, enable RSSI as a criterion
      uint8_t bEnaCorr:1;               //!<        If 1, enable correlation as a criterion
      uint8_t operation:1;              //!< \brief 0: Busy if either RSSI or correlation indicates Busy<br>
                                        //!<        1: Busy if both RSSI and correlation indicates Busy
      uint8_t busyOp:1;                 //!< \brief 0: Continue carrier sense on channel Busy<br>
                                        //!<        1: End carrier sense on channel Busy<br>
                                        //!<        For an RX command, the receiver will continue when carrier sense ends, but it will then not end if channel goes Idle
      uint8_t idleOp:1;                 //!< \brief 0: Continue on channel Idle<br>
                                        //!<        1: End on channel Idle
      uint8_t timeoutRes:1;             //!< \brief 0: Timeout with channel state Invalid treated as Busy<br>
                                        //!<        1: Timeout with channel state Invalid treated as Idle
   } csConf;
   int8_t rssiThr;                      //!<        RSSI threshold
   uint8_t numRssiIdle;                 //!< \brief Number of consecutive RSSI measurements below the threshold needed before the channel is
                                        //!<        declared Idle
   uint8_t numRssiBusy;                 //!< \brief Number of consecutive RSSI measurements above the threshold needed before the channel is
                                        //!<        declared Busy
   uint16_t corrPeriod;                 //!<        Number of RAT ticks for a correlation observation periods
   struct {
      uint8_t numCorrInv:4;             //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Idle to Invalid
      uint8_t numCorrBusy:4;            //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Invalid to Busy
   } corrConfig;
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } csEndTrigger;                      //!<        Trigger classifier for ending the carrier sense
   ratmr_t csEndTime;                   //!<        Time used together with <code>csEndTrigger</code> for ending the operation
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_TX
//! @{
#define CMD_PROP_TX                                             0x3801
//! Proprietary Mode Transmit Command
struct __RFC_STRUCT rfc_CMD_PROP_TX_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3801
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOff:1;                 //!< \brief 0: Keep frequency synth on after command<br>
                                        //!<        1: Turn frequency synth off after command
      uint8_t :2;
      uint8_t bUseCrc:1;                //!< \brief 0: Do not append CRC<br>
                                        //!<        1: Append CRC
      uint8_t bVarLen:1;                //!< \brief 0: Fixed length<br>
                                        //!<        1: Transmit length as first byte
   } pktConf;
   uint8_t pktLen;                      //!<        Packet length
   uint32_t syncWord;                   //!<        Sync word to transmit
   uint8_t* pPkt;                       //!<        Pointer to packet
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RX
//! @{
#define CMD_PROP_RX                                             0x3802
//! Proprietary Mode Receive Command
struct __RFC_STRUCT rfc_CMD_PROP_RX_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3802
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOff:1;                 //!< \brief 0: Keep frequency synth on after command<br>
                                        //!<        1: Turn frequency synth off after command
      uint8_t bRepeatOk:1;              //!< \brief 0: End operation after receiving a packet correctly<br>
                                        //!<        1: Go back to sync search after receiving a packet correctly
      uint8_t bRepeatNok:1;             //!< \brief 0: End operation after receiving a packet with CRC error<br>
                                        //!<        1: Go back to sync search after receiving a packet with CRC error
      uint8_t bUseCrc:1;                //!< \brief 0: Do not check CRC<br>
                                        //!<        1: Check CRC
      uint8_t bVarLen:1;                //!< \brief 0: Fixed length<br>
                                        //!<        1: Receive length as first byte
      uint8_t bChkAddress:1;            //!< \brief 0: No address check<br>
                                        //!<        1: Check address
      uint8_t endType:1;                //!< \brief 0: Packet is received to the end if end trigger happens after sync is obtained<br>
                                        //!<        1: Packet reception is stopped if end trigger happens
      uint8_t filterOp:1;               //!< \brief 0: Stop receiver and restart sync search on address mismatch<br>
                                        //!<        1: Receive packet and mark it as ignored on address mismatch
   } pktConf;
   struct {
      uint8_t bAutoFlushIgnored:1;      //!<        If 1, automatically discard ignored packets from RX queue
      uint8_t bAutoFlushCrcErr:1;       //!<        If 1, automatically discard packets with CRC error from RX queue
      uint8_t :1;
      uint8_t bIncludeHdr:1;            //!<        If 1, include the received header or length byte in the stored packet; otherwise discard it
      uint8_t bIncludeCrc:1;            //!<        If 1, include the received CRC field in the stored packet; otherwise discard it
      uint8_t bAppendRssi:1;            //!<        If 1, append an RSSI byte to the packet in the RX queue
      uint8_t bAppendTimestamp:1;       //!<        If 1, append a timestamp to the packet in the RX queue
      uint8_t bAppendStatus:1;          //!<        If 1, append a status byte to the packet in the RX queue
   } rxConf;                            //!<        RX configuration
   uint32_t syncWord;                   //!<        Sync word to listen for
   uint8_t maxPktLen;                   //!< \brief Packet length for fixed length, maximum packet length for variable length<br>
                                        //!<        0: Unlimited or unknown length
   uint8_t address0;                    //!<        Address
   uint8_t address1;                    //!< \brief Address (set equal to <code>address0</code> to accept only one address. If 0xFF, accept
                                        //!<        0x00 as well)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } endTrigger;                        //!<        Trigger classifier for ending the operation
   ratmr_t endTime;                     //!<        Time used together with <code>endTrigger</code> for ending the operation
   dataQueue_t* pQueue;                 //!<        Pointer to receive queue
   uint8_t* pOutput;                    //!<        Pointer to output structure
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_TX_ADV
//! @{
#define CMD_PROP_TX_ADV                                         0x3803
//! Proprietary Mode Advanced Transmit Command
struct __RFC_STRUCT rfc_CMD_PROP_TX_ADV_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3803
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOff:1;                 //!< \brief 0: Keep frequency synth on after command<br>
                                        //!<        1: Turn frequency synth off after command
      uint8_t :2;
      uint8_t bUseCrc:1;                //!< \brief 0: Do not append CRC<br>
                                        //!<        1: Append CRC
      uint8_t bCrcIncSw:1;              //!< \brief 0:Do not include sync word in CRC calculation<br>
                                        //!<        1: Include sync word in CRC calculation
      uint8_t bCrcIncHdr:1;             //!< \brief 0: Do not include header in CRC calculation<br>
                                        //!<        1: Include header in CRC calculation
   } pktConf;
   uint8_t numHdrBits;                  //!<        Number of bits in header (0--32)
   uint16_t pktLen;                     //!<        Packet length. 0: Unlimited
   struct {
      uint8_t bExtTxTrig:1;             //!< \brief 0: Start packet on a fixed time from the command start trigger<br>
                                        //!<        1: Start packet on an external trigger (input event to RAT)
      uint8_t inputMode:2;              //!< \brief Input mode if external trigger is used for TX start<br>
                                        //!<        0: Rising edge<br>
                                        //!<        1: Falling edge<br>
                                        //!<        2: Both edges<br>
                                        //!<        3: <i>Reserved</i>
      uint8_t source:5;                 //!<        RAT input event number used for capture if external trigger is used for TX start
   } startConf;
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } preTrigger;                        //!<        Trigger for transition from preamble to sync word
   ratmr_t preTime;                     //!< \brief Time used together with <code>preTrigger</code> for transition from preamble to sync
                                        //!<        word. If <code>preTrigger.triggerType</code> is set to "now", one preamble as
                                        //!<        configured in the setup will be sent. Otherwise, the preamble will be repeated until
                                        //!<        this trigger is observed.
   uint32_t syncWord;                   //!<        Sync word to transmit
   uint8_t* pPkt;                       //!<        Pointer to packet, or TX queue for unlimited length
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RX_ADV
//! @{
#define CMD_PROP_RX_ADV                                         0x3804
//! Proprietary Mode Advanced Receive Command
struct __RFC_STRUCT rfc_CMD_PROP_RX_ADV_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3804
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOff:1;                 //!< \brief 0: Keep frequency synth on after command<br>
                                        //!<        1: Turn frequency synth off after command
      uint8_t bRepeatOk:1;              //!< \brief 0: End operation after receiving a packet correctly<br>
                                        //!<        1: Go back to sync search after receiving a packet correctly
      uint8_t bRepeatNok:1;             //!< \brief 0: End operation after receiving a packet with CRC error<br>
                                        //!<        1: Go back to sync search after receiving a packet with CRC error
      uint8_t bUseCrc:1;                //!< \brief 0: Do not check CRC<br>
                                        //!<        1: Check CRC
      uint8_t bCrcIncSw:1;              //!< \brief 0: Do not include sync word in CRC calculation<br>
                                        //!<        1: Include sync word in CRC calculation
      uint8_t bCrcIncHdr:1;             //!< \brief 0: Do not include header in CRC calculation <br>
                                        //!<        1: Include header in CRC calculation
      uint8_t endType:1;                //!< \brief 0: Packet is received to the end if end trigger happens after sync is obtained<br>
                                        //!<        1: Packet reception is stopped if end trigger happens
      uint8_t filterOp:1;               //!< \brief 0: Stop receiver and restart sync search on address mismatch<br>
                                        //!<        1: Receive packet and mark it as ignored on address mismatch
   } pktConf;
   struct {
      uint8_t bAutoFlushIgnored:1;      //!<        If 1, automatically discard ignored packets from RX queue
      uint8_t bAutoFlushCrcErr:1;       //!<        If 1, automatically discard packets with CRC error from RX queue
      uint8_t :1;
      uint8_t bIncludeHdr:1;            //!<        If 1, include the received header or length byte in the stored packet; otherwise discard it
      uint8_t bIncludeCrc:1;            //!<        If 1, include the received CRC field in the stored packet; otherwise discard it
      uint8_t bAppendRssi:1;            //!<        If 1, append an RSSI byte to the packet in the RX queue
      uint8_t bAppendTimestamp:1;       //!<        If 1, append a timestamp to the packet in the RX queue
      uint8_t bAppendStatus:1;          //!<        If 1, append a status byte to the packet in the RX queue
   } rxConf;                            //!<        RX configuration
   uint32_t syncWord0;                  //!<        Sync word to listen for
   uint32_t syncWord1;                  //!<        Alternative sync word if non-zero
   uint16_t maxPktLen;                  //!< \brief Packet length for fixed length, maximum packet length for variable length<br>
                                        //!<        0: Unlimited or unknown length
   struct {
      uint16_t numHdrBits:6;            //!<        Number of bits in header (0--32)
      uint16_t lenPos:5;                //!<        Position of length field in header (0--31)
      uint16_t numLenBits:5;            //!<        Number of bits in length field (0--16)
   } hdrConf;
   struct {
      uint16_t addrType:1;              //!< \brief 0: Address after header<br>
                                        //!<        1: Address in header
      uint16_t addrSize:5;              //!< \brief If <code>addrType</code> = 0: Address size in bytes<br>
                                        //!<        If <code>addrType</code> = 1: Address size in bits
      uint16_t addrPos:5;               //!< \brief If <code>addrType</code> = 1: Bit position of address in header<br>
                                        //!<        If <code>addrType</code> = 0: Non-zero to extend address with sync word identifier
      uint16_t numAddr:5;               //!<        Number of addresses in address list
   } addrConf;
   int8_t lenOffset;                    //!<        Signed value to add to length field
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } endTrigger;                        //!<        Trigger classifier for ending the operation
   ratmr_t endTime;                     //!<        Time used together with <code>endTrigger</code> for ending the operation
   uint8_t* pAddr;                      //!<        Pointer to address list
   dataQueue_t* pQueue;                 //!<        Pointer to receive queue
   uint8_t* pOutput;                    //!<        Pointer to output structure
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_CS
//! @{
#define CMD_PROP_CS                                             0x3805
//! Carrier Sense Command
struct __RFC_STRUCT rfc_CMD_PROP_CS_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3805
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOffIdle:1;             //!< \brief 0: Keep synth running if command ends with channel Idle<br>
                                        //!<        1: Turn off synth if command ends with channel Idle
      uint8_t bFsOffBusy:1;             //!< \brief 0: Keep synth running if command ends with channel Busy<br>
                                        //!<        1: Turn off synth if command ends with channel Busy
   } csFsConf;
   uint8_t __dummy0;
   struct {
      uint8_t bEnaRssi:1;               //!<        If 1, enable RSSI as a criterion
      uint8_t bEnaCorr:1;               //!<        If 1, enable correlation as a criterion
      uint8_t operation:1;              //!< \brief 0: Busy if either RSSI or correlation indicates Busy<br>
                                        //!<        1: Busy if both RSSI and correlation indicates Busy
      uint8_t busyOp:1;                 //!< \brief 0: Continue carrier sense on channel Busy<br>
                                        //!<        1: End carrier sense on channel Busy<br>
                                        //!<        For an RX command, the receiver will continue when carrier sense ends, but it will then not end if channel goes Idle
      uint8_t idleOp:1;                 //!< \brief 0: Continue on channel Idle<br>
                                        //!<        1: End on channel Idle
      uint8_t timeoutRes:1;             //!< \brief 0: Timeout with channel state Invalid treated as Busy<br>
                                        //!<        1: Timeout with channel state Invalid treated as Idle
   } csConf;
   int8_t rssiThr;                      //!<        RSSI threshold
   uint8_t numRssiIdle;                 //!< \brief Number of consecutive RSSI measurements below the threshold needed before the channel is
                                        //!<        declared Idle
   uint8_t numRssiBusy;                 //!< \brief Number of consecutive RSSI measurements above the threshold needed before the channel is
                                        //!<        declared Busy
   uint16_t corrPeriod;                 //!<        Number of RAT ticks for a correlation observation periods
   struct {
      uint8_t numCorrInv:4;             //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Idle to Invalid
      uint8_t numCorrBusy:4;            //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Invalid to Busy
   } corrConfig;
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } csEndTrigger;                      //!<        Trigger classifier for ending the carrier sense
   ratmr_t csEndTime;                   //!<        Time used together with <code>csEndTrigger</code> for ending the operation
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RADIO_SETUP
//! @{
#define CMD_PROP_RADIO_SETUP                                    0x3806
//! Proprietary Mode Radio Setup Command
struct __RFC_STRUCT rfc_CMD_PROP_RADIO_SETUP_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3806
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint16_t modType:3;               //!< \brief 0: FSK<br>
                                        //!<        1: GFSK<br>
                                        //!<        Others: <i>Reserved</i>
      uint16_t deviation:13;            //!<        Deviation (250 Hz steps)
   } modulation;
   struct {
      uint32_t preScale:4;              //!<        Prescaler value
      uint32_t :4;
      uint32_t rateWord:21;             //!<        Rate word
      uint32_t decimMode:3;             //!< \brief 0: Use automatic PDIF decimation<br>
                                        //!<        1: Force PDIF decimation to 0<br>
                                        //!<        3: Force PDIF decimation to 1<br>
                                        //!<        5: Force PDIF decimation to 2<br>
                                        //!<        Others: <i>Reserved</i>
   } symbolRate;                        //!<        Symbol rate setting
   uint8_t rxBw;                        //!<        Receiver bandwidth
   struct {
      uint8_t nPreamBytes:6;            //!< \brief 0: 1 preamble bit<br>
                                        //!<        1--16: Number of preamble bytes<br>
                                        //!<        18, 20, ..., 30: Number of preamble bytes<br>
                                        //!<        31: 4 preamble bits<br>
                                        //!<        32: 32 preamble bytes<br>
                                        //!<        Others: <i>Reserved</i>
      uint8_t preamMode:2;              //!< \brief 0: Send 0 as the first preamble bit<br>
                                        //!<        1: Send 1 as the first preamble bit<br>
                                        //!<        2: Send same first bit in preamble and sync word<br>
                                        //!<        3: Send different first bit in preamble and sync word
   } preamConf;
   struct {
      uint16_t nSwBits:6;               //!<        Number of sync word bits (8--32)
      uint16_t bBitReversal:1;          //!< \brief 0: Use positive deviation for 1<br>
                                        //!<        1: Use positive deviation for 0
      uint16_t bMsbFirst:1;             //!< \brief 0: Least significant bit transmitted first<br>
                                        //!<        1: Most significant bit transmitted first
      uint16_t fecMode:4;               //!< \brief Select coding<br>
                                        //!<        0: Uncoded binary modulation<br>
                                        //!<        10: Manchester coded binary modulation<br>
                                        //!<        Others: <i>Reserved</i>
      uint16_t :1;
      uint16_t whitenMode:3;            //!< \brief 0: No whitening<br>
                                        //!<        1: CC1101/CC2500 compatible whitening<br>
                                        //!<        2: PN9 whitening without byte reversal<br>
                                        //!<        3: <i>Reserved</i><br>
                                        //!<        4: No whitener, 32-bit IEEE 802.15.4g compatible CRC<br>
                                        //!<        5: IEEE 802.15.4g compatible whitener and 32-bit CRC<br>
                                        //!<        6: No whitener, dynamically IEEE 802.15.4g compatible 16-bit or 32-bit CRC<br>
                                        //!<        7: Dynamically IEEE 802.15.4g compatible whitener and 16-bit or 32-bit CRC
   } formatConf;
   struct {
      uint16_t frontEndMode:3;          //!< \brief 0x00: Differential mode<br>
                                        //!<        0x01: Single-ended mode RFP<br>
                                        //!<        0x02: Single-ended mode RFN<br>
                                        //!<        0x05 Single-ended mode RFP with external frontend control on RF pins (RFN and RXTX)<br>
                                        //!<        0x06 Single-ended mode RFN with external frontend control on RF pins (RFP and RXTX)<br>
                                        //!<        Others: <i>Reserved</i>
      uint16_t biasMode:1;              //!< \brief 0: Internal bias<br>
                                        //!<        1: External bias
      uint16_t analogCfgMode:6;         //!< \brief 0x00: Write analog configuration.<br>
                                        //!<        Required first time after boot and when changing frequency band
                                        //!<        or front-end configuration<br>
                                        //!<        0x2D: Keep analog configuration.<br>
                                        //!<        May be used after standby or when changing mode with the same frequency
                                        //!<        band and front-end configuration<br>
                                        //!<        Others: <i>Reserved</i>
      uint16_t bNoFsPowerUp:1;          //!< \brief 0: Power up frequency synth<br>
                                        //!<        1: Do not power up frequency synth
   } config;                            //!<        Configuration options
   uint16_t txPower;                    //!< \brief TX power setting
                                        //!<        Bits 0--5: IB
                                        //!<        Value to write to the PA power control field at 25 &deg;C
                                        //!<        Bits 6--7: GC
                                        //!<        Value to write to the gain control of the 1st stage of the PA
                                        //!<        Bits 8--15: tempCoeff
                                        //!<        Temperature coefficient for IB. 0: No temperature compensation
   uint32_t* pRegOverride;              //!< \brief Pointer to a list of hardware and configuration registers to override. If NULL, no
                                        //!<        override is used.
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RADIO_DIV_SETUP
//! @{
#define CMD_PROP_RADIO_DIV_SETUP                                0x3807
//! Define only for compatibility with CC13XX family. Command will result in error if sent.
struct __RFC_STRUCT rfc_CMD_PROP_RADIO_DIV_SETUP_s {
   uint8_t dummy0;
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RX_SNIFF
//! @{
#define CMD_PROP_RX_SNIFF                                       0x3808
//! Proprietary Mode Receive Command with Sniff Mode
struct __RFC_STRUCT rfc_CMD_PROP_RX_SNIFF_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3808
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOff:1;                 //!< \brief 0: Keep frequency synth on after command<br>
                                        //!<        1: Turn frequency synth off after command
      uint8_t bRepeatOk:1;              //!< \brief 0: End operation after receiving a packet correctly<br>
                                        //!<        1: Go back to sync search after receiving a packet correctly
      uint8_t bRepeatNok:1;             //!< \brief 0: End operation after receiving a packet with CRC error<br>
                                        //!<        1: Go back to sync search after receiving a packet with CRC error
      uint8_t bUseCrc:1;                //!< \brief 0: Do not check CRC<br>
                                        //!<        1: Check CRC
      uint8_t bVarLen:1;                //!< \brief 0: Fixed length<br>
                                        //!<        1: Receive length as first byte
      uint8_t bChkAddress:1;            //!< \brief 0: No address check<br>
                                        //!<        1: Check address
      uint8_t endType:1;                //!< \brief 0: Packet is received to the end if end trigger happens after sync is obtained<br>
                                        //!<        1: Packet reception is stopped if end trigger happens
      uint8_t filterOp:1;               //!< \brief 0: Stop receiver and restart sync search on address mismatch<br>
                                        //!<        1: Receive packet and mark it as ignored on address mismatch
   } pktConf;
   struct {
      uint8_t bAutoFlushIgnored:1;      //!<        If 1, automatically discard ignored packets from RX queue
      uint8_t bAutoFlushCrcErr:1;       //!<        If 1, automatically discard packets with CRC error from RX queue
      uint8_t :1;
      uint8_t bIncludeHdr:1;            //!<        If 1, include the received header or length byte in the stored packet; otherwise discard it
      uint8_t bIncludeCrc:1;            //!<        If 1, include the received CRC field in the stored packet; otherwise discard it
      uint8_t bAppendRssi:1;            //!<        If 1, append an RSSI byte to the packet in the RX queue
      uint8_t bAppendTimestamp:1;       //!<        If 1, append a timestamp to the packet in the RX queue
      uint8_t bAppendStatus:1;          //!<        If 1, append a status byte to the packet in the RX queue
   } rxConf;                            //!<        RX configuration
   uint32_t syncWord;                   //!<        Sync word to listen for
   uint8_t maxPktLen;                   //!< \brief Packet length for fixed length, maximum packet length for variable length<br>
                                        //!<        0: Unlimited or unknown length
   uint8_t address0;                    //!<        Address
   uint8_t address1;                    //!< \brief Address (set equal to <code>address0</code> to accept only one address. If 0xFF, accept
                                        //!<        0x00 as well)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } endTrigger;                        //!<        Trigger classifier for ending the operation
   ratmr_t endTime;                     //!<        Time used together with <code>endTrigger</code> for ending the operation
   dataQueue_t* pQueue;                 //!<        Pointer to receive queue
   uint8_t* pOutput;                    //!<        Pointer to output structure
   struct {
      uint8_t bEnaRssi:1;               //!<        If 1, enable RSSI as a criterion
      uint8_t bEnaCorr:1;               //!<        If 1, enable correlation as a criterion
      uint8_t operation:1;              //!< \brief 0: Busy if either RSSI or correlation indicates Busy<br>
                                        //!<        1: Busy if both RSSI and correlation indicates Busy
      uint8_t busyOp:1;                 //!< \brief 0: Continue carrier sense on channel Busy<br>
                                        //!<        1: End carrier sense on channel Busy<br>
                                        //!<        For an RX command, the receiver will continue when carrier sense ends, but it will then not end if channel goes Idle
      uint8_t idleOp:1;                 //!< \brief 0: Continue on channel Idle<br>
                                        //!<        1: End on channel Idle
      uint8_t timeoutRes:1;             //!< \brief 0: Timeout with channel state Invalid treated as Busy<br>
                                        //!<        1: Timeout with channel state Invalid treated as Idle
   } csConf;
   int8_t rssiThr;                      //!<        RSSI threshold
   uint8_t numRssiIdle;                 //!< \brief Number of consecutive RSSI measurements below the threshold needed before the channel is
                                        //!<        declared Idle
   uint8_t numRssiBusy;                 //!< \brief Number of consecutive RSSI measurements above the threshold needed before the channel is
                                        //!<        declared Busy
   uint16_t corrPeriod;                 //!<        Number of RAT ticks for a correlation observation periods
   struct {
      uint8_t numCorrInv:4;             //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Idle to Invalid
      uint8_t numCorrBusy:4;            //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Invalid to Busy
   } corrConfig;
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } csEndTrigger;                      //!<        Trigger classifier for ending the carrier sense
   ratmr_t csEndTime;                   //!<        Time used together with <code>csEndTrigger</code> for ending the operation
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RX_ADV_SNIFF
//! @{
#define CMD_PROP_RX_ADV_SNIFF                                   0x3809
//! Proprietary Mode Advanced Receive Command with Sniff Mode
struct __RFC_STRUCT rfc_CMD_PROP_RX_ADV_SNIFF_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3809
   uint16_t status;                     //!< \brief An integer telling the status of the command. This value is
                                        //!<        updated by the radio CPU during operation and may be read by the
                                        //!<        system CPU at any time.
   rfc_radioOp_t *pNextOp;              //!<        Pointer to the next operation to run after this operation is done
   ratmr_t startTime;                   //!<        Absolute or relative start time (depending on the value of <code>startTrigger</code>)
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } startTrigger;                      //!<        Identification of the trigger that starts the operation
   struct {
      uint8_t rule:4;                   //!<        Condition for running next command: Rule for how to proceed
      uint8_t nSkip:4;                  //!<        Number of skips + 1 if the rule involves skipping. 0: same, 1: next, 2: skip next, ...
   } condition;
   struct {
      uint8_t bFsOff:1;                 //!< \brief 0: Keep frequency synth on after command<br>
                                        //!<        1: Turn frequency synth off after command
      uint8_t bRepeatOk:1;              //!< \brief 0: End operation after receiving a packet correctly<br>
                                        //!<        1: Go back to sync search after receiving a packet correctly
      uint8_t bRepeatNok:1;             //!< \brief 0: End operation after receiving a packet with CRC error<br>
                                        //!<        1: Go back to sync search after receiving a packet with CRC error
      uint8_t bUseCrc:1;                //!< \brief 0: Do not check CRC<br>
                                        //!<        1: Check CRC
      uint8_t bCrcIncSw:1;              //!< \brief 0: Do not include sync word in CRC calculation<br>
                                        //!<        1: Include sync word in CRC calculation
      uint8_t bCrcIncHdr:1;             //!< \brief 0: Do not include header in CRC calculation <br>
                                        //!<        1: Include header in CRC calculation
      uint8_t endType:1;                //!< \brief 0: Packet is received to the end if end trigger happens after sync is obtained<br>
                                        //!<        1: Packet reception is stopped if end trigger happens
      uint8_t filterOp:1;               //!< \brief 0: Stop receiver and restart sync search on address mismatch<br>
                                        //!<        1: Receive packet and mark it as ignored on address mismatch
   } pktConf;
   struct {
      uint8_t bAutoFlushIgnored:1;      //!<        If 1, automatically discard ignored packets from RX queue
      uint8_t bAutoFlushCrcErr:1;       //!<        If 1, automatically discard packets with CRC error from RX queue
      uint8_t :1;
      uint8_t bIncludeHdr:1;            //!<        If 1, include the received header or length byte in the stored packet; otherwise discard it
      uint8_t bIncludeCrc:1;            //!<        If 1, include the received CRC field in the stored packet; otherwise discard it
      uint8_t bAppendRssi:1;            //!<        If 1, append an RSSI byte to the packet in the RX queue
      uint8_t bAppendTimestamp:1;       //!<        If 1, append a timestamp to the packet in the RX queue
      uint8_t bAppendStatus:1;          //!<        If 1, append a status byte to the packet in the RX queue
   } rxConf;                            //!<        RX configuration
   uint32_t syncWord0;                  //!<        Sync word to listen for
   uint32_t syncWord1;                  //!<        Alternative sync word if non-zero
   uint16_t maxPktLen;                  //!< \brief Packet length for fixed length, maximum packet length for variable length<br>
                                        //!<        0: Unlimited or unknown length
   struct {
      uint16_t numHdrBits:6;            //!<        Number of bits in header (0--32)
      uint16_t lenPos:5;                //!<        Position of length field in header (0--31)
      uint16_t numLenBits:5;            //!<        Number of bits in length field (0--16)
   } hdrConf;
   struct {
      uint16_t addrType:1;              //!< \brief 0: Address after header<br>
                                        //!<        1: Address in header
      uint16_t addrSize:5;              //!< \brief If <code>addrType</code> = 0: Address size in bytes<br>
                                        //!<        If <code>addrType</code> = 1: Address size in bits
      uint16_t addrPos:5;               //!< \brief If <code>addrType</code> = 1: Bit position of address in header<br>
                                        //!<        If <code>addrType</code> = 0: Non-zero to extend address with sync word identifier
      uint16_t numAddr:5;               //!<        Number of addresses in address list
   } addrConf;
   int8_t lenOffset;                    //!<        Signed value to add to length field
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } endTrigger;                        //!<        Trigger classifier for ending the operation
   ratmr_t endTime;                     //!<        Time used together with <code>endTrigger</code> for ending the operation
   uint8_t* pAddr;                      //!<        Pointer to address list
   dataQueue_t* pQueue;                 //!<        Pointer to receive queue
   uint8_t* pOutput;                    //!<        Pointer to output structure
   struct {
      uint8_t bEnaRssi:1;               //!<        If 1, enable RSSI as a criterion
      uint8_t bEnaCorr:1;               //!<        If 1, enable correlation as a criterion
      uint8_t operation:1;              //!< \brief 0: Busy if either RSSI or correlation indicates Busy<br>
                                        //!<        1: Busy if both RSSI and correlation indicates Busy
      uint8_t busyOp:1;                 //!< \brief 0: Continue carrier sense on channel Busy<br>
                                        //!<        1: End carrier sense on channel Busy<br>
                                        //!<        For an RX command, the receiver will continue when carrier sense ends, but it will then not end if channel goes Idle
      uint8_t idleOp:1;                 //!< \brief 0: Continue on channel Idle<br>
                                        //!<        1: End on channel Idle
      uint8_t timeoutRes:1;             //!< \brief 0: Timeout with channel state Invalid treated as Busy<br>
                                        //!<        1: Timeout with channel state Invalid treated as Idle
   } csConf;
   int8_t rssiThr;                      //!<        RSSI threshold
   uint8_t numRssiIdle;                 //!< \brief Number of consecutive RSSI measurements below the threshold needed before the channel is
                                        //!<        declared Idle
   uint8_t numRssiBusy;                 //!< \brief Number of consecutive RSSI measurements above the threshold needed before the channel is
                                        //!<        declared Busy
   uint16_t corrPeriod;                 //!<        Number of RAT ticks for a correlation observation periods
   struct {
      uint8_t numCorrInv:4;             //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Idle to Invalid
      uint8_t numCorrBusy:4;            //!< \brief Number of subsequent correlation tops with maximum <code>corrPeriod</code> RAT
                                        //!<        ticks between them needed to go from Invalid to Busy
   } corrConfig;
   struct {
      uint8_t triggerType:4;            //!<        The type of trigger
      uint8_t bEnaCmd:1;                //!< \brief 0: No alternative trigger command<br>
                                        //!<        1: CMD_TRIGGER can be used as an alternative trigger
      uint8_t triggerNo:2;              //!<        The trigger number of the CMD_TRIGGER command that triggers this action
      uint8_t pastTrig:1;               //!< \brief 0: A trigger in the past is never triggered, or for start of commands, give an error<br>
                                        //!<        1: A trigger in the past is triggered as soon as possible
   } csEndTrigger;                      //!<        Trigger classifier for ending the carrier sense
   ratmr_t csEndTime;                   //!<        Time used together with <code>csEndTrigger</code> for ending the operation
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_SET_LEN
//! @{
#define CMD_PROP_SET_LEN                                        0x3401
//! Set Packet Length Command
struct __RFC_STRUCT rfc_CMD_PROP_SET_LEN_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3401
   uint16_t rxLen;                      //!<        Payload length to use
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup CMD_PROP_RESTART_RX
//! @{
#define CMD_PROP_RESTART_RX                                     0x3402
//! Restart Packet  Command
struct __RFC_STRUCT rfc_CMD_PROP_RESTART_RX_s {
   uint16_t commandNo;                  //!<        The command ID number 0x3402
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup propRxOutput
//! @{
//! Output structure for RX operations

struct __RFC_STRUCT rfc_propRxOutput_s {
   uint16_t nRxOk;                      //!<        Number of packets that have been received with payload, CRC OK and not ignored
   uint16_t nRxNok;                     //!<        Number of packets that have been received with CRC error
   uint8_t nRxIgnored;                  //!<        Number of packets that have been received with CRC OK and ignored due to address mismatch
   uint8_t nRxStopped;                  //!<        Number of packets not received due to illegal length or address mismatch with pktConf.filterOp = 1
   uint8_t nRxBufFull;                  //!<        Number of packets that have been received and discarded due to lack of buffer space
   int8_t lastRssi;                     //!<        RSSI of last received packet
   ratmr_t timeStamp;                   //!<        Time stamp of last received packet
} __RFC_STRUCT_ATTR;

//! @}

//! \addtogroup propRxStatus
//! @{
//! Receive status byte that may be appended to message in receive buffer

struct __RFC_STRUCT rfc_propRxStatus_s {
   struct {
      uint8_t addressInd:5;             //!<        Index of address found (0 if not applicable)
      uint8_t syncWordId:1;             //!<        0 for primary sync word, 1 for alternate sync word
      uint8_t result:2;                 //!< \brief 0: Packet received correctly, not ignored<br>
                                        //!<        1: Packet received with CRC error<br>
                                        //!<        2: Packet received correctly, but can be ignored<br>
                                        //!<        3: Packet reception was aborted
   } status;
} __RFC_STRUCT_ATTR;

//! @}

//! @}
//! @}
#endif