deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
osd-contiki/cpu/cc26xx-cc13xx/rf-core/api/ble_cmd.h

1082 lines
76 KiB
C
Raw Permalink Normal View History

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-16 17:30:04 +02:00
/******************************************************************************
* Filename: ble_cmd.h
* Revised: $ $
* Revision: $ $
*
* Description: CC26xx/CC13xx API for Bluetooth Low Energy 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 BLE_CMD_H_
#define BLE_CMD_H_
#ifndef __RFC_STRUCT
#ifdef __GNUC__
#define __RFC_STRUCT __attribute__ ((aligned (4)))
#else
#define __RFC_STRUCT
#endif
#endif
//! \addtogroup rfc
//! @{
//! \addtogroup ble_cmd
//! @{
#include <stdint.h>
#include "mailbox.h"
#include "common_cmd.h"
typedef struct __RFC_STRUCT rfc_bleRadioOp_s rfc_bleRadioOp_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_SLAVE_s rfc_CMD_BLE_SLAVE_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_MASTER_s rfc_CMD_BLE_MASTER_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_ADV_s rfc_CMD_BLE_ADV_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_ADV_DIR_s rfc_CMD_BLE_ADV_DIR_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_ADV_NC_s rfc_CMD_BLE_ADV_NC_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_ADV_SCAN_s rfc_CMD_BLE_ADV_SCAN_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_SCANNER_s rfc_CMD_BLE_SCANNER_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_INITIATOR_s rfc_CMD_BLE_INITIATOR_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_GENERIC_RX_s rfc_CMD_BLE_GENERIC_RX_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_TX_TEST_s rfc_CMD_BLE_TX_TEST_t;
typedef struct __RFC_STRUCT rfc_CMD_BLE_ADV_PAYLOAD_s rfc_CMD_BLE_ADV_PAYLOAD_t;
typedef struct __RFC_STRUCT rfc_bleMasterSlavePar_s rfc_bleMasterSlavePar_t;
typedef struct __RFC_STRUCT rfc_bleMasterPar_s rfc_bleMasterPar_t;
typedef struct __RFC_STRUCT rfc_bleSlavePar_s rfc_bleSlavePar_t;
typedef struct __RFC_STRUCT rfc_bleAdvPar_s rfc_bleAdvPar_t;
typedef struct __RFC_STRUCT rfc_bleScannerPar_s rfc_bleScannerPar_t;
typedef struct __RFC_STRUCT rfc_bleInitiatorPar_s rfc_bleInitiatorPar_t;
typedef struct __RFC_STRUCT rfc_bleGenericRxPar_s rfc_bleGenericRxPar_t;
typedef struct __RFC_STRUCT rfc_bleTxTestPar_s rfc_bleTxTestPar_t;
typedef struct __RFC_STRUCT rfc_bleMasterSlaveOutput_s rfc_bleMasterSlaveOutput_t;
typedef struct __RFC_STRUCT rfc_bleAdvOutput_s rfc_bleAdvOutput_t;
typedef struct __RFC_STRUCT rfc_bleScannerOutput_s rfc_bleScannerOutput_t;
typedef struct __RFC_STRUCT rfc_bleInitiatorOutput_s rfc_bleInitiatorOutput_t;
typedef struct __RFC_STRUCT rfc_bleGenericRxOutput_s rfc_bleGenericRxOutput_t;
typedef struct __RFC_STRUCT rfc_bleTxTestOutput_s rfc_bleTxTestOutput_t;
typedef struct __RFC_STRUCT rfc_bleWhiteListEntry_s rfc_bleWhiteListEntry_t;
typedef struct __RFC_STRUCT rfc_bleRxStatus_s rfc_bleRxStatus_t;
//! \addtogroup bleRadioOp
//! @{
struct __RFC_STRUCT rfc_bleRadioOp_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;
uint8_t channel; //!< \brief Channel to use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
uint8_t* pParams; //!< Pointer to command specific parameter structure
uint8_t* pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_SLAVE
//! @{
#define CMD_BLE_SLAVE 0x1801
struct __RFC_STRUCT rfc_CMD_BLE_SLAVE_s {
uint16_t commandNo; //!< The command ID number 0x1801
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleSlavePar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleMasterSlaveOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_MASTER
//! @{
#define CMD_BLE_MASTER 0x1802
struct __RFC_STRUCT rfc_CMD_BLE_MASTER_s {
uint16_t commandNo; //!< The command ID number 0x1802
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleMasterPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleMasterSlaveOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_ADV
//! @{
#define CMD_BLE_ADV 0x1803
struct __RFC_STRUCT rfc_CMD_BLE_ADV_s {
uint16_t commandNo; //!< The command ID number 0x1803
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleAdvPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleAdvOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_ADV_DIR
//! @{
#define CMD_BLE_ADV_DIR 0x1804
struct __RFC_STRUCT rfc_CMD_BLE_ADV_DIR_s {
uint16_t commandNo; //!< The command ID number 0x1804
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleAdvPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleAdvOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_ADV_NC
//! @{
#define CMD_BLE_ADV_NC 0x1805
struct __RFC_STRUCT rfc_CMD_BLE_ADV_NC_s {
uint16_t commandNo; //!< The command ID number 0x1805
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleAdvPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleAdvOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_ADV_SCAN
//! @{
#define CMD_BLE_ADV_SCAN 0x1806
struct __RFC_STRUCT rfc_CMD_BLE_ADV_SCAN_s {
uint16_t commandNo; //!< The command ID number 0x1806
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleAdvPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleAdvOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_SCANNER
//! @{
#define CMD_BLE_SCANNER 0x1807
struct __RFC_STRUCT rfc_CMD_BLE_SCANNER_s {
uint16_t commandNo; //!< The command ID number 0x1807
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleScannerPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleScannerOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_INITIATOR
//! @{
#define CMD_BLE_INITIATOR 0x1808
struct __RFC_STRUCT rfc_CMD_BLE_INITIATOR_s {
uint16_t commandNo; //!< The command ID number 0x1808
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleInitiatorPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleInitiatorOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_GENERIC_RX
//! @{
#define CMD_BLE_GENERIC_RX 0x1809
struct __RFC_STRUCT rfc_CMD_BLE_GENERIC_RX_s {
uint16_t commandNo; //!< The command ID number 0x1809
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleGenericRxPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleGenericRxOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_TX_TEST
//! @{
#define CMD_BLE_TX_TEST 0x180A
struct __RFC_STRUCT rfc_CMD_BLE_TX_TEST_s {
uint16_t commandNo; //!< The command ID number 0x180A
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 use<br>
//!< 0&ndash;39: BLE advertising/data channel number
//!< 60&ndash;207: Custom frequency; (2300 + <code>channel</code>) MHz
//!< 255: Use existing frequency
//!< Others: <i>Reserved<i>
struct {
uint8_t init:7; //!< \brief If <code>bOverride</code> = 1 or custom frequency is used:<br>
//!< 0: Do not use whitening<br>
//!< Other value: Initialization for 7-bit LFSR whitener
uint8_t bOverride:1; //!< \brief 0: Use default whitening for BLE advertising/data channels<br>
//!< 1: Override whitening initialization with value of init
} whitening;
rfc_bleTxTestPar_t *pParams; //!< Pointer to command specific parameter structure
rfc_bleTxTestOutput_t *pOutput; //!< Pointer to command specific output structure
};
//! @}
//! \addtogroup CMD_BLE_ADV_PAYLOAD
//! @{
#define CMD_BLE_ADV_PAYLOAD 0x1001
struct __RFC_STRUCT rfc_CMD_BLE_ADV_PAYLOAD_s {
uint16_t commandNo; //!< The command ID number 0x1001
uint8_t payloadType; //!< \brief 0: Advertising data<br>
//!< 1: Scan response data
uint8_t newLen; //!< Length of the new payload
uint8_t* pNewData; //!< Pointer to the buffer containing the new data
rfc_bleAdvPar_t *pParams; //!< Pointer to the parameter structure to update
};
//! @}
//! \addtogroup bleMasterSlavePar
//! @{
struct __RFC_STRUCT rfc_bleMasterSlavePar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue
dataQueue_t* pTxQ; //!< Pointer to transmit queue
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
struct {
uint8_t lastRxSn:1; //!< The SN bit of the header of the last packet received with CRC OK
uint8_t lastTxSn:1; //!< The SN bit of the header of the last transmitted packet
uint8_t nextTxSn:1; //!< The SN bit of the header of the next packet to transmit
uint8_t bFirstPkt:1; //!< For slave: 0 if a packet has been transmitted on the connection, 1 otherwise
uint8_t bAutoEmpty:1; //!< 1 if the last transmitted packet was an auto-empty packet
uint8_t bLlCtrlTx:1; //!< 1 if the last transmitted packet was an LL control packet (LLID = 11)
uint8_t bLlCtrlAckRx:1; //!< 1 if the last received packet was the ACK of an LL control packet
uint8_t bLlCtrlAckPending:1; //!< 1 if the last successfully received packet was an LL control packet which has not yet been ACK'ed
} seqStat;
uint8_t maxNack; //!< Maximum number of NACKs received before operation ends. 0: No limit
uint8_t maxPkt; //!< Maximum number of packets transmitted in the operation before it ends. 0: No limit
uint32_t accessAddress; //!< Access address used on the connection
uint8_t crcInit0; //!< CRC initialization value used on the connection &ndash; least significant byte
uint8_t crcInit1; //!< CRC initialization value used on the connection &ndash; middle byte
uint8_t crcInit2; //!< CRC initialization value used on the connection &ndash; most significant byte
};
//! @}
//! \addtogroup bleMasterPar
//! @{
//! Parameter structure for master (CMD_BLE_MASTER)
struct __RFC_STRUCT rfc_bleMasterPar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue
dataQueue_t* pTxQ; //!< Pointer to transmit queue
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
struct {
uint8_t lastRxSn:1; //!< The SN bit of the header of the last packet received with CRC OK
uint8_t lastTxSn:1; //!< The SN bit of the header of the last transmitted packet
uint8_t nextTxSn:1; //!< The SN bit of the header of the next packet to transmit
uint8_t bFirstPkt:1; //!< For slave: 0 if a packet has been transmitted on the connection, 1 otherwise
uint8_t bAutoEmpty:1; //!< 1 if the last transmitted packet was an auto-empty packet
uint8_t bLlCtrlTx:1; //!< 1 if the last transmitted packet was an LL control packet (LLID = 11)
uint8_t bLlCtrlAckRx:1; //!< 1 if the last received packet was the ACK of an LL control packet
uint8_t bLlCtrlAckPending:1; //!< 1 if the last successfully received packet was an LL control packet which has not yet been ACK'ed
} seqStat;
uint8_t maxNack; //!< Maximum number of NACKs received before operation ends. 0: No limit
uint8_t maxPkt; //!< Maximum number of packets transmitted in the operation before it ends. 0: No limit
uint32_t accessAddress; //!< Access address used on the connection
uint8_t crcInit0; //!< CRC initialization value used on the connection &ndash; least significant byte
uint8_t crcInit1; //!< CRC initialization value used on the connection &ndash; middle byte
uint8_t crcInit2; //!< CRC initialization value used on the connection &ndash; most significant byte
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 connection event as soon as allowed
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the
//!< connection event as soon as allowed
};
//! @}
//! \addtogroup bleSlavePar
//! @{
//! Parameter structure for slave (CMD_BLE_SLAVE)
struct __RFC_STRUCT rfc_bleSlavePar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue
dataQueue_t* pTxQ; //!< Pointer to transmit queue
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
struct {
uint8_t lastRxSn:1; //!< The SN bit of the header of the last packet received with CRC OK
uint8_t lastTxSn:1; //!< The SN bit of the header of the last transmitted packet
uint8_t nextTxSn:1; //!< The SN bit of the header of the next packet to transmit
uint8_t bFirstPkt:1; //!< For slave: 0 if a packet has been transmitted on the connection, 1 otherwise
uint8_t bAutoEmpty:1; //!< 1 if the last transmitted packet was an auto-empty packet
uint8_t bLlCtrlTx:1; //!< 1 if the last transmitted packet was an LL control packet (LLID = 11)
uint8_t bLlCtrlAckRx:1; //!< 1 if the last received packet was the ACK of an LL control packet
uint8_t bLlCtrlAckPending:1; //!< 1 if the last successfully received packet was an LL control packet which has not yet been ACK'ed
} seqStat;
uint8_t maxNack; //!< Maximum number of NACKs received before operation ends. 0: No limit
uint8_t maxPkt; //!< Maximum number of packets transmitted in the operation before it ends. 0: No limit
uint32_t accessAddress; //!< Access address used on the connection
uint8_t crcInit0; //!< CRC initialization value used on the connection &ndash; least significant byte
uint8_t crcInit1; //!< CRC initialization value used on the connection &ndash; middle byte
uint8_t crcInit2; //!< CRC initialization value used on the connection &ndash; most significant byte
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
} timeoutTrigger; //!< Trigger that defines timeout of the first receive operation
ratmr_t timeoutTime; //!< \brief Time used together with <code>timeoutTrigger</code> that defines timeout of the first
//!< receive operation
uint16_t __dummy0;
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 that causes the device to end the connection event as soon as allowed
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the
//!< connection event as soon as allowed
};
//! @}
//! \addtogroup bleAdvPar
//! @{
//! Parameter structure for advertiser (CMD_BLE_ADV*)
struct __RFC_STRUCT rfc_bleAdvPar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
struct {
uint8_t advFilterPolicy:2; //!< \brief The advertiser filter policy, as defined in Volume 2, Part E, Section 7.8.5 of
//!< the Bluetooth 4.0 spec
uint8_t deviceAddrType:1; //!< The type of the device address &ndash; public (0) or random (1)
uint8_t peerAddrType:1; //!< Directed advertiser: The type of the peer address &ndash; public (0) or random (1)
uint8_t bStrictLenFilter:1; //!< 1: Discard messages with illegal length
} advConfig;
uint8_t advLen; //!< Size of advertiser data
uint8_t scanRspLen; //!< Size of scan response data
uint8_t* pAdvData; //!< Pointer to buffer containing ADV*_IND data
uint8_t* pScanRspData; //!< Pointer to buffer containing SCAN_RSP data
uint16_t* pDeviceAddress; //!< Pointer to device address used for this device
rfc_bleWhiteListEntry_t *pWhiteList; //!< Pointer to white list or peer address (directed advertiser)
uint16_t __dummy0;
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 that causes the device to end the advertiser event as soon as allowed
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the
//!< advertiser event as soon as allowed
};
//! @}
//! \addtogroup bleScannerPar
//! @{
//! Parameter structure for scanner (CMD_BLE_SCANNER)
struct __RFC_STRUCT rfc_bleScannerPar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
struct {
uint8_t scanFilterPolicy:1; //!< \brief The advertiser filter policy, as defined in Volume 2, Part E, Section 7.8.10 of
//!< the Bluetooth 4.0 spec
uint8_t bActiveScan:1; //!< \brief 0: Passive scan<br>
//!< 1: Active scan
uint8_t deviceAddrType:1; //!< The type of the device address &ndash; public (0) or random (1)
uint8_t :1;
uint8_t bStrictLenFilter:1; //!< 1: Discard messages with illegal length
uint8_t bAutoWlIgnore:1; //!< 1: Automatically set ignore bit in white list
uint8_t bEndOnRpt:1; //!< 1: End scanner operation after each reported ADV*_IND and potentially SCAN_RSP
} scanConfig;
uint16_t randomState; //!< State for pseudo-random number generation used in backoff procedure
uint16_t backoffCount; //!< Parameter <i>backoffCount</i> used in backoff procedure, cf. Bluetooth 4.0 spec
struct {
uint8_t logUpperLimit:4; //!< Binary logarithm of parameter upperLimit used in scanner backoff procedure
uint8_t bLastSucceeded:1; //!< \brief 1 if the last SCAN_RSP was successfully received and <code>upperLimit</code>
//!< not changed
uint8_t bLastFailed:1; //!< \brief 1 if reception of the last SCAN_RSP failed and <code>upperLimit</code> was not
//!< changed
} backoffPar;
uint8_t scanReqLen; //!< Size of scan request data
uint8_t* pScanReqData; //!< Pointer to buffer containing SCAN_REQ data
uint16_t* pDeviceAddress; //!< Pointer to device address used for this device
rfc_bleWhiteListEntry_t *pWhiteList; //!< Pointer to white list
uint16_t __dummy0;
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
} timeoutTrigger; //!< Trigger that causes the device to stop receiving as soon as allowed
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 stop receiving as soon as allowed
ratmr_t timeoutTime; //!< \brief Time used together with <code>timeoutTrigger</code> that causes the device to stop
//!< receiving as soon as allowed, ending with BLE_DONE_RXTIMEOUT
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to stop
//!< receiving as soon as allowed, ending with BLE_DONE_ENDED
};
//! @}
//! \addtogroup bleInitiatorPar
//! @{
//! Parameter structure for initiator (CMD_BLE_INITIATOR)
struct __RFC_STRUCT rfc_bleInitiatorPar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
struct {
uint8_t bUseWhiteList:1; //!< \brief Initiator filter policy, cf. Volume 2, Part E, Section 7.8.10 of the
//!< Bluetooth 4.0 spec:<br>
//!< 0: Use specific peer address<br>
//!< 1: Use white list
uint8_t bDynamicWinOffset:1; //!< 1: Use dynamic WinOffset insertion
uint8_t deviceAddrType:1; //!< The type of the device address &ndash; public (0) or random (1)
uint8_t peerAddrType:1; //!< The type of the peer address &ndash; public (0) or random (1)
uint8_t bStrictLenFilter:1; //!< 1: Discard messages with illegal length
} initConfig;
uint8_t __dummy0;
uint8_t connectReqLen; //!< Size of connect request data
uint8_t* pConnectReqData; //!< Pointer to buffer containing LLData to go in the CONNECT_REQ
uint16_t* pDeviceAddress; //!< Pointer to device address used for this device
rfc_bleWhiteListEntry_t *pWhiteList; //!< Pointer to white list or peer address
ratmr_t connectTime; //!< \brief Indication of timer value of the first possible start time of the first connection event.
//!< Set to the calculated value if a connection is made and to the next possible connection
//!< time if not.
uint16_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
} timeoutTrigger; //!< Trigger that causes the device to stop receiving as soon as allowed
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 stop receiving as soon as allowed
ratmr_t timeoutTime; //!< \brief Time used together with <code>timeoutTrigger</code> that causes the device to stop
//!< receiving as soon as allowed, ending with BLE_DONE_RXTIMEOUT
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to stop
//!< receiving as soon as allowed, ending with BLE_DONE_ENDED
};
//! @}
//! \addtogroup bleGenericRxPar
//! @{
//! Parameter structure for generic Rx (CMD_BLE_GENERIC_RX)
struct __RFC_STRUCT rfc_bleGenericRxPar_s {
dataQueue_t* pRxQ; //!< Pointer to receive queue. May be NULL; if so, received packets are not stored
struct {
uint8_t bAutoFlushIgnored:1; //!< If 1, automatically remove ignored packets from Rx queue
uint8_t bAutoFlushCrcErr:1; //!< If 1, automatically remove packets with CRC error from Rx queue
uint8_t bAutoFlushEmpty:1; //!< If 1, automatically remove empty packets from Rx queue
uint8_t bIncludeLenByte:1; //!< If 1, include the received 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 bAppendStatus:1; //!< If 1, append a status byte to the packet in the Rx queue
uint8_t bAppendTimestamp:1; //!< If 1, append a timestamp to the packet in the Rx queue
} rxConfig; //!< Configuration bits for the receive queue entries
uint8_t bRepeat; //!< \brief 0: End operation after receiving a packet<br>
//!< 1: Restart receiver after receiving a packet
uint16_t __dummy0;
uint32_t accessAddress; //!< Access address used on the connection
uint8_t crcInit0; //!< CRC initialization value used on the connection &ndash; least significant byte
uint8_t crcInit1; //!< CRC initialization value used on the connection &ndash; middle byte
uint8_t crcInit2; //!< CRC initialization value used on the connection &ndash; most significant byte
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 bleTxTestPar
//! @{
//! Parameter structure for Tx test (CMD_BLE_TX_TEST)
struct __RFC_STRUCT rfc_bleTxTestPar_s {
uint16_t numPackets; //!< \brief Number of packets to transmit<br>
//!< 0: Transmit unlimited number of packets
uint8_t payloadLength; //!< The number of payload bytes in each packet.
uint8_t packetType; //!< \brief The packet type to be used, encoded according to the Bluetooth 4.0 spec, Volume 2, Part E,
//!< Section 7.8.29
ratmr_t period; //!< Number of radio timer cycles between the start of each packet
struct {
uint8_t bOverrideDefault:1; //!< \brief 0: Use default packet encoding<br>
//!< 1: Override packet contents
uint8_t bUsePrbs9:1; //!< \brief If <code>bOverride</code> is 1:<br>
//!< 1: Use PRBS9 encoding of packet
uint8_t bUsePrbs15:1; //!< \brief If <code>bOverride</code> is 1:<br>
//!< 1: Use PRBS15 encoding of packet
} config;
uint8_t byteVal; //!< If <code>config.bOverride</code> is 1, value of each byte to be sent
uint8_t __dummy0;
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 Test Tx operation
ratmr_t endTime; //!< \brief Time used together with <code>endTrigger</code> that causes the device to end the
//!< Test Tx operation
};
//! @}
//! \addtogroup bleMasterSlaveOutput
//! @{
//! Output structure for master and slave (CMD_BLE_MASTER/CMD_BLE_SLAVE)
struct __RFC_STRUCT rfc_bleMasterSlaveOutput_s {
uint8_t nTx; //!< \brief Total number of packets (including auto-empty and retransmissions) that have been
//!< transmitted
uint8_t nTxAck; //!< Total number of transmitted packets (including auto-empty) that have been ACK'ed
uint8_t nTxCtrl; //!< Number of unique LL control packets from the Tx queue that have been transmitted
uint8_t nTxCtrlAck; //!< Number of LL control packets from the Tx queue that have been finished (ACK'ed)
uint8_t nTxCtrlAckAck; //!< \brief Number of LL control packets that have been ACK'ed and where an ACK has been sent in
//!< response
uint8_t nTxRetrans; //!< Number of retransmissions that has been done
uint8_t nTxEntryDone; //!< Number of packets from the Tx queue that have been finished (ACK'ed)
uint8_t nRxOk; //!< Number of packets that have been received with payload, CRC OK and not ignored
uint8_t nRxCtrl; //!< Number of LL control packets that have been received with CRC OK and not ignored
uint8_t nRxCtrlAck; //!< \brief Number of LL control packets that have been received with CRC OK and not ignored, and
//!< then ACK'ed
uint8_t nRxNok; //!< Number of packets that have been received with CRC error
uint8_t nRxIgnored; //!< \brief Number of packets that have been received with CRC OK and ignored due to repeated
//!< sequence number
uint8_t nRxEmpty; //!< Number of packets that have been received with CRC OK and no payload
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
struct {
uint8_t bTimeStampValid:1; //!< 1 if a valid time stamp has been written to timeStamp; 0 otherwise
uint8_t bLastCrcErr:1; //!< 1 if the last received packet had CRC error; 0 otherwise
uint8_t bLastIgnored:1; //!< 1 if the last received packet with CRC OK was ignored; 0 otherwise
uint8_t bLastEmpty:1; //!< 1 if the last received packet with CRC OK was empty; 0 otherwise
uint8_t bLastCtrl:1; //!< 1 if the last received packet with CRC OK was empty; 0 otherwise
uint8_t bLastMd:1; //!< 1 if the last received packet with CRC OK had MD = 1; 0 otherwise
uint8_t bLastAck:1; //!< \brief 1 if the last received packet with CRC OK was an ACK of a transmitted packet;
//!< 0 otherwise
} pktStatus;
ratmr_t timeStamp; //!< Slave operation: Time stamp of first received packet
};
//! @}
//! \addtogroup bleAdvOutput
//! @{
//! Output structure for advertiser (CMD_BLE_ADV*)
struct __RFC_STRUCT rfc_bleAdvOutput_s {
uint16_t nTxAdvInd; //!< Number of ADV*_IND packets completely transmitted
uint8_t nTxScanRsp; //!< Number of SCAN_RSP packets transmitted
uint8_t nRxScanReq; //!< Number of SCAN_REQ packets received OK and not ignored
uint8_t nRxConnectReq; //!< Number of CONNECT_REQ packets received OK and not ignored
uint8_t __dummy0;
uint16_t nRxNok; //!< Number of packets received with CRC error
uint16_t nRxIgnored; //!< Number of packets received with CRC OK, but ignored
uint8_t nRxBufFull; //!< Number of packets received that did not fit in Rx queue
int8_t lastRssi; //!< The RSSI of the last received packet
ratmr_t timeStamp; //!< Time stamp of the last received packet
};
//! @}
//! \addtogroup bleScannerOutput
//! @{
//! Output structure for scanner (CMD_BLE_SCANNER)
struct __RFC_STRUCT rfc_bleScannerOutput_s {
uint16_t nTxScanReq; //!< Number of transmitted SCAN_REQ packets
uint16_t nBackedOffScanReq; //!< Number of SCAN_REQ packets not sent due to backoff procedure
uint16_t nRxAdvOk; //!< Number of ADV*_IND packets received with CRC OK and not ignored
uint16_t nRxAdvIgnored; //!< Number of ADV*_IND packets received with CRC OK, but ignored
uint16_t nRxAdvNok; //!< Number of ADV*_IND packets received with CRC error
uint16_t nRxScanRspOk; //!< Number of SCAN_RSP packets received with CRC OK and not ignored
uint16_t nRxScanRspIgnored; //!< Number of SCAN_RSP packets received with CRC OK, but ignored
uint16_t nRxScanRspNok; //!< Number of SCAN_RSP packets received with CRC error
uint8_t nRxAdvBufFull; //!< Number of ADV*_IND packets received that did not fit in Rx queue
uint8_t nRxScanRspBufFull; //!< Number of SCAN_RSP packets received that did not fit in Rx queue
int8_t lastRssi; //!< The RSSI of the last received packet
uint8_t __dummy0;
ratmr_t timeStamp; //!< Time stamp of the last successfully received ADV*_IND packet that was not ignored
};
//! @}
//! \addtogroup bleInitiatorOutput
//! @{
//! Output structure for initiator (CMD_BLE_INITIATOR)
struct __RFC_STRUCT rfc_bleInitiatorOutput_s {
uint8_t nTxConnectReq; //!< Number of transmitted CONNECT_REQ packets
uint8_t nRxAdvOk; //!< Number of ADV*_IND packets received with CRC OK and not ignored
uint16_t nRxAdvIgnored; //!< Number of ADV*_IND packets received with CRC OK, but ignored
uint16_t nRxAdvNok; //!< Number of ADV*_IND packets received with CRC error
uint8_t nRxAdvBufFull; //!< Number of ADV*_IND packets received that did not fit in Rx queue
int8_t lastRssi; //!< The RSSI of the last received packet
ratmr_t timeStamp; //!< Time stamp of the received ADV*_IND packet that caused transmission of CONNECT_REQ
};
//! @}
//! \addtogroup bleGenericRxOutput
//! @{
//! Output structure for generic Rx (CMD_BLE_GENERIC_RX)
struct __RFC_STRUCT rfc_bleGenericRxOutput_s {
uint16_t nRxOk; //!< Number of packets received with CRC OK
uint16_t nRxNok; //!< Number of packets received with CRC error
uint16_t nRxBufFull; //!< Number of packets that have been received and discarded due to lack of buffer space
int8_t lastRssi; //!< The RSSI of the last received packet
uint8_t __dummy0;
ratmr_t timeStamp; //!< Time stamp of the last received packet
};
//! @}
//! \addtogroup bleTxTestOutput
//! @{
//! Output structure for Tx test (CMD_BLE_TX_TEST)
struct __RFC_STRUCT rfc_bleTxTestOutput_s {
uint16_t nTx; //!< Number of packets transmitted
};
//! @}
//! \addtogroup bleWhiteListEntry
//! @{
//! White list entry structure
struct __RFC_STRUCT rfc_bleWhiteListEntry_s {
uint8_t size; //!< Number of while list entries. Used in the first entry of the list only
struct {
uint8_t bEnable:1; //!< 1 if the entry is in use, 0 if the entry is not in use
uint8_t addrType:1; //!< The type address in the entry &ndash; public (0) or random (1)
uint8_t bWlIgn:1; //!< \brief 1 if the entry is to be ignored by a scanner, 0 otherwise. Used to mask out
//!< entries that have already been scanned and reported.
} conf;
uint16_t address; //!< Least significant 16 bits of the address contained in the entry
uint32_t addressHi; //!< Most significant 32 bits of the address contained in the entry
};
//! @}
//! \addtogroup bleRxStatus
//! @{
//! Receive status byte that may be appended to message in receive buffer
struct __RFC_STRUCT rfc_bleRxStatus_s {
struct {
uint8_t channel:6; //!< \brief The channel on which the packet was received, provided channel is in the range
//!< 0&ndash;39; otherwise 0x3F
uint8_t bIgnore:1; //!< 1 if the packet is marked as ignored, 0 otherwise
uint8_t bCrcErr:1; //!< 1 if the packet was received with CRC error, 0 otherwise
} status;
};
//! @}
//! @}
//! @}
#endif /* BLE_CMD_H_ */
Reference in a new issue Copy permalink