mirror of
https://github.com/oliverschmidt/contiki.git
synced 2024-11-03 22:06:22 +00:00
01e36532c2
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
612 lines
41 KiB
C
612 lines
41 KiB
C
/******************************************************************************
|
|
* Filename: ieee_cmd.h
|
|
* Revised: $ $
|
|
* Revision: $ $
|
|
*
|
|
* Description: CC26xx/CC13xx API for IEEE 802.15.4 commands
|
|
*
|
|
* Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
|
|
*
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 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.
|
|
*
|
|
* Neither the name of Texas Instruments Incorporated 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
|
|
* OWNER 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 IEEE_CMD_H_
|
|
#define IEEE_CMD_H_
|
|
|
|
#ifndef __RFC_STRUCT
|
|
#ifdef __GNUC__
|
|
#define __RFC_STRUCT __attribute__ ((aligned (4)))
|
|
#else
|
|
#define __RFC_STRUCT
|
|
#endif
|
|
#endif
|
|
|
|
//! \addtogroup rfc
|
|
//! @{
|
|
|
|
//! \addtogroup ieee_cmd
|
|
//! @{
|
|
|
|
#include <stdint.h>
|
|
#include "mailbox.h"
|
|
#include "common_cmd.h"
|
|
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_RX_s rfc_CMD_IEEE_RX_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_ED_SCAN_s rfc_CMD_IEEE_ED_SCAN_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_TX_s rfc_CMD_IEEE_TX_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_CSMA_s rfc_CMD_IEEE_CSMA_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_RX_ACK_s rfc_CMD_IEEE_RX_ACK_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_ABORT_BG_s rfc_CMD_IEEE_ABORT_BG_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_MOD_CCA_s rfc_CMD_IEEE_MOD_CCA_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_MOD_FILT_s rfc_CMD_IEEE_MOD_FILT_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_MOD_SRC_MATCH_s rfc_CMD_IEEE_MOD_SRC_MATCH_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_ABORT_FG_s rfc_CMD_IEEE_ABORT_FG_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_STOP_FG_s rfc_CMD_IEEE_STOP_FG_t;
|
|
typedef struct __RFC_STRUCT rfc_CMD_IEEE_CCA_REQ_s rfc_CMD_IEEE_CCA_REQ_t;
|
|
typedef struct __RFC_STRUCT rfc_ieeeRxOutput_s rfc_ieeeRxOutput_t;
|
|
typedef struct __RFC_STRUCT rfc_shortAddrEntry_s rfc_shortAddrEntry_t;
|
|
typedef struct __RFC_STRUCT rfc_ieeeRxCorrCrc_s rfc_ieeeRxCorrCrc_t;
|
|
|
|
//! \addtogroup CMD_IEEE_RX
|
|
//! @{
|
|
#define CMD_IEEE_RX 0x2801
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_RX_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2801
|
|
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 channel; //!< \brief Channel to tune to in the start of the operation<br>
|
|
//!< 0: Use existing channel<br>
|
|
//!< 11–26: Use as IEEE 802.15.4 channel, i.e. frequency is (2405 + 5 × (channel - 11)) MHz<br>
|
|
//!< 60–207: Frequency is (2300 + channel) MHz<br>
|
|
//!< Others: <i>Reserved</i>
|
|
struct {
|
|
uint8_t bAutoFlushCrc:1; //!< If 1, automatically remove packets with CRC error from Rx queue
|
|
uint8_t bAutoFlushIgn:1; //!< If 1, automatically remove packets that can be ignored according to frame filtering from Rx queue
|
|
uint8_t bIncludePhyHdr:1; //!< If 1, include the received PHY header field 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 bAppendCorrCrc:1; //!< If 1, append a correlation value and CRC result byte to the packet in the Rx queue
|
|
uint8_t bAppendSrcInd:1; //!< If 1, append an index from the source matching algorithm
|
|
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
|
|
} rxConfig;
|
|
dataQueue_t* pRxQ; //!< Pointer to receive queue
|
|
rfc_ieeeRxOutput_t *pOutput; //!< Pointer to output structure (NULL: Do not store results)
|
|
struct {
|
|
uint16_t frameFiltEn:1; //!< \brief 0: Disable frame filtering<br>
|
|
//!< 1: Enable frame filtering
|
|
uint16_t frameFiltStop:1; //!< \brief 0: Receive all packets to the end<br>
|
|
//!< 1: Stop receiving frame once frame filtering has caused the frame to be rejected.
|
|
uint16_t autoAckEn:1; //!< \brief 0: Disable auto ACK<br>
|
|
//!< 1: Enable auto ACK.
|
|
uint16_t slottedAckEn:1; //!< \brief 0: Non-slotted ACK<br>
|
|
//!< 1: Slotted ACK.
|
|
uint16_t autoPendEn:1; //!< \brief 0: Auto-pend disabled<br>
|
|
//!< 1: Auto-pend enabled
|
|
uint16_t defaultPend:1; //!< The value of the pending data bit in auto ACK packets that are not subject to auto-pend
|
|
uint16_t bPendDataReqOnly:1; //!< \brief 0: Use auto-pend for any packet<br>
|
|
//!< 1: Use auto-pend for data request packets only
|
|
uint16_t bPanCoord:1; //!< \brief 0: Device is not PAN coordinator<br>
|
|
//!< 1: Device is PAN coordinator
|
|
uint16_t maxFrameVersion:2; //!< Reject frames where the frame version field in the FCF is greater than this value
|
|
uint16_t fcfReservedMask:3; //!< Value to be AND-ed with the reserved part of the FCF; frame rejected if result is non-zero
|
|
uint16_t modifyFtFilter:2; //!< \brief Treatment of MSB of frame type field before frame-type filtering:<br>
|
|
//!< 0: No modification<br>
|
|
//!< 1: Invert MSB<br>
|
|
//!< 2: Set MSB to 0<br>
|
|
//!< 3: Set MSB to 1
|
|
uint16_t bStrictLenFilter:1; //!< \brief 0: Accept acknowledgement frames of any length >= 5<br>
|
|
//!< 1: Accept only acknowledgement frames of length 5
|
|
} frameFiltOpt; //!< Frame filtering options
|
|
struct {
|
|
uint8_t bAcceptFt0Beacon:1; //!< \brief Treatment of frames with frame type 000 (beacon):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt1Data:1; //!< \brief Treatment of frames with frame type 001 (data):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt2Ack:1; //!< \brief Treatment of frames with frame type 010 (ACK):<br>
|
|
//!< 0: Reject, unless running ACK receive command<br>
|
|
//!< 1: Always accept
|
|
uint8_t bAcceptFt3MacCmd:1; //!< \brief Treatment of frames with frame type 011 (MAC command):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt4Reserved:1; //!< \brief Treatment of frames with frame type 100 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt5Reserved:1; //!< \brief Treatment of frames with frame type 101 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt6Reserved:1; //!< \brief Treatment of frames with frame type 110 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt7Reserved:1; //!< \brief Treatment of frames with frame type 111 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
} frameTypes; //!< Frame types to receive in frame filtering
|
|
struct {
|
|
uint8_t ccaEnEnergy:1; //!< Enable energy scan as CCA source
|
|
uint8_t ccaEnCorr:1; //!< Enable correlator based carrier sense as CCA source
|
|
uint8_t ccaEnSync:1; //!< Enable sync found based carrier sense as CCA source
|
|
uint8_t ccaCorrOp:1; //!< \brief Operator to use between energy based and correlator based CCA<br>
|
|
//!< 0: Report busy channel if either ccaEnergy or ccaCorr are busy<br>
|
|
//!< 1: Report busy channel if both ccaEnergy and ccaCorr are busy
|
|
uint8_t ccaSyncOp:1; //!< \brief Operator to use between sync found based CCA and the others<br>
|
|
//!< 0: Always report busy channel if ccaSync is busy<br>
|
|
//!< 1: Always report idle channel if ccaSync is idle
|
|
uint8_t ccaCorrThr:2; //!< Threshold for number of correlation peaks in correlator based carrier sense
|
|
} ccaOpt; //!< CCA options
|
|
int8_t ccaRssiThr; //!< RSSI threshold for CCA
|
|
uint8_t __dummy0;
|
|
uint8_t numExtEntries; //!< Number of extended address entries
|
|
uint8_t numShortEntries; //!< Number of short address entries
|
|
uint32_t* pExtEntryList; //!< Pointer to list of extended address entries
|
|
rfc_shortAddrEntry_t *pShortEntryList;//!< Pointer to list of short address entries
|
|
uint64_t localExtAddr; //!< The extended address of the local device
|
|
uint16_t localShortAddr; //!< The short address of the local device
|
|
uint16_t localPanID; //!< The PAN ID of the local device
|
|
uint16_t __dummy1;
|
|
uint8_t __dummy2;
|
|
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 that causes the device to end the Rx operation
|
|
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the Rx
|
|
//!< operation
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_ED_SCAN
|
|
//! @{
|
|
#define CMD_IEEE_ED_SCAN 0x2802
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_ED_SCAN_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2802
|
|
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 channel; //!< \brief Channel to tune to in the start of the operation<br>
|
|
//!< 0: Use existing channel<br>
|
|
//!< 11–26: Use as IEEE 802.15.4 channel, i.e. frequency is (2405 + 5 × (channel - 11)) MHz<br>
|
|
//!< 60–207: Frequency is (2300 + channel) MHz<br>
|
|
//!< Others: <i>Reserved</i>
|
|
struct {
|
|
uint8_t ccaEnEnergy:1; //!< Enable energy scan as CCA source
|
|
uint8_t ccaEnCorr:1; //!< Enable correlator based carrier sense as CCA source
|
|
uint8_t ccaEnSync:1; //!< Enable sync found based carrier sense as CCA source
|
|
uint8_t ccaCorrOp:1; //!< \brief Operator to use between energy based and correlator based CCA<br>
|
|
//!< 0: Report busy channel if either ccaEnergy or ccaCorr are busy<br>
|
|
//!< 1: Report busy channel if both ccaEnergy and ccaCorr are busy
|
|
uint8_t ccaSyncOp:1; //!< \brief Operator to use between sync found based CCA and the others<br>
|
|
//!< 0: Always report busy channel if ccaSync is busy<br>
|
|
//!< 1: Always report idle channel if ccaSync is idle
|
|
uint8_t ccaCorrThr:2; //!< Threshold for number of correlation peaks in correlator based carrier sense
|
|
} ccaOpt; //!< CCA options
|
|
int8_t ccaRssiThr; //!< RSSI threshold for CCA
|
|
uint8_t __dummy0;
|
|
int8_t maxRssi; //!< The maximum RSSI recorded during the ED scan
|
|
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 that causes the device to end the Rx operation
|
|
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the Rx
|
|
//!< operation
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_TX
|
|
//! @{
|
|
#define CMD_IEEE_TX 0x2C01
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_TX_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2C01
|
|
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 bIncludePhyHdr:1; //!< \brief 0: Find PHY header automatically<br>
|
|
//!< 1: Insert PHY header from the buffer
|
|
uint8_t bIncludeCrc:1; //!< \brief 0: Append automatically calculated CRC<br>
|
|
//!< 1: Insert FCS (CRC) from the buffer
|
|
uint8_t :1;
|
|
uint8_t payloadLenMsb:5; //!< \brief Most significant bits of payload length. Should only be non-zero to create long
|
|
//!< non-standard packets for test purposes
|
|
} txOpt;
|
|
uint8_t payloadLen; //!< Number of bytes in the payload
|
|
uint8_t* pPayload; //!< Pointer to payload buffer of size <code>payloadLen</code>
|
|
ratmr_t timeStamp; //!< Time stamp of transmitted frame
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_CSMA
|
|
//! @{
|
|
#define CMD_IEEE_CSMA 0x2C02
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_CSMA_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2C02
|
|
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 randomState; //!< The state of the pseudo-random generator
|
|
uint8_t macMaxBE; //!< The IEEE 802.15.4 MAC parameter <i>macMaxBE</i>
|
|
uint8_t macMaxCSMABackoffs; //!< The IEEE 802.15.4 MAC parameter <i>macMaxCSMABackoffs</i>
|
|
struct {
|
|
uint8_t initCW:5; //!< The initialization value for the CW parameter
|
|
uint8_t bSlotted:1; //!< \brief 0: non-slotted CSMA<br>
|
|
//!< 1: slotted CSMA
|
|
uint8_t rxOffMode:2; //!< \brief 0: RX stays on during CSMA backoffs<br>
|
|
//!< 1: The CSMA-CA algorithm will suspend the receiver if no frame is being received<br>
|
|
//!< 2: The CSMA-CA algorithm will suspend the receiver if no frame is being received,
|
|
//!< or after finishing it (including auto ACK) otherwise<br>
|
|
//!< 3: The CSMA-CA algorithm will suspend the receiver immediately during back-offs
|
|
} csmaConfig;
|
|
uint8_t NB; //!< The NB parameter from the IEEE 802.15.4 CSMA-CA algorithm
|
|
uint8_t BE; //!< The BE parameter from the IEEE 802.15.4 CSMA-CA algorithm
|
|
uint8_t remainingPeriods; //!< The number of remaining periods from a paused backoff countdown
|
|
int8_t lastRssi; //!< RSSI measured at the last CCA 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 that causes the device to end the CSMA-CA operation
|
|
ratmr_t lastTimeStamp; //!< Time of the last CCA operation
|
|
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the
|
|
//!< CSMA-CA operation
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_RX_ACK
|
|
//! @{
|
|
#define CMD_IEEE_RX_ACK 0x2C03
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_RX_ACK_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2C03
|
|
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 seqNo; //!< Sequence number to expect
|
|
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 that causes the device to give up acknowledgement reception
|
|
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to give up
|
|
//!< acknowledgement reception
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_ABORT_BG
|
|
//! @{
|
|
#define CMD_IEEE_ABORT_BG 0x2C04
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_ABORT_BG_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2C04
|
|
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_IEEE_MOD_CCA
|
|
//! @{
|
|
#define CMD_IEEE_MOD_CCA 0x2001
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_MOD_CCA_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2001
|
|
struct {
|
|
uint8_t ccaEnEnergy:1; //!< Enable energy scan as CCA source
|
|
uint8_t ccaEnCorr:1; //!< Enable correlator based carrier sense as CCA source
|
|
uint8_t ccaEnSync:1; //!< Enable sync found based carrier sense as CCA source
|
|
uint8_t ccaCorrOp:1; //!< \brief Operator to use between energy based and correlator based CCA<br>
|
|
//!< 0: Report busy channel if either ccaEnergy or ccaCorr are busy<br>
|
|
//!< 1: Report busy channel if both ccaEnergy and ccaCorr are busy
|
|
uint8_t ccaSyncOp:1; //!< \brief Operator to use between sync found based CCA and the others<br>
|
|
//!< 0: Always report busy channel if ccaSync is busy<br>
|
|
//!< 1: Always report idle channel if ccaSync is idle
|
|
uint8_t ccaCorrThr:2; //!< Threshold for number of correlation peaks in correlator based carrier sense
|
|
} newCcaOpt; //!< New value of <code>ccaOpt</code> for the running background level operation
|
|
int8_t newCcaRssiThr; //!< New value of <code>ccaRssiThr</code> for the running background level operation
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_MOD_FILT
|
|
//! @{
|
|
#define CMD_IEEE_MOD_FILT 0x2002
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_MOD_FILT_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2002
|
|
struct {
|
|
uint16_t frameFiltEn:1; //!< \brief 0: Disable frame filtering<br>
|
|
//!< 1: Enable frame filtering
|
|
uint16_t frameFiltStop:1; //!< \brief 0: Receive all packets to the end<br>
|
|
//!< 1: Stop receiving frame once frame filtering has caused the frame to be rejected.
|
|
uint16_t autoAckEn:1; //!< \brief 0: Disable auto ACK<br>
|
|
//!< 1: Enable auto ACK.
|
|
uint16_t slottedAckEn:1; //!< \brief 0: Non-slotted ACK<br>
|
|
//!< 1: Slotted ACK.
|
|
uint16_t autoPendEn:1; //!< \brief 0: Auto-pend disabled<br>
|
|
//!< 1: Auto-pend enabled
|
|
uint16_t defaultPend:1; //!< The value of the pending data bit in auto ACK packets that are not subject to auto-pend
|
|
uint16_t bPendDataReqOnly:1; //!< \brief 0: Use auto-pend for any packet<br>
|
|
//!< 1: Use auto-pend for data request packets only
|
|
uint16_t bPanCoord:1; //!< \brief 0: Device is not PAN coordinator<br>
|
|
//!< 1: Device is PAN coordinator
|
|
uint16_t maxFrameVersion:2; //!< Reject frames where the frame version field in the FCF is greater than this value
|
|
uint16_t fcfReservedMask:3; //!< Value to be AND-ed with the reserved part of the FCF; frame rejected if result is non-zero
|
|
uint16_t modifyFtFilter:2; //!< \brief Treatment of MSB of frame type field before frame-type filtering:<br>
|
|
//!< 0: No modification<br>
|
|
//!< 1: Invert MSB<br>
|
|
//!< 2: Set MSB to 0<br>
|
|
//!< 3: Set MSB to 1
|
|
uint16_t bStrictLenFilter:1; //!< \brief 0: Accept acknowledgement frames of any length >= 5<br>
|
|
//!< 1: Accept only acknowledgement frames of length 5
|
|
} newFrameFiltOpt; //!< New value of <code>frameFiltOpt</code> for the running background level operation
|
|
struct {
|
|
uint8_t bAcceptFt0Beacon:1; //!< \brief Treatment of frames with frame type 000 (beacon):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt1Data:1; //!< \brief Treatment of frames with frame type 001 (data):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt2Ack:1; //!< \brief Treatment of frames with frame type 010 (ACK):<br>
|
|
//!< 0: Reject, unless running ACK receive command<br>
|
|
//!< 1: Always accept
|
|
uint8_t bAcceptFt3MacCmd:1; //!< \brief Treatment of frames with frame type 011 (MAC command):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt4Reserved:1; //!< \brief Treatment of frames with frame type 100 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt5Reserved:1; //!< \brief Treatment of frames with frame type 101 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt6Reserved:1; //!< \brief Treatment of frames with frame type 110 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
uint8_t bAcceptFt7Reserved:1; //!< \brief Treatment of frames with frame type 111 (reserved):<br>
|
|
//!< 0: Reject<br>
|
|
//!< 1: Accept
|
|
} newFrameTypes; //!< New value of <code>frameTypes</code> for the running background level operation
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_MOD_SRC_MATCH
|
|
//! @{
|
|
#define CMD_IEEE_MOD_SRC_MATCH 0x2003
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_MOD_SRC_MATCH_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2003
|
|
struct {
|
|
uint8_t bEnable:1; //!< \brief 0: Disable entry<br>
|
|
//!< 1: Enable entry
|
|
uint8_t srcPend:1; //!< New value of the pending bit for the entry
|
|
uint8_t entryType:1; //!< \brief 0: Extended address<br>
|
|
//!< 1: Short address
|
|
} options;
|
|
uint8_t entryNo; //!< Index of entry to enable or disable
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_ABORT_FG
|
|
//! @{
|
|
#define CMD_IEEE_ABORT_FG 0x2401
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_ABORT_FG_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2401
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_STOP_FG
|
|
//! @{
|
|
#define CMD_IEEE_STOP_FG 0x2402
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_STOP_FG_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2402
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup CMD_IEEE_CCA_REQ
|
|
//! @{
|
|
#define CMD_IEEE_CCA_REQ 0x2403
|
|
struct __RFC_STRUCT rfc_CMD_IEEE_CCA_REQ_s {
|
|
uint16_t commandNo; //!< The command ID number 0x2403
|
|
int8_t currentRssi; //!< The RSSI currently observed on the channel
|
|
int8_t maxRssi; //!< The maximum RSSI observed on the channel since Rx was started
|
|
struct {
|
|
uint8_t ccaState:2; //!< \brief Value of the current CCA state<br>
|
|
//!< 0: Idle<br>
|
|
//!< 1: Busy<br>
|
|
//!< 2: Invalid
|
|
uint8_t ccaEnergy:2; //!< \brief Value of the current energy detect CCA state<br>
|
|
//!< 0: Idle<br>
|
|
//!< 1: Busy<br>
|
|
//!< 2: Invalid
|
|
uint8_t ccaCorr:2; //!< \brief Value of the current correlator based carrier sense CCA state<br>
|
|
//!< 0: Idle<br>
|
|
//!< 1: Busy<br>
|
|
//!< 2: Invalid
|
|
uint8_t ccaSync:1; //!< \brief Value of the current sync found based carrier sense CCA state<br>
|
|
//!< 0: Idle<br>
|
|
//!< 1: Busy
|
|
} ccaInfo;
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup ieeeRxOutput
|
|
//! @{
|
|
//! Output structure for CMD_IEEE_RX
|
|
|
|
struct __RFC_STRUCT rfc_ieeeRxOutput_s {
|
|
uint8_t nTxAck; //!< Total number of transmitted ACK frames
|
|
uint8_t nRxBeacon; //!< Number of received beacon frames
|
|
uint8_t nRxData; //!< Number of received data frames
|
|
uint8_t nRxAck; //!< Number of received acknowledgement frames
|
|
uint8_t nRxMacCmd; //!< Number of received MAC command frames
|
|
uint8_t nRxReserved; //!< Number of received frames with reserved frame type
|
|
uint8_t nRxNok; //!< Number of received frames with CRC error
|
|
uint8_t nRxIgnored; //!< Number of frames received that are to be ignored
|
|
uint8_t nRxBufFull; //!< Number of received frames discarded because the Rx buffer was full
|
|
int8_t lastRssi; //!< RSSI of last received frame
|
|
int8_t maxRssi; //!< Highest RSSI observed in the operation
|
|
uint8_t __dummy0;
|
|
ratmr_t beaconTimeStamp; //!< Time stamp of last received beacon frame
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup shortAddrEntry
|
|
//! @{
|
|
//! Structure for short address entries
|
|
|
|
struct __RFC_STRUCT rfc_shortAddrEntry_s {
|
|
uint16_t shortAddr; //!< Short address
|
|
uint16_t panId; //!< PAN ID
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! \addtogroup ieeeRxCorrCrc
|
|
//! @{
|
|
//! Receive status byte that may be appended to message in receive buffer
|
|
|
|
struct __RFC_STRUCT rfc_ieeeRxCorrCrc_s {
|
|
struct {
|
|
uint8_t corr:6; //!< The correlation value
|
|
uint8_t bIgnore:1; //!< 1 if the packet should be rejected by frame filtering, 0 otherwise
|
|
uint8_t bCrcErr:1; //!< 1 if the packet was received with CRC error, 0 otherwise
|
|
} status;
|
|
};
|
|
|
|
//! @}
|
|
|
|
//! @}
|
|
//! @}
|
|
#endif /* IEEE_CMD_H_ */
|