nes-proj/cpu/cc26xx-cc13xx/rf-core/api/common_cmd.h
Jonas Olsson 01e36532c2 Add support for the CC13xx CPU
This commit:

* Moves all cpu files from cpu/cc26xx to cpu/cc26xx-cc13xx
* Bumps the CC26xxware submodule to the latest TI release
* Adds CC13xxware as a submodule
* Adds support for sub-ghz mode / IEEE 802.15.4g
* Splits the driver into multiple files for clarity. We now have the following structure:
  * A common module that handles access to the RF core, interrupts etc
  * A module that takes care of BLE functionality
  * A netstack radio driver for IEEE mode (2.4GHz)
  * A netstack radio driver for PROP mode (sub-ghz - multiple bands)

This commit also adds tick suppression functionality, applicable to all chips of the CC26xx and CC13xx families. Instead waking up on every clock tick simply to increment our software counter, we now only wake up just in time to service the next scheduled etimer. ContikiMAC-triggered wakeups are unaffected.

Laslty, this commit also applies a number of minor changes:
* Addition of missing includes
* Removal of stub functions
* Removal of a woraround for a CC26xxware bug that has now been fixed
2015-08-23 19:54:42 +01:00

1032 lines
63 KiB
C

/******************************************************************************
* Filename: common_cmd.h
* Revised: 2015-08-04 10:40:45 +0200 (Tue, 04 Aug 2015)
* Revision: 44326
*
* Description: CC13xx API for common/generic commands
*
* Copyright (c) 2015, 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 COMMON_CMD_H_
#define COMMON_CMD_H_
#ifndef __RFC_STRUCT
#ifdef __GNUC__
#define __RFC_STRUCT __attribute__ ((aligned (4)))
#else
#define __RFC_STRUCT
#endif
#endif
//! \addtogroup rfc
//! @{
//! \addtogroup common_cmd
//! @{
#include <stdint.h>
#include "mailbox.h"
typedef struct __RFC_STRUCT rfc_command_s rfc_command_t;
typedef struct __RFC_STRUCT rfc_radioOp_s rfc_radioOp_t;
typedef struct __RFC_STRUCT rfc_CMD_NOP_s rfc_CMD_NOP_t;
typedef struct __RFC_STRUCT rfc_CMD_RADIO_SETUP_s rfc_CMD_RADIO_SETUP_t;
typedef struct __RFC_STRUCT rfc_CMD_FS_s rfc_CMD_FS_t;
typedef struct __RFC_STRUCT rfc_CMD_FS_OFF_s rfc_CMD_FS_OFF_t;
typedef struct __RFC_STRUCT rfc_CMD_RX_s rfc_CMD_RX_t;
typedef struct __RFC_STRUCT rfc_CMD_TX_s rfc_CMD_TX_t;
typedef struct __RFC_STRUCT rfc_CMD_RX_TEST_s rfc_CMD_RX_TEST_t;
typedef struct __RFC_STRUCT rfc_CMD_TX_TEST_s rfc_CMD_TX_TEST_t;
typedef struct __RFC_STRUCT rfc_CMD_SYNC_STOP_RAT_s rfc_CMD_SYNC_STOP_RAT_t;
typedef struct __RFC_STRUCT rfc_CMD_SYNC_START_RAT_s rfc_CMD_SYNC_START_RAT_t;
typedef struct __RFC_STRUCT rfc_CMD_COUNT_s rfc_CMD_COUNT_t;
typedef struct __RFC_STRUCT rfc_CMD_FS_POWERUP_s rfc_CMD_FS_POWERUP_t;
typedef struct __RFC_STRUCT rfc_CMD_FS_POWERDOWN_s rfc_CMD_FS_POWERDOWN_t;
typedef struct __RFC_STRUCT rfc_CMD_SCH_IMM_s rfc_CMD_SCH_IMM_t;
typedef struct __RFC_STRUCT rfc_CMD_COUNT_BRANCH_s rfc_CMD_COUNT_BRANCH_t;
typedef struct __RFC_STRUCT rfc_CMD_PATTERN_CHECK_s rfc_CMD_PATTERN_CHECK_t;
typedef struct __RFC_STRUCT rfc_CMD_TX_POWER_BOOST_s rfc_CMD_TX_POWER_BOOST_t;
typedef struct __RFC_STRUCT rfc_CMD_ABORT_s rfc_CMD_ABORT_t;
typedef struct __RFC_STRUCT rfc_CMD_STOP_s rfc_CMD_STOP_t;
typedef struct __RFC_STRUCT rfc_CMD_GET_RSSI_s rfc_CMD_GET_RSSI_t;
typedef struct __RFC_STRUCT rfc_CMD_UPDATE_RADIO_SETUP_s rfc_CMD_UPDATE_RADIO_SETUP_t;
typedef struct __RFC_STRUCT rfc_CMD_TRIGGER_s rfc_CMD_TRIGGER_t;
typedef struct __RFC_STRUCT rfc_CMD_GET_FW_INFO_s rfc_CMD_GET_FW_INFO_t;
typedef struct __RFC_STRUCT rfc_CMD_START_RAT_s rfc_CMD_START_RAT_t;
typedef struct __RFC_STRUCT rfc_CMD_PING_s rfc_CMD_PING_t;
typedef struct __RFC_STRUCT rfc_CMD_ADD_DATA_ENTRY_s rfc_CMD_ADD_DATA_ENTRY_t;
typedef struct __RFC_STRUCT rfc_CMD_REMOVE_DATA_ENTRY_s rfc_CMD_REMOVE_DATA_ENTRY_t;
typedef struct __RFC_STRUCT rfc_CMD_FLUSH_QUEUE_s rfc_CMD_FLUSH_QUEUE_t;
typedef struct __RFC_STRUCT rfc_CMD_CLEAR_RX_s rfc_CMD_CLEAR_RX_t;
typedef struct __RFC_STRUCT rfc_CMD_REMOVE_PENDING_ENTRIES_s rfc_CMD_REMOVE_PENDING_ENTRIES_t;
typedef struct __RFC_STRUCT rfc_CMD_SET_RAT_CMP_s rfc_CMD_SET_RAT_CMP_t;
typedef struct __RFC_STRUCT rfc_CMD_SET_RAT_CPT_s rfc_CMD_SET_RAT_CPT_t;
typedef struct __RFC_STRUCT rfc_CMD_DISABLE_RAT_CH_s rfc_CMD_DISABLE_RAT_CH_t;
typedef struct __RFC_STRUCT rfc_CMD_SET_RAT_OUTPUT_s rfc_CMD_SET_RAT_OUTPUT_t;
typedef struct __RFC_STRUCT rfc_CMD_ARM_RAT_CH_s rfc_CMD_ARM_RAT_CH_t;
typedef struct __RFC_STRUCT rfc_CMD_DISARM_RAT_CH_s rfc_CMD_DISARM_RAT_CH_t;
typedef struct __RFC_STRUCT rfc_CMD_SET_TX_POWER_s rfc_CMD_SET_TX_POWER_t;
typedef struct __RFC_STRUCT rfc_CMD_UPDATE_FS_s rfc_CMD_UPDATE_FS_t;
typedef struct __RFC_STRUCT rfc_CMD_BUS_REQUEST_s rfc_CMD_BUS_REQUEST_t;
//! \addtogroup command
//! @{
struct __RFC_STRUCT rfc_command_s {
uint16_t commandNo; //!< The command ID number
};
//! @}
//! \addtogroup radioOp
//! @{
//! Common definition for radio operation commands
struct __RFC_STRUCT rfc_radioOp_s {
uint16_t commandNo; //!< The command ID number
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 if the rule involves skipping
} condition;
};
//! @}
//! \addtogroup CMD_NOP
//! @{
#define CMD_NOP 0x0801
struct __RFC_STRUCT rfc_CMD_NOP_s {
uint16_t commandNo; //!< The command ID number 0x0801
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 if the rule involves skipping
} condition;
};
//! @}
//! \addtogroup CMD_RADIO_SETUP
//! @{
#define CMD_RADIO_SETUP 0x0802
struct __RFC_STRUCT rfc_CMD_RADIO_SETUP_s {
uint16_t commandNo; //!< The command ID number 0x0802
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 if the rule involves skipping
} condition;
uint8_t mode; //!< \brief The main mode to use<br>
//!< 0x00: BLE<br>
//!< 0x01: IEEE 802.15.4<br>
//!< 0x02: 2 Mbps GFSK<br>
//!< 0x05: 5 Mbps coded 8-FSK<br>
//!< 0x06: ANT<br>
//!< 0xFF: Keep existing mode; update overrides only<br>
//!< Others: <i>Reserved</i>
uint8_t loDivider; //!< \brief LO divider setting to use. Supported values: 0 (equivalent to 2), 2, 5, 6, 10, 12, 15,
//!< and 30.<br>
//!< Value of 0 or 2 only supported for devices that support 2.4 GHz operation
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 :6;
uint16_t bNoFsPowerUp:1; //!< \brief 0: Power up frequency synth<br>
//!< 1: Do not power up frequency synth
} config; //!< Configuration options
struct {
uint16_t IB:6; //!< Value to write to the PA power control field at 25 &deg;C
uint16_t GC:2; //!< Value to write to the gain control of the 1st stage of the PA
uint16_t boost:1; //!< Value of boost bit in synth
uint16_t tempCoeff:7; //!< Temperature coefficient for IB. 0: No temperature compensation
} txPower; //!< Transmit power
uint32_t* pRegOverride; //!< \brief Pointer to a list of hardware and configuration registers to override. If NULL, no
//!< override is used.
};
//! @}
//! \addtogroup CMD_FS
//! @{
#define CMD_FS 0x0803
struct __RFC_STRUCT rfc_CMD_FS_s {
uint16_t commandNo; //!< The command ID number 0x0803
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 if the rule involves skipping
} condition;
uint16_t frequency; //!< The frequency in MHz to tune to
uint16_t fractFreq; //!< Fractional part of the frequency to tune to
struct {
uint8_t bTxMode:1; //!< \brief 0: Start synth in Rx mode<br>
//!< 1: Start synth in Tx mode
uint8_t refFreq:6; //!< \brief 0: Use default reference frequency<br>
//!< Others: Use reference frequency 24 MHz/<code>refFreq</code>
} synthConf;
uint8_t __dummy0;
uint8_t midPrecal; //!< Mid pre-calibration value to use when <code>bOverrideCalib</code> and <code>bSkipCoarseCalib</code> are both 1
uint8_t ktPrecal; //!< KT pre-calibration value to use when <code>bOverrideCalib</code> and <code>bSkipCoarseCalib</code> are both 1
uint16_t tdcPrecal; //!< TDC pre-calibration value to use when <code>bOverrideCalib</code> and <code>bSkipCoarseCalib</code> are both 1
};
//! @}
//! \addtogroup CMD_FS_OFF
//! @{
#define CMD_FS_OFF 0x0804
struct __RFC_STRUCT rfc_CMD_FS_OFF_s {
uint16_t commandNo; //!< The command ID number 0x0804
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 if the rule involves skipping
} condition;
};
//! @}
//! \addtogroup CMD_RX
//! @{
#define CMD_RX 0x0805
struct __RFC_STRUCT rfc_CMD_RX_s {
uint16_t commandNo; //!< The command ID number 0x0805
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 if the rule involves skipping
} condition;
struct {
uint16_t endianness:1; //!< \brief 0: Least significant bit first<br>
//!< 1: Most significant bit first
uint16_t numHdrBits:6; //!< Number of bits in the header
uint16_t bFsOff:1; //!< \brief 0: Keep frequency synth on after command<br>
//!< 1: Turn frequency synth off after command
uint16_t bUseCrc:1; //!< \brief 0: No CRC<br>
//!< 1: The last bytes of the packet are a CRC
uint16_t bCrcIncSw:1; //!< \brief 0: Do not include sync word in CRC calculation<br>
//!< 1: Include sync word in CRC calculation
uint16_t bCrcIncHdr:1; //!< \brief 0: Do not include header in CRC calculation<br>
//!< 1: Include header in CRC calculation
uint16_t bReportCrc:1; //!< \brief 0: Do not write CRC to receive buffer<br>
//!< 1: Write received CRC to receive buffer
uint16_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
uint16_t bDualSw:1; //!< \brief 0: Single sync word<br>
//!< 1: Dual sync word.
} pktConfig;
uint32_t syncWord; //!< Sync word to receive
uint32_t syncWord2; //!< Secondary sync word to receive if <code>pktConfig.bDualSw</code> = 1
struct {
uint16_t numLenBits:4; //!< Number of bits in the length field
uint16_t lenFieldPos:5; //!< Bit position of the first bit in the length field
uint16_t lenOffset:7; //!< Signed number to add to the received length field
} lenConfig;
uint16_t maxLen; //!< Maximum number of bytes in the received packet (including header, excluding CRC)
uint8_t* pRecPkt; //!< Pointer to buffer for received packet. NULL: Do not store the contents.
ratmr_t endTime; //!< Time to end the operation
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
int8_t rssi; //!< RSSI of received packet
uint16_t recLen; //!< Number of bytes written to receive buffer
ratmr_t timeStamp; //!< Time stamp of received packet
uint16_t nRxOk; //!< Counter of number of received packets with CRC OK and first sync word
uint16_t nRxNok; //!< Counter of number of received packets with CRC error and first sync word
uint16_t nRx2Ok; //!< \brief Counter of number of received packets with CRC OK and second sync word; may safely be
//!< omitted if <code>pktConfig.bDualSw</code> is 0
uint16_t nRx2Nok; //!< \brief Counter of number of received packets with CRC error and second sync word; may safely be
//!< omitted if <code>pktConfig.bDualSw</code> is 0
};
//! @}
//! \addtogroup CMD_TX
//! @{
#define CMD_TX 0x0806
struct __RFC_STRUCT rfc_CMD_TX_s {
uint16_t commandNo; //!< The command ID number 0x0806
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 if the rule involves skipping
} condition;
struct {
uint16_t endianness:1; //!< \brief 0: Least significant bit first<br>
//!< 1: Most significant bit first
uint16_t numHdrBits:6; //!< Number of bits in the header
uint16_t bFsOff:1; //!< \brief 0: Keep frequency synth on after command<br>
//!< 1: Turn frequency synth off after command
uint16_t bUseCrc:1; //!< \brief 0: No CRC<br>
//!< 1: Append a CRC to the packet
uint16_t bCrcIncSw:1; //!< \brief 0: Do not include sync word in CRC calculation<br>
//!< 1: Include sync word in CRC calculation
uint16_t bCrcIncHdr:1; //!< \brief 0: Do not include header in CRC calculation<br>
//!< 1: Include header in CRC calculation
} pktConfig;
uint32_t syncWord; //!< Sync word to transmit
uint8_t* pTxPkt; //!< Pointer to buffer for transmitted packet.
uint16_t pktLen; //!< Number of bytes in the transmitted packet
};
//! @}
//! \addtogroup CMD_RX_TEST
//! @{
#define CMD_RX_TEST 0x0807
struct __RFC_STRUCT rfc_CMD_RX_TEST_s {
uint16_t commandNo; //!< The command ID number 0x0807
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 if the rule involves skipping
} condition;
struct {
uint8_t bEnaFifo:1; //!< \brief 0: Do not enable FIFO in modem, so that received data is not available<br>
//!< 1: Enable FIFO in modem &ndash; the data must be read out by the application
uint8_t bFsOff:1; //!< \brief 0: Keep frequency synth on after command<br>
//!< 1: Turn frequency synth off after command
uint8_t bNoSync:1; //!< \brief 0: Run sync search as normal for the configured mode<br>
//!< 1: Write correlation thresholds to the maximum value to avoid getting sync
} config;
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
uint32_t syncWord; //!< Sync word to use for receiver
ratmr_t endTime; //!< Time to end the operation
};
//! @}
//! \addtogroup CMD_TX_TEST
//! @{
#define CMD_TX_TEST 0x0808
struct __RFC_STRUCT rfc_CMD_TX_TEST_s {
uint16_t commandNo; //!< The command ID number 0x0808
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 if the rule involves skipping
} condition;
struct {
uint8_t bUseCw:1; //!< \brief 0: Send modulated signal<br>
//!< 1: Send continuous wave
uint8_t bFsOff:1; //!< \brief 0: Keep frequency synth on after command<br>
//!< 1: Turn frequency synth off after command
uint8_t whitenMode:2; //!< \brief 0: No whitening<br>
//!< 1: Default whitening<br>
//!< 2: PRBS-15<br>
//!< 3: PRBS-32
} config;
uint8_t __dummy0;
uint16_t txWord; //!< Value to send to the modem before whitening
uint8_t __dummy1;
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
uint32_t syncWord; //!< Sync word to use for transmitter
ratmr_t endTime; //!< Time to end the operation
};
//! @}
//! \addtogroup CMD_SYNC_STOP_RAT
//! @{
#define CMD_SYNC_STOP_RAT 0x0809
struct __RFC_STRUCT rfc_CMD_SYNC_STOP_RAT_s {
uint16_t commandNo; //!< The command ID number 0x0809
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 if the rule involves skipping
} condition;
uint16_t __dummy0;
ratmr_t rat0; //!< \brief The returned RAT timer value corresponding to the value the RAT would have had when the
//!< RTC was zero
};
//! @}
//! \addtogroup CMD_SYNC_START_RAT
//! @{
#define CMD_SYNC_START_RAT 0x080A
struct __RFC_STRUCT rfc_CMD_SYNC_START_RAT_s {
uint16_t commandNo; //!< The command ID number 0x080A
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 if the rule involves skipping
} condition;
uint16_t __dummy0;
ratmr_t rat0; //!< \brief The desired RAT timer value corresponding to the value the RAT would have had when the
//!< RTC was zero. This parameter is returned by CMD_SYNC_STOP_RAT
};
//! @}
//! \addtogroup CMD_COUNT
//! @{
#define CMD_COUNT 0x080B
struct __RFC_STRUCT rfc_CMD_COUNT_s {
uint16_t commandNo; //!< The command ID number 0x080B
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 if the rule involves skipping
} condition;
uint16_t counter; //!< \brief Counter. On start, the radio CPU decrements the value, and the end status of the operation
//!< differs if the result is zero
};
//! @}
//! \addtogroup CMD_FS_POWERUP
//! @{
#define CMD_FS_POWERUP 0x080C
struct __RFC_STRUCT rfc_CMD_FS_POWERUP_s {
uint16_t commandNo; //!< The command ID number 0x080C
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 if the rule involves skipping
} condition;
uint16_t __dummy0;
uint32_t* pRegOverride; //!< Pointer to a list of hardware and configuration registers to override. If NULL, no override is used.
};
//! @}
//! \addtogroup CMD_FS_POWERDOWN
//! @{
#define CMD_FS_POWERDOWN 0x080D
struct __RFC_STRUCT rfc_CMD_FS_POWERDOWN_s {
uint16_t commandNo; //!< The command ID number 0x080D
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 if the rule involves skipping
} condition;
};
//! @}
//! \addtogroup CMD_SCH_IMM
//! @{
#define CMD_SCH_IMM 0x0810
struct __RFC_STRUCT rfc_CMD_SCH_IMM_s {
uint16_t commandNo; //!< The command ID number 0x0810
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 if the rule involves skipping
} condition;
uint16_t __dummy0;
uint32_t cmdrVal; //!< Value as would be written to CMDR
uint32_t cmdstaVal; //!< Value as would be returned in CMDSTA
};
//! @}
//! \addtogroup CMD_COUNT_BRANCH
//! @{
#define CMD_COUNT_BRANCH 0x0812
struct __RFC_STRUCT rfc_CMD_COUNT_BRANCH_s {
uint16_t commandNo; //!< The command ID number 0x0812
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 if the rule involves skipping
} condition;
uint16_t counter; //!< \brief Counter. On start, the radio CPU decrements the value, and the end status of the operation
//!< differs if the result is zero
rfc_radioOp_t *pNextOpIfOk; //!< Pointer to next operation if counter did not expire
};
//! @}
//! \addtogroup CMD_PATTERN_CHECK
//! @{
#define CMD_PATTERN_CHECK 0x0813
struct __RFC_STRUCT rfc_CMD_PATTERN_CHECK_s {
uint16_t commandNo; //!< The command ID number 0x0813
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 if the rule involves skipping
} condition;
struct {
uint16_t operation:2; //!< \brief Operation to perform<br>
//!< 0: True if value == <code>compareVal</code><br>
//!< 1: True if value < <code>compareVal</code><br>
//!< 2: True if value > <code>compareVal</code><br>
//!< 3: <i>Reserved</i>
uint16_t bByteRev:1; //!< \brief If 1, interchange the four bytes of the value, so that they are read
//!< most-significant-byte-first.
uint16_t bBitRev:1; //!< If 1, perform bit reversal of the value
uint16_t signExtend:5; //!< \brief 0: Treat value and <code>compareVal</code> as unsigned<br>
//!< 1&ndash;31: Treat value and <code>compareVal</code> as signed, where the value
//!< gives the number of the most significant bit in the signed number.
uint16_t bRxVal:1; //!< \brief 0: Use <code>pValue</code> as a pointer<br>
//!< 1: Use <code>pValue</code> as a signed offset to the start of the last
//!< committed Rx entry element
} patternOpt; //!< Options for comparison
rfc_radioOp_t *pNextOpIfOk; //!< Pointer to next operation if comparison result was true
uint8_t* pValue; //!< Pointer to read from, or offset from last Rx entry if <code>patternOpt.bRxVal</code> == 1
uint32_t mask; //!< Bit mask to apply before comparison
uint32_t compareVal; //!< Value to compare to
};
//! @}
//! \addtogroup CMD_TX_POWER_BOOST
//! @{
#define CMD_TX_POWER_BOOST 0x0816
struct __RFC_STRUCT rfc_CMD_TX_POWER_BOOST_s {
uint16_t commandNo; //!< The command ID number 0x0816
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 if the rule involves skipping
} condition;
uint8_t vddrLevel; //!< \brief VDDR level to set<br>
//!< 0xFD: Trim VDDR voltage to normal level (VDDR_TRIM), nominally 1.68 V<br>
//!< 0xFE: Trim VDDR voltage to high level (VDDR_TRIM_H), nominally 1.85 V<br>
//!< 0xFF: Trim VDDR voltage to higher level (VDDR_TRIM_HH), nominally 1.95 V<br>
//!< Other: reserved
uint8_t paTrimValue; //!< \brief Optional power amplifier trim setting manipulation<br>
//!< 0x00-0x1F: Value to write in ADI_0_RF:PACTL0.TRIM register field<br>
//!< 0xFE: Set PACTL0.TRIM to its default value from FCFG1<br>
//!< 0xFF: Do not write PACTL0.TRIM, use the setting that is already applied<br>
};
//! @}
//! \addtogroup CMD_ABORT
//! @{
#define CMD_ABORT 0x0401
struct __RFC_STRUCT rfc_CMD_ABORT_s {
uint16_t commandNo; //!< The command ID number 0x0401
};
//! @}
//! \addtogroup CMD_STOP
//! @{
#define CMD_STOP 0x0402
struct __RFC_STRUCT rfc_CMD_STOP_s {
uint16_t commandNo; //!< The command ID number 0x0402
};
//! @}
//! \addtogroup CMD_GET_RSSI
//! @{
#define CMD_GET_RSSI 0x0403
struct __RFC_STRUCT rfc_CMD_GET_RSSI_s {
uint16_t commandNo; //!< The command ID number 0x0403
};
//! @}
//! \addtogroup CMD_UPDATE_RADIO_SETUP
//! @{
#define CMD_UPDATE_RADIO_SETUP 0x0001
struct __RFC_STRUCT rfc_CMD_UPDATE_RADIO_SETUP_s {
uint16_t commandNo; //!< The command ID number 0x0001
uint16_t __dummy0;
uint32_t* pRegOverride; //!< Pointer to a list of hardware and configuration registers to override
};
//! @}
//! \addtogroup CMD_TRIGGER
//! @{
#define CMD_TRIGGER 0x0404
struct __RFC_STRUCT rfc_CMD_TRIGGER_s {
uint16_t commandNo; //!< The command ID number 0x0404
uint8_t triggerNo; //!< Command trigger number
};
//! @}
//! \addtogroup CMD_GET_FW_INFO
//! @{
#define CMD_GET_FW_INFO 0x0002
struct __RFC_STRUCT rfc_CMD_GET_FW_INFO_s {
uint16_t commandNo; //!< The command ID number 0x0002
uint16_t versionNo; //!< Firmware version number
uint16_t startOffset; //!< The start of free RAM
uint16_t freeRamSz; //!< The size of free RAM
uint16_t availRatCh; //!< Bitmap of available RAT channels
};
//! @}
//! \addtogroup CMD_START_RAT
//! @{
#define CMD_START_RAT 0x0405
struct __RFC_STRUCT rfc_CMD_START_RAT_s {
uint16_t commandNo; //!< The command ID number 0x0405
};
//! @}
//! \addtogroup CMD_PING
//! @{
#define CMD_PING 0x0406
struct __RFC_STRUCT rfc_CMD_PING_s {
uint16_t commandNo; //!< The command ID number 0x0406
};
//! @}
//! \addtogroup CMD_ADD_DATA_ENTRY
//! @{
#define CMD_ADD_DATA_ENTRY 0x0005
struct __RFC_STRUCT rfc_CMD_ADD_DATA_ENTRY_s {
uint16_t commandNo; //!< The command ID number 0x0005
uint16_t __dummy0;
dataQueue_t* pQueue; //!< Pointer to the queue structure to which the entry will be added
uint8_t* pEntry; //!< Pointer to the entry
};
//! @}
//! \addtogroup CMD_REMOVE_DATA_ENTRY
//! @{
#define CMD_REMOVE_DATA_ENTRY 0x0006
struct __RFC_STRUCT rfc_CMD_REMOVE_DATA_ENTRY_s {
uint16_t commandNo; //!< The command ID number 0x0006
uint16_t __dummy0;
dataQueue_t* pQueue; //!< Pointer to the queue structure from which the entry will be removed
uint8_t* pEntry; //!< Pointer to the entry that was removed
};
//! @}
//! \addtogroup CMD_FLUSH_QUEUE
//! @{
#define CMD_FLUSH_QUEUE 0x0007
struct __RFC_STRUCT rfc_CMD_FLUSH_QUEUE_s {
uint16_t commandNo; //!< The command ID number 0x0007
uint16_t __dummy0;
dataQueue_t* pQueue; //!< Pointer to the queue structure to be flushed
uint8_t* pFirstEntry; //!< Pointer to the first entry that was removed
};
//! @}
//! \addtogroup CMD_CLEAR_RX
//! @{
#define CMD_CLEAR_RX 0x0008
struct __RFC_STRUCT rfc_CMD_CLEAR_RX_s {
uint16_t commandNo; //!< The command ID number 0x0008
uint16_t __dummy0;
dataQueue_t* pQueue; //!< Pointer to the queue structure to be cleared
};
//! @}
//! \addtogroup CMD_REMOVE_PENDING_ENTRIES
//! @{
#define CMD_REMOVE_PENDING_ENTRIES 0x0009
struct __RFC_STRUCT rfc_CMD_REMOVE_PENDING_ENTRIES_s {
uint16_t commandNo; //!< The command ID number 0x0009
uint16_t __dummy0;
dataQueue_t* pQueue; //!< Pointer to the queue structure to be flushed
uint8_t* pFirstEntry; //!< Pointer to the first entry that was removed
};
//! @}
//! \addtogroup CMD_SET_RAT_CMP
//! @{
#define CMD_SET_RAT_CMP 0x000A
struct __RFC_STRUCT rfc_CMD_SET_RAT_CMP_s {
uint16_t commandNo; //!< The command ID number 0x000A
uint8_t ratCh; //!< The radio timer channel number
uint8_t __dummy0;
ratmr_t compareTime; //!< The time at which the compare occurs
};
//! @}
//! \addtogroup CMD_SET_RAT_CPT
//! @{
#define CMD_SET_RAT_CPT 0x0603
struct __RFC_STRUCT rfc_CMD_SET_RAT_CPT_s {
uint16_t commandNo; //!< The command ID number 0x0603
struct {
uint16_t :3;
uint16_t inputSrc:5; //!< Input source indicator
uint16_t ratCh:4; //!< The radio timer channel number
uint16_t bRepeated:1; //!< \brief 0: Single capture mode<br>
//!< 1: Repeated capture mode
uint16_t inputMode:2; //!< \brief Input mode:<br>
//!< 0: Capture on rising edge<br>
//!< 1: Capture on falling edge<br>
//!< 2: Capture on both edges<br>
//!< 3: <i>Reserved</i>
} config;
};
//! @}
//! \addtogroup CMD_DISABLE_RAT_CH
//! @{
#define CMD_DISABLE_RAT_CH 0x0408
struct __RFC_STRUCT rfc_CMD_DISABLE_RAT_CH_s {
uint16_t commandNo; //!< The command ID number 0x0408
uint8_t ratCh; //!< The radio timer channel number
};
//! @}
//! \addtogroup CMD_SET_RAT_OUTPUT
//! @{
#define CMD_SET_RAT_OUTPUT 0x0604
struct __RFC_STRUCT rfc_CMD_SET_RAT_OUTPUT_s {
uint16_t commandNo; //!< The command ID number 0x0604
struct {
uint16_t :2;
uint16_t outputSel:3; //!< Output event indicator
uint16_t outputMode:3; //!< \brief 0: Set output line low as default; and pulse on event. Duration of pulse is one RF Core clock period (ca. 41.67 ns).<br>
//!< 1: Set output line high on event<br>
//!< 2: Set output line low on event<br>
//!< 3: Toggle (invert) output line state on event<br>
//!< 4: Immediately set output line to low (does not change upon event)<br>
//!< 5: Immediately set output line to high (does not change upon event)<br>
//!< Others: <i>Reserved</i>
uint16_t ratCh:4; //!< The radio timer channel number
} config;
};
//! @}
//! \addtogroup CMD_ARM_RAT_CH
//! @{
#define CMD_ARM_RAT_CH 0x0409
struct __RFC_STRUCT rfc_CMD_ARM_RAT_CH_s {
uint16_t commandNo; //!< The command ID number 0x0409
uint8_t ratCh; //!< The radio timer channel number
};
//! @}
//! \addtogroup CMD_DISARM_RAT_CH
//! @{
#define CMD_DISARM_RAT_CH 0x040A
struct __RFC_STRUCT rfc_CMD_DISARM_RAT_CH_s {
uint16_t commandNo; //!< The command ID number 0x040A
uint8_t ratCh; //!< The radio timer channel number
};
//! @}
//! \addtogroup CMD_SET_TX_POWER
//! @{
#define CMD_SET_TX_POWER 0x0010
struct __RFC_STRUCT rfc_CMD_SET_TX_POWER_s {
uint16_t commandNo; //!< The command ID number 0x0010
struct {
uint16_t IB:6; //!< Value to write to the PA power control field at 25 &deg;C
uint16_t GC:2; //!< Value to write to the gain control of the 1st stage of the PA
uint16_t boost:1; //!< Value of boost bit in synth
uint16_t tempCoeff:7; //!< Temperature coefficient for IB. 0: No temperature compensation
} txPower; //!< New Tx power setting
};
//! @}
//! \addtogroup CMD_UPDATE_FS
//! @{
#define CMD_UPDATE_FS 0x0011
struct __RFC_STRUCT rfc_CMD_UPDATE_FS_s {
uint16_t commandNo; //!< The command ID number 0x0011
uint16_t frequency; //!< The frequency in MHz to tune to
uint16_t fractFreq; //!< Fractional part of the frequency to tune to
};
//! @}
//! \addtogroup CMD_BUS_REQUEST
//! @{
#define CMD_BUS_REQUEST 0x040E
struct __RFC_STRUCT rfc_CMD_BUS_REQUEST_s {
uint16_t commandNo; //!< The command ID number 0x040E
uint8_t bSysBusNeeded; //!< \brief 0: System bus may sleep<br>
//!< 1: System bus access needed
};
//! @}
//! @}
//! @}
#endif /* COMMON_CMD_H_ */