ble5.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2025, 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:
 *
 * *  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 ti_drivers_RCL_commands_ble5_h__include
#define ti_drivers_RCL_commands_ble5_h__include

typedef struct RCL_FL_ENTRY_t     RCL_FL_Entry;
typedef struct RCL_FILTER_LIST_t  RCL_FilterList;

typedef struct RCL_ADDR_TYPE_t    RCL_AddrType;
typedef struct RCL_CONN_PARAMS_t  RCL_ConnParams;

typedef struct RCL_CMD_BLE5_ADV_t           RCL_CmdBle5Advertiser;
typedef struct RCL_CMD_BLE5_AUX_ADV_t       RCL_CmdBle5AuxAdvertiser;
typedef struct RCL_CMD_BLE5_PER_ADV_t       RCL_CmdBle5PeriodicAdvertiser;
typedef struct RCL_CMD_BLE5_INITIATOR_t     RCL_CmdBle5Initiator;
typedef struct RCL_CMD_BLE5_SCANNER_t       RCL_CmdBle5Scanner;
typedef struct RCL_CMD_BLE5_PER_SCANNER_t   RCL_CmdBle5PeriodicScanner;
typedef struct RCL_CMD_BLE5_CONNECTION_t    RCL_CmdBle5Connection;
typedef struct RCL_CMD_BLE5_DTM_TX          RCL_CmdBle5DtmTx;
typedef struct RCL_CMD_BLE5_GENERIC_RX_t    RCL_CmdBle5GenericRx;
typedef struct RCL_CMD_BLE5_GENERIC_TX_t    RCL_CmdBle5GenericTx;
typedef struct RCL_CMD_BLE5_TX_TEST_t       RCL_CmdBle5TxTest;
typedef struct RCL_CMD_BLE5_CH_ASSESSMENT_t RCL_CmdBle5ChAssessment;

typedef struct RCL_CTX_ADVERTISER_t         RCL_CtxAdvertiser;
typedef struct RCL_CTX_PER_ADVERTISER_t     RCL_CtxPeriodicAdvertiser;
typedef struct RCL_CTX_SCAN_INIT_t          RCL_CtxScanInit;
typedef struct RCL_CTX_PER_SCANNER_t        RCL_CtxPeriodicScanner;
typedef struct RCL_CTX_CONNECTION_t         RCL_CtxConnection;
typedef struct RCL_CTX_GENERIC_RX_t         RCL_CtxGenericRx;
typedef struct RCL_CTX_GENERIC_TX_t         RCL_CtxGenericTx;

typedef struct RCL_STATS_ADV_SCAN_INIT_t    RCL_StatsAdvScanInit;
typedef struct RCL_STATS_CONNECTION_t       RCL_StatsConnection;
typedef struct RCL_STATS_GENERIC_RX_t       RCL_StatsGenericRx;

typedef uint8_t RCL_Ble5Channel;

typedef enum {
    RCL_Ble5_RxPhy1Mbps = 0,
    RCL_Ble5_RxPhy2Mbps = 1,
    RCL_Ble5_RxPhyCodedS8 = 2,
    RCL_Ble5_RxPhyCodedS2 = 3,
} RCL_Ble5_RxPhy;

typedef union {
    struct {
        RCL_Ble5_RxPhy phy       :2;     
        uint8_t crcError         :1;     
        uint8_t ignored          :1;     
        uint8_t ignoredAddr      :1;     
        uint8_t syncInfoOnly     :1;     
        uint8_t reserved         :2;
    };
    uint8_t value;
} RCL_Ble5_RxPktStatus;

/* Invalid packet status */
#define RCL_BLE5_RX_PKT_STATUS_INVALID 0xFF

/* Do includes after typedefs, as the types are needed in ti/drivers/rcl/handlers/ble5.h */
#include <ti/drivers/rcl/RCL_Command.h>
#include <ti/drivers/rcl/handlers/ble5.h>
#include <ti/drivers/utils/List.h>

#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(inc/pbe_ble5_ram_regs.h)

/* Command IDs for BLE commands */
#define RCL_CMDID_BLE5_ADVERTISER              0x1001U
#define RCL_CMDID_BLE5_INITIATOR               0x1002U
#define RCL_CMDID_BLE5_SCANNER                 0x1003U
#define RCL_CMDID_BLE5_CONNECTION              0x1004U
#define RCL_CMDID_BLE5_DTM_TX                  0x1005U
#define RCL_CMDID_BLE5_GENERIC_RX              0x1006U
#define RCL_CMDID_BLE5_GENERIC_TX              0x1007U
#define RCL_CMDID_BLE5_TX_TEST                 0x1008U
#define RCL_CMDID_BLE5_AUX_ADV                 0x1009U
#define RCL_CMDID_BLE5_PERIODIC_ADV            0x100AU
#define RCL_CMDID_BLE5_PERIODIC_SCAN           0x100BU
#define RCL_CMDID_BLE5_CH_ASSESSMENT           0x100CU

#define BLE_CUSTOM_FREQ_BM        0x80U

struct RCL_FL_ENTRY_t {
    union
    {
        struct
        {
            uint16_t enabled      : 1; 
            uint16_t addType      : 1; 
            uint16_t duplicateIgn : 1; 
            uint16_t privIgn      : 1; 
            uint16_t reserved     : 12;
        } ctl;
        uint16_t ctlWord;
    };
    uint16_t address[3];               
};

struct RCL_FILTER_LIST_t {
    uint32_t     numEntries;
    RCL_FL_Entry entries[16];
};

struct RCL_ADDR_TYPE_t {
    uint8_t peer :1;     
    uint8_t own :1;      
    uint8_t scanReq :1;  
    uint8_t reserved: 5; 
};

struct RCL_CONN_PARAMS_t {
    struct
    {
        uint16_t interval;
        uint16_t latency;
        uint16_t timeout;
    } ble2M;
    struct
    {
        uint16_t interval;
        uint16_t latency;
        uint16_t timeout;
    } bleCoded;
};

struct RCL_CMD_BLE5_ADV_t {
    RCL_Command  common;
    uint8_t chanMap;              
    RCL_Command_TxPower txPower;  
    uint8_t order;                
    uint8_t highDuty;             
    uint32_t connectPktTime;      
    RCL_CtxAdvertiser *ctx;       
    RCL_StatsAdvScanInit *stats;  
};

#define RCL_CmdBle5Advertiser_Default()                         \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_ADVERTISER,    \
                                  RCL_Handler_BLE5_adv),        \
    .chanMap = 0x7,                                             \
    .txPower = {.dBm = 0, .fraction = 0},                       \
    .order = 0,                                                 \
    .highDuty = 0,                                              \
    .connectPktTime = 0,                                        \
    .ctx = NULL,                                                \
    .stats = NULL,                                              \
}
#define RCL_CmdBle5Advertiser_DefaultRuntime() (RCL_CmdBle5Advertiser) RCL_CmdBle5Advertiser_Default()

struct RCL_CMD_BLE5_AUX_ADV_t {
    RCL_Command  common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    uint32_t connectPktTime;      
    RCL_CtxAdvertiser *ctx;       
    RCL_StatsAdvScanInit *stats;  
};

#define RCL_CmdBle5AuxAdvertiser_Default()                      \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_AUX_ADV,       \
                                  RCL_Handler_BLE5_aux_adv),    \
    .channel = 0,                                               \
    .txPower = {.dBm = 0, .fraction = 0},                       \
    .ctx = NULL,                                                \
    .stats = NULL,                                              \
}
#define RCL_CmdBle5AuxAdvertiser_DefaultRuntime() (RCL_CmdBle5AuxAdvertiser) RCL_CmdBle5AuxAdvertiser_Default()

struct RCL_CTX_ADVERTISER_t {
    RCL_FilterList *filterListConn;     
    RCL_FilterList *filterListScan;     
    List_List txBuffers;                
    List_List rxBuffers;                
    uint16_t advA[3];                   
    uint16_t peerA[3];                  
    RCL_AddrType addrType;              
    uint8_t filterPolicy: 2;            
    uint8_t privIgnMode: 1;             
    uint8_t addrModePeer: 1;            
    uint8_t acceptAllConnectInd: 1;     
};

#define RCL_CtxAdvertiser_Default() \
{                                   \
    .filterListConn = NULL,         \
    .filterListScan = NULL,         \
    .txBuffers = { 0 },             \
    .rxBuffers = { 0 },             \
    .advA = { 0 },                  \
    .peerA = { 0 },                 \
    .addrType =  { 0 },             \
    .filterPolicy = 0,              \
    .privIgnMode = 0,               \
    .addrModePeer = 0,              \
    .acceptAllConnectInd = 0     \
}
#define RCL_CtxAdvertiser_DefaultRuntime() (RCL_CtxAdvertiser) RCL_CtxAdvertiser_Default()

struct RCL_CMD_BLE5_PER_ADV_t {
    RCL_Command  common;
    RCL_Ble5Channel channel;         
    RCL_Command_TxPower txPower;     
    RCL_CtxPeriodicAdvertiser *ctx;  
    RCL_StatsAdvScanInit *stats;     
};

#define RCL_CmdBle5PeriodicAdvertiser_Default()                         \
{                                                                       \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_PERIODIC_ADV,          \
                                  RCL_Handler_BLE5_periodicAdv),        \
    .channel = 0,                                                       \
    .txPower = {.dBm = 0, .fraction = 0},                               \
    .ctx = NULL,                                                        \
    .stats = NULL,                                                      \
}
#define RCL_CmdBle5PeriodicAdvertiser_DefaultRuntime() (RCL_CmdBle5PeriodicAdvertiser) RCL_CmdBle5PeriodicAdvertiser_Default()

struct RCL_CTX_PER_ADVERTISER_t {
    List_List txBuffers;       
    uint32_t accessAddress;    
    uint32_t crcInit;          
};

#define RCL_CtxPeriodicAdvertiser_Default() \
{                                           \
    .txBuffers = { 0 },                     \
    .accessAddress = 0,                     \
    .crcInit = 0,                           \
}
#define RCL_CtxPeriodicAdvertiser_DefaultRuntime() (RCL_CtxPeriodicAdvertiser) RCL_CtxPeriodicAdvertiser_Default()

struct RCL_CMD_BLE5_INITIATOR_t {
    RCL_Command common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    uint16_t maxAuxPtrWaitTime;   
    bool dynamicWinOffset;        
    bool acceptLegacy : 1;        
    bool acceptExtended : 1;      
    uint32_t connectTime;         
    RCL_CtxScanInit *ctx;         
    RCL_StatsAdvScanInit *stats;  
};

#define RCL_CmdInitiator_Default()                                  \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_INITIATOR,         \
                                  RCL_Handler_BLE5_scan_init),      \
    .channel = 37,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .maxAuxPtrWaitTime = 30000,                                     \
    .dynamicWinOffset = 0,                                          \
    .acceptLegacy = 1,                                              \
    .acceptExtended = 0,                                            \
    .connectTime = 0,                                               \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdInitiator_DefaultRuntime() (RCL_CmdBle5Initiator) RCL_CmdInitiator_Default()

struct RCL_CMD_BLE5_SCANNER_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_Command_TxPower txPower;   
    uint16_t maxAuxPtrWaitTime;    
    bool activeScan;               
    bool acceptLegacy : 1;         
    bool acceptExtended : 1;       
    RCL_CtxScanInit *ctx;          
    RCL_StatsAdvScanInit *stats;   
};

#define RCL_CmdScanner_Default()                                    \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_SCANNER,           \
                                  RCL_Handler_BLE5_scan_init),      \
    .channel = 37,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .maxAuxPtrWaitTime = 20000,                                     \
    .activeScan = 0,                                                \
    .acceptLegacy = 1,                                              \
    .acceptExtended = 0,                                            \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdScanner_DefaultRuntime() (RCL_CmdBle5Scanner) RCL_CmdScanner_Default()

struct RCL_CTX_SCAN_INIT_t {
    RCL_FilterList *filterList;           
    List_List txBuffers;                  
    List_List rxBuffers;                  
    uint16_t ownA[3];                     
    uint16_t peerA[3];                    
    uint16_t scanReqA[3];                 
    RCL_AddrType addrType;                
    uint8_t filterPolicy : 1;             
    uint8_t scanExtFilterPolicy: 1;       
    uint8_t addrModePeer: 1;              
    uint8_t acceptAllRpaConnectRsp: 1;    
    uint8_t periodicSyncEstablishment: 1; 
    uint16_t initialBackoff;              
    uint8_t backoffUpper;                 
    struct
    {
        uint8_t backOffLastFail : 1;
        uint8_t backOffLastSucceed : 1;
        uint8_t reserved  : 6;
    } backoffStatus;                      
    uint16_t localClockAccuracy;          
    RCL_ConnParams connParams;            
};

#define RCL_CtxScanInit_Default()   \
{                                   \
    .filterList = NULL,             \
    .txBuffers = { 0 },             \
    .rxBuffers = { 0 },             \
    .ownA = { 0 },                  \
    .peerA = { 0 },                 \
    .scanReqA = { 0 },              \
    .addrType =  { 0 },             \
    .filterPolicy = 0,              \
    .scanExtFilterPolicy = 0,       \
    .addrModePeer = 0,              \
    .acceptAllRpaConnectRsp = 0,    \
    .periodicSyncEstablishment = 0, \
    .initialBackoff = 1,            \
    .backoffUpper = 0,              \
    .backoffStatus = { 0 },         \
    .localClockAccuracy = 3355,     \
}
#define RCL_CtxScanInit_DefaultRuntime() (RCL_CtxScanInit) RCL_CtxScanInit_Default()

struct RCL_CMD_BLE5_PER_SCANNER_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_Command_TxPower txPower;   
    bool perAdvType;               
    uint16_t maxAuxPtrWaitTime;    
    uint32_t receivedPktTime;      
    RCL_CtxPeriodicScanner *ctx;   
    RCL_StatsAdvScanInit *stats;   
};

#define RCL_CmdPeriodicScanner_Default()                            \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_PERIODIC_SCAN,     \
                                  RCL_Handler_BLE5_periodicScan),   \
    .channel = 37,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .perAdvType = 0,                                                \
    .maxAuxPtrWaitTime = 20000,                                     \
    .receivedPktTime = 0,                                           \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdPeriodicScanner_DefaultRuntime() (RCL_CmdBle5PeriodicScanner) RCL_CmdPeriodicScanner_Default()

struct RCL_CTX_PER_SCANNER_t {
    List_List txBuffers;                  
    List_List rxBuffers;                  
    uint16_t ownA[3];                     
    uint16_t peerA[3];                    
    RCL_AddrType addrType;                
    uint16_t localClockAccuracy;          
    uint32_t accessAddress;               
    uint32_t crcInit;                     
    uint8_t acceptAllConnectInd;          
};

#define RCL_CtxPeriodicScanner_Default()   \
{                                          \
    .txBuffers = { 0 },                    \
    .rxBuffers = { 0 },                    \
    .ownA = { 0 },                         \
    .peerA = { 0 },                        \
    .addrType = { 0 },                     \
    .localClockAccuracy = 3355,            \
    .accessAddress = 0,                    \
    .crcInit = 0,                          \
    .acceptAllConnectInd = 1,              \
}
#define RCL_CtxPeriodicScanner_DefaultRuntime() (RCL_CtxPeriodicScanner) RCL_CtxPeriodicScanner_Default()

struct RCL_STATS_ADV_SCAN_INIT_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   timestampValid;        
    int8_t    lastRssi;              
    uint32_t  lastTimestamp;         
    uint16_t  nRxNok;                
    uint16_t  nRxIgnored;            
    uint16_t  nRxOk;                 
    uint8_t   nRxFifoFull;           
    uint8_t   nTx;                   
};

#define RCL_StatsAdvScanInit_Default()  \
{                                       \
    .config = { 0 },                    \
    .timestampValid = 0,                \
    .lastRssi = LRF_RSSI_INVALID,       \
}
#define RCL_StatsAdvScanInit_DefaultRuntime() (RCL_StatsAdvScanInit) RCL_StatsAdvScanInit_Default()

struct RCL_CMD_BLE5_CONNECTION_t {
    RCL_Command common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    uint16_t relRxTimeoutTime;    
    RCL_CtxConnection *ctx;       
    RCL_StatsConnection *stats;   
};

#define RCL_CmdBle5Connection_Default()                             \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_CONNECTION,        \
                                  RCL_Handler_BLE5_conn),           \
    .channel = 0,                                                   \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdBle5Connection_DefaultRuntime() (RCL_CmdBle5Connection) RCL_CmdBle5Connection_Default()

struct RCL_CTX_CONNECTION_t {
    List_List txBuffers;       
    List_List rxBuffers;       
    bool      isPeripheral;    
    uint16_t  seqStat;         
    uint32_t  accessAddress;   
    uint32_t  crcInit;         
};

#define _INIT_SEQSTAT (PBE_BLE5_RAM_SEQSTAT_LASTRXSN_M | \
                       PBE_BLE5_RAM_SEQSTAT_LASTTXSN_M | \
                       PBE_BLE5_RAM_SEQSTAT_FIRSTPKT_M )

#define RCL_CtxConnection_Default() \
{                                   \
    .txBuffers = { 0 },             \
    .rxBuffers = { 0 },             \
    .isPeripheral = 0,              \
    .seqStat = _INIT_SEQSTAT,       \
    .accessAddress = 0,             \
    .crcInit = 0,                   \
}
#define RCL_CtxConnection_DefaultRuntime() (RCL_CtxConnection) RCL_CtxConnection_Default()

struct RCL_STATS_CONNECTION_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   anchorValid;           
    int8_t    lastRssi;              
    uint32_t  anchorPoint;           
    uint8_t   nTxDone;               
    uint8_t   nTxAck;                
    uint8_t   nTxCtlAck;             
    uint8_t   nTxCtl;                
    uint8_t   nTxRetrans;            
    uint8_t   nRxNok;                
    uint8_t   nRxIgnored;            
    uint8_t   nRxEmpty;              
    uint8_t   nRxFifoFull;           
    uint8_t   nRxOk;                 
    uint8_t   nTx;                   
    uint8_t   nRxCtl;                
    uint8_t   nRxCtlAck;             
};

#define RCL_StatsConnection_Default()   \
{                                       \
    .config = { 0 },                    \
    .anchorValid = 0,                   \
    .lastRssi = LRF_RSSI_INVALID,       \
}
#define RCL_StatsConnection_DefaultRuntime() (RCL_StatsConnection) RCL_StatsConnection_Default()

struct RCL_CMD_BLE5_DTM_TX {
    RCL_Command common;
    RCL_Ble5Channel channel;      
    RCL_Command_TxPower txPower;  
    uint8_t   pduHeader;          
    uint8_t   pduLength;          
    uint8_t   cteInfo;            
    uint16_t  periodUs;           
    uint16_t  numPackets;         
};

#define RCL_CmdBle5DtmTx_Default()                          \
{                                                           \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_DTM_TX,    \
                                  RCL_Handler_BLE5_dtmTx),  \
    .channel = 64,                                          \
    .txPower = {.dBm = 0, .fraction = 0},                   \
    .pduHeader = 0x00,                                      \
    .pduLength = 37,                                        \
    .cteInfo = 0x14,                                        \
    .periodUs = 625,                                        \
    .numPackets = 0,                                        \
}
#define RCL_CmdBle5DtmTx_DefaultRuntime() (RCL_CmdBle5DtmTx) RCL_CmdBle5DtmTx_Default()

struct RCL_CMD_BLE5_GENERIC_RX_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_CtxGenericRx *ctx;         
    RCL_StatsGenericRx *stats;     
};

#define RCL_CmdBle5GenericRx_Default()                              \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_GENERIC_RX,        \
                                  RCL_Handler_BLE5_genericRx),      \
    .channel = 64,                                                  \
    .ctx = NULL,                                                    \
    .stats = NULL,                                                  \
}
#define RCL_CmdBle5GenericRx_DefaultRuntime() (RCL_CmdBle5GenericRx) RCL_CmdBle5GenericRx_Default()

struct RCL_CTX_GENERIC_RX_t {
    List_List rxBuffers;       
    uint32_t  accessAddress;   
    uint32_t  crcInit;         
    uint8_t   maxPktLen;       
    uint8_t   maxPkts;         
    struct {
        uint8_t  repeated: 1;         
        uint8_t  disableSync: 1;      
        uint8_t  discardRxPackets: 1; 
        uint8_t  reserved: 4;         
    } config;
};

#define RCL_CtxGenericRx_Default()  \
{                                   \
    .rxBuffers = { 0 },             \
    .accessAddress = 0x71764129U,   \
    .crcInit = 0x555555,            \
    .maxPktLen = 255,               \
    .maxPkts = 0,                   \
    .config = {                     \
        .repeated = 1,              \
        .disableSync = 0,           \
        .discardRxPackets = 1,      \
        .reserved = 0,              \
    },                              \
}
#define RCL_CtxGenericRx_DefaultRuntime() (RCL_CtxGenericRx) RCL_CtxGenericRx_Default()

struct RCL_STATS_GENERIC_RX_t {
    struct
    {
        uint8_t accumulate : 1;      
        uint8_t activeUpdate : 1;    
        uint8_t reserved : 6;        
    } config;                        
    uint8_t   timestampValid;        
    int8_t    lastRssi;              
    uint32_t  lastTimestamp;         
    uint16_t  nRxNok;                
    uint16_t  nRxOk;                 
    uint8_t   nRxFifoFull;           
};

#define RCL_StatsGenericRx_Default()    \
{                                       \
    .config =  { 0 },                   \
    .timestampValid = 0,                \
    .lastRssi = LRF_RSSI_INVALID,       \
}
#define RCL_StatsGenericRx_DefaultRuntime() (RCL_StatsGenericRx) RCL_StatsGenericRx_Default()

struct RCL_CMD_BLE5_GENERIC_TX_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    RCL_Command_TxPower txPower;   
    RCL_CtxGenericTx *ctx;         
};

#define RCL_CmdBle5GenericTx_Default()                              \
{                                                                   \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_GENERIC_TX,        \
                                  RCL_Handler_BLE5_genericTx),      \
    .channel = 64,                                                  \
    .txPower = {.dBm = 0, .fraction = 0},                           \
    .ctx = NULL,                                                    \
}
#define RCL_CmdBle5GenericTx_DefaultRuntime() (RCL_CmdBle5GenericTx) RCL_CmdBle5GenericTx_Default()

struct RCL_CTX_GENERIC_TX_t {
    List_List txBuffers;            
    uint32_t  accessAddress;        
    uint32_t  crcInit;              
};

#define RCL_CtxGenericTx_Default()  \
{                                   \
    .txBuffers = { 0 },             \
    .accessAddress = 0x71764129U,   \
    .crcInit = 0x555555,            \
}
#define RCL_CtxGenericTx_DefaultRuntime() (RCL_CtxGenericTx) RCL_CtxGenericTx_Default()

struct RCL_CMD_BLE5_TX_TEST_t {
    RCL_Command  common;
    uint8_t      channel;           
    RCL_Command_TxPower txPower;    
    uint16_t     txWord;            
    struct {
        uint8_t  whitenMode: 2;     
        uint8_t  sendCw: 1;         
        uint8_t  reserved: 5;       
    } config;
};

#define RCL_CmdBle5TxTest_Default()                             \
{                                                               \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_TX_TEST,       \
                                  RCL_Handler_Ble5_txTest),     \
    .channel = 64,                                              \
    .txPower = {.dBm = 0, .fraction = 0},                       \
    .txWord = 0,                                                \
    .config = {                                                 \
        .whitenMode = 2,                                        \
        .sendCw = 0,                                            \
        .reserved = 0,                                          \
    },                                                          \
}
#define RCL_CmdBle5TxTest_DefaultRuntime() (RCL_CmdBle5TxTest) RCL_CmdBle5TxTest_Default()

#define RCL_CMD_BLE5_WH_MODE_DEFAULT  0 
#define RCL_CMD_BLE5_WH_MODE_PRBS9    1 
#define RCL_CMD_BLE5_WH_MODE_PRBS15   2 
#define RCL_CMD_BLE5_WH_MODE_PRBS32   3 
struct RCL_CMD_BLE5_CH_ASSESSMENT_t {
    RCL_Command common;
    RCL_Ble5Channel channel;       
    int8_t assessmentThreshold;    
    uint16_t assessmentDuration;   
};

#define RCL_CmdBle5ChAssessment_Default()                                   \
{                                                                           \
    .common = RCL_Command_Default(RCL_CMDID_BLE5_CH_ASSESSMENT,             \
                                  RCL_Handler_BLE5_ChannelAssessment),      \
    .channel = 37,                                                          \
    .assessmentThreshold = -70,                                             \
    .assessmentDuration = 400,                                              \
}
#define RCL_CmdBle5ChAssessment_DefaultRuntime() (RCL_CmdBle5ChAssessment) RCL_CmdBle5ChAssessment_Default()

#endif