sx126x.h

Go to the documentation of this file.

 
#ifndef __SX126x_H__
#define __SX126x_H__
 
extern "C"
{
#define SX1261 1
#define SX1262 2
 
#define RADIO_TCXO_SETUP_TIME 50 // [ms]
 
#define RADIO_WAKEUP_TIME 3 // [ms]
 
#define AUTO_RX_TX_OFFSET 2
 
#define CRC_IBM_SEED 0xFFFF
 
#define CRC_CCITT_SEED 0x1D0F
 
#define CRC_POLYNOMIAL_IBM 0x8005
 
#define CRC_POLYNOMIAL_CCITT 0x1021
 
#define REG_LR_CRCSEEDBASEADDR 0x06BC
 
#define REG_LR_CRCPOLYBASEADDR 0x06BE
 
#define REG_LR_WHITSEEDBASEADDR_MSB 0x06B8
#define REG_LR_WHITSEEDBASEADDR_LSB 0x06B9
 
#define REG_LR_PACKETPARAMS 0x0704
 
#define REG_LR_PAYLOADLENGTH 0x0702
 
#define REG_LR_SYNCWORDBASEADDRESS 0x06C0
 
#define REG_LR_SYNCWORD 0x0740
 
#define LORA_MAC_PRIVATE_SYNCWORD 0x1424
 
#define LORA_MAC_PUBLIC_SYNCWORD 0x3444
 
#define RANDOM_NUMBER_GENERATORBASEADDR 0x0819
 
#define REG_RX_GAIN 0x08AC
 
#define REG_XTA_TRIM 0x0911
 
#define REG_OCP 0x08E7
 
    typedef union RadioStatus_u {
        uint8_t Value;
        struct
        {                          //bit order is lsb -> msb
            uint8_t Reserved : 1;  
            uint8_t CmdStatus : 3; 
            uint8_t ChipMode : 3;  
            uint8_t CpuBusy : 1;   
        } Fields;
    } RadioStatus_t;
 
    typedef enum
    {
        IRQ_HEADER_ERROR_CODE = 0x01,
        IRQ_SYNCWORD_ERROR_CODE = 0x02,
        IRQ_CRC_ERROR_CODE = 0x04,
    } IrqErrorCode_t;
 
    enum IrqPblSyncHeaderCode_t
    {
        IRQ_PBL_DETECT_CODE = 0x01,
        IRQ_SYNCWORD_VALID_CODE = 0x02,
        IRQ_HEADER_VALID_CODE = 0x04,
    };
 
    typedef enum
    {
        MODE_SLEEP = 0x00, 
        MODE_STDBY_RC,     
        MODE_STDBY_XOSC,   
        MODE_FS,           
        MODE_TX,           
        MODE_RX,           
        MODE_RX_DC,        
        MODE_CAD           
    } RadioOperatingModes_t;
 
    typedef enum
    {
        STDBY_RC = 0x00,
        STDBY_XOSC = 0x01,
    } RadioStandbyModes_t;
 
    typedef enum
    {
        USE_LDO = 0x00, // default
        USE_DCDC = 0x01,
    } RadioRegulatorMode_t;
 
    typedef enum
    {
        PACKET_TYPE_GFSK = 0x00,
        PACKET_TYPE_LORA = 0x01,
        PACKET_TYPE_NONE = 0x0F,
    } RadioPacketTypes_t;
 
    typedef enum
    {
        RADIO_RAMP_10_US = 0x00,
        RADIO_RAMP_20_US = 0x01,
        RADIO_RAMP_40_US = 0x02,
        RADIO_RAMP_80_US = 0x03,
        RADIO_RAMP_200_US = 0x04,
        RADIO_RAMP_800_US = 0x05,
        RADIO_RAMP_1700_US = 0x06,
        RADIO_RAMP_3400_US = 0x07,
    } RadioRampTimes_t;
 
    typedef enum
    {
        LORA_CAD_01_SYMBOL = 0x00,
        LORA_CAD_02_SYMBOL = 0x01,
        LORA_CAD_04_SYMBOL = 0x02,
        LORA_CAD_08_SYMBOL = 0x03,
        LORA_CAD_16_SYMBOL = 0x04,
    } RadioLoRaCadSymbols_t;
 
    typedef enum
    {
        LORA_CAD_ONLY = 0x00,
        LORA_CAD_RX = 0x01,
        LORA_CAD_LBT = 0x10,
    } RadioCadExitModes_t;
 
    typedef enum
    {
        MOD_SHAPING_OFF = 0x00,
        MOD_SHAPING_G_BT_03 = 0x08,
        MOD_SHAPING_G_BT_05 = 0x09,
        MOD_SHAPING_G_BT_07 = 0x0A,
        MOD_SHAPING_G_BT_1 = 0x0B,
    } RadioModShapings_t;
 
    typedef enum
    {
        RX_BW_4800 = 0x1F,
        RX_BW_5800 = 0x17,
        RX_BW_7300 = 0x0F,
        RX_BW_9700 = 0x1E,
        RX_BW_11700 = 0x16,
        RX_BW_14600 = 0x0E,
        RX_BW_19500 = 0x1D,
        RX_BW_23400 = 0x15,
        RX_BW_29300 = 0x0D,
        RX_BW_39000 = 0x1C,
        RX_BW_46900 = 0x14,
        RX_BW_58600 = 0x0C,
        RX_BW_78200 = 0x1B,
        RX_BW_93800 = 0x13,
        RX_BW_117300 = 0x0B,
        RX_BW_156200 = 0x1A,
        RX_BW_187200 = 0x12,
        RX_BW_234300 = 0x0A,
        RX_BW_312000 = 0x19,
        RX_BW_373600 = 0x11,
        RX_BW_467000 = 0x09,
    } RadioRxBandwidth_t;
 
    typedef enum
    {
        LORA_SF5 = 0x05,
        LORA_SF6 = 0x06,
        LORA_SF7 = 0x07,
        LORA_SF8 = 0x08,
        LORA_SF9 = 0x09,
        LORA_SF10 = 0x0A,
        LORA_SF11 = 0x0B,
        LORA_SF12 = 0x0C,
    } RadioLoRaSpreadingFactors_t;
 
    typedef enum
    {
        LORA_BW_500 = 6,
        LORA_BW_250 = 5,
        LORA_BW_125 = 4,
        LORA_BW_062 = 3,
        LORA_BW_041 = 10,
        LORA_BW_031 = 2,
        LORA_BW_020 = 9,
        LORA_BW_015 = 1,
        LORA_BW_010 = 8,
        LORA_BW_007 = 0,
    } RadioLoRaBandwidths_t;
 
    typedef enum
    {
        LORA_CR_4_5 = 0x01,
        LORA_CR_4_6 = 0x02,
        LORA_CR_4_7 = 0x03,
        LORA_CR_4_8 = 0x04,
    } RadioLoRaCodingRates_t;
 
    typedef enum
    {
        RADIO_PREAMBLE_DETECTOR_OFF = 0x00,     
        RADIO_PREAMBLE_DETECTOR_08_BITS = 0x04, 
        RADIO_PREAMBLE_DETECTOR_16_BITS = 0x05, 
        RADIO_PREAMBLE_DETECTOR_24_BITS = 0x06, 
        RADIO_PREAMBLE_DETECTOR_32_BITS = 0x07, 
    } RadioPreambleDetection_t;
 
    typedef enum
    {
        RADIO_ADDRESSCOMP_FILT_OFF = 0x00, 
        RADIO_ADDRESSCOMP_FILT_NODE = 0x01,
        RADIO_ADDRESSCOMP_FILT_NODE_BROAD = 0x02,
    } RadioAddressComp_t;
 
    typedef enum
    {
        RADIO_PACKET_FIXED_LENGTH = 0x00,    
        RADIO_PACKET_VARIABLE_LENGTH = 0x01, 
    } RadioPacketLengthModes_t;
 
    typedef enum
    {
        RADIO_CRC_OFF = 0x01, 
        RADIO_CRC_1_BYTES = 0x00,
        RADIO_CRC_2_BYTES = 0x02,
        RADIO_CRC_1_BYTES_INV = 0x04,
        RADIO_CRC_2_BYTES_INV = 0x06,
        RADIO_CRC_2_BYTES_IBM = 0xF1,
        RADIO_CRC_2_BYTES_CCIT = 0xF2,
    } RadioCrcTypes_t;
 
    typedef enum
    {
        RADIO_DC_FREE_OFF = 0x00,
        RADIO_DC_FREEWHITENING = 0x01,
    } RadioDcFree_t;
 
    typedef enum
    {
        LORA_PACKET_VARIABLE_LENGTH = 0x00, 
        LORA_PACKET_FIXED_LENGTH = 0x01,    
        LORA_PACKET_EXPLICIT = LORA_PACKET_VARIABLE_LENGTH,
        LORA_PACKET_IMPLICIT = LORA_PACKET_FIXED_LENGTH,
    } RadioLoRaPacketLengthsMode_t;
 
    typedef enum
    {
        LORA_CRC_ON = 0x01,  
        LORA_CRC_OFF = 0x00, 
    } RadioLoRaCrcModes_t;
 
    typedef enum
    {
        LORA_IQ_NORMAL = 0x00,
        LORA_IQ_INVERTED = 0x01,
    } RadioLoRaIQModes_t;
 
    typedef enum
    {
        TCXO_CTRL_1_6V = 0x00,
        TCXO_CTRL_1_7V = 0x01,
        TCXO_CTRL_1_8V = 0x02,
        TCXO_CTRL_2_2V = 0x03,
        TCXO_CTRL_2_4V = 0x04,
        TCXO_CTRL_2_7V = 0x05,
        TCXO_CTRL_3_0V = 0x06,
        TCXO_CTRL_3_3V = 0x07,
    } RadioTcxoCtrlVoltage_t;
 
    typedef enum
    {
        IRQ_RADIO_NONE = 0x0000,
        IRQ_TX_DONE = 0x0001,
        IRQ_RX_DONE = 0x0002,
        IRQ_PREAMBLE_DETECTED = 0x0004,
        IRQ_SYNCWORD_VALID = 0x0008,
        IRQ_HEADER_VALID = 0x0010,
        IRQ_HEADER_ERROR = 0x0020,
        IRQ_CRC_ERROR = 0x0040,
        IRQ_CAD_DONE = 0x0080,
        IRQ_CAD_ACTIVITY_DETECTED = 0x0100,
        IRQ_RX_TX_TIMEOUT = 0x0200,
        IRQ_RADIO_ALL = 0xFFFF,
    } RadioIrqMasks_t;
 
    typedef enum RadioCommands_e
    {
        RADIO_GET_STATUS = 0xC0,
        RADIO_WRITE_REGISTER = 0x0D,
        RADIO_READ_REGISTER = 0x1D,
        RADIO_WRITE_BUFFER = 0x0E,
        RADIO_READ_BUFFER = 0x1E,
        RADIO_SET_SLEEP = 0x84,
        RADIO_SET_STANDBY = 0x80,
        RADIO_SET_FS = 0xC1,
        RADIO_SET_TX = 0x83,
        RADIO_SET_RX = 0x82,
        RADIO_SET_RXDUTYCYCLE = 0x94,
        RADIO_SET_CAD = 0xC5,
        RADIO_SET_TXCONTINUOUSWAVE = 0xD1,
        RADIO_SET_TXCONTINUOUSPREAMBLE = 0xD2,
        RADIO_SET_PACKETTYPE = 0x8A,
        RADIO_GET_PACKETTYPE = 0x11,
        RADIO_SET_RFFREQUENCY = 0x86,
        RADIO_SET_TXPARAMS = 0x8E,
        RADIO_SET_PACONFIG = 0x95,
        RADIO_SET_CADPARAMS = 0x88,
        RADIO_SET_BUFFERBASEADDRESS = 0x8F,
        RADIO_SET_MODULATIONPARAMS = 0x8B,
        RADIO_SET_PACKETPARAMS = 0x8C,
        RADIO_GET_RXBUFFERSTATUS = 0x13,
        RADIO_GET_PACKETSTATUS = 0x14,
        RADIO_GET_RSSIINST = 0x15,
        RADIO_GET_STATS = 0x10,
        RADIO_RESET_STATS = 0x00,
        RADIO_CFG_DIOIRQ = 0x08,
        RADIO_GET_IRQSTATUS = 0x12,
        RADIO_CLR_IRQSTATUS = 0x02,
        RADIO_CALIBRATE = 0x89,
        RADIO_CALIBRATEIMAGE = 0x98,
        RADIO_SET_REGULATORMODE = 0x96,
        RADIO_GET_ERROR = 0x17,
        RADIO_CLR_ERROR = 0x07,
        RADIO_SET_TCXOMODE = 0x97,
        RADIO_SET_TXFALLBACKMODE = 0x93,
        RADIO_SET_RFSWITCHMODE = 0x9D,
        RADIO_SET_STOPRXTIMERONPREAMBLE = 0x9F,
        RADIO_SET_LORASYMBTIMEOUT = 0xA0,
    } RadioCommands_t;
 
    typedef struct
    {
        RadioPacketTypes_t PacketType; 
        struct
        {
            struct
            {
                uint32_t BitRate;
                uint32_t Fdev;
                RadioModShapings_t ModulationShaping;
                uint8_t Bandwidth;
            } Gfsk;
            struct
            {
                RadioLoRaSpreadingFactors_t SpreadingFactor; 
                RadioLoRaBandwidths_t Bandwidth;             
                RadioLoRaCodingRates_t CodingRate;           
                uint8_t LowDatarateOptimize;                 
            } LoRa;
        } Params; 
    } ModulationParams_t;
 
    typedef struct
    {
        RadioPacketTypes_t PacketType; 
        struct
        {
            struct
            {
                uint16_t PreambleLength;                    
                RadioPreambleDetection_t PreambleMinDetect; 
                uint8_t SyncWordLength;                     
                RadioAddressComp_t AddrComp;                
                RadioPacketLengthModes_t HeaderType;        
                uint8_t PayloadLength;                      
                RadioCrcTypes_t CrcLength;                  
                RadioDcFree_t DcFree;
            } Gfsk;
            struct
            {
                uint16_t PreambleLength;                 
                RadioLoRaPacketLengthsMode_t HeaderType; 
                uint8_t PayloadLength;                   
                RadioLoRaCrcModes_t CrcMode;             
                RadioLoRaIQModes_t InvertIQ;             
            } LoRa;
        } Params; 
    } PacketParams_t;
 
    typedef struct
    {
        RadioPacketTypes_t packetType; 
        struct
        {
            struct
            {
                uint8_t RxStatus;
                int8_t RssiAvg;  
                int8_t RssiSync; 
                uint32_t FreqError;
            } Gfsk;
            struct
            {
                int8_t RssiPkt; 
                int8_t SnrPkt;  
                int8_t SignalRssiPkt;
                uint32_t FreqError;
            } LoRa;
        } Params;
    } PacketStatus_t;
 
    typedef struct
    {
        RadioPacketTypes_t packetType; 
        uint16_t PacketReceived;
        uint16_t CrcOk;
        uint16_t LengthError;
    } RxCounter_t;
 
    typedef union {
        struct
        {
            uint8_t RC64KEnable : 1;    
            uint8_t RC13MEnable : 1;    
            uint8_t PLLEnable : 1;      
            uint8_t ADCPulseEnable : 1; 
            uint8_t ADCBulkNEnable : 1; 
            uint8_t ADCBulkPEnable : 1; 
            uint8_t ImgEnable : 1;
            uint8_t : 1;
        } Fields;
        uint8_t Value;
    } CalibrationParams_t;
 
    typedef union {
        struct
        {
            uint8_t WakeUpRTC : 1; 
            uint8_t Reset : 1;
            uint8_t WarmStart : 1;
            uint8_t Reserved : 5;
        } Fields;
        uint8_t Value;
    } SleepParams_t;
 
    typedef union {
        struct
        {
            uint8_t Rc64kCalib : 1; 
            uint8_t Rc13mCalib : 1; 
            uint8_t PllCalib : 1;   
            uint8_t AdcCalib : 1;   
            uint8_t ImgCalib : 1;   
            uint8_t XoscStart : 1;  
            uint8_t PllLock : 1;    
            uint8_t BuckStart : 1;  
            uint8_t PaRamp : 1;     
            uint8_t : 7;            
        } Fields;
        uint16_t Value;
    } RadioError_t;
 
    typedef struct SX126x_s
    {
        int Reset;
        int BUSY;
        int DIO1;
        int DIO2;
        int DIO3;
        int Spi;
        PacketParams_t PacketParams;
        PacketStatus_t PacketStatus;
        ModulationParams_t ModulationParams;
    } SX126x_t;
 
    typedef void(DioIrqHandler)(void);
 
#define XTAL_FREQ (double)32000000
#define FREQ_DIV (double)pow(2.0, 25.0)
#define FREQ_STEP (double)(XTAL_FREQ / FREQ_DIV)
 
#define RX_BUFFER_SIZE 256
 
    typedef struct
    {
        void (*txDone)(void);                    
        void (*rxDone)(void);                    
        void (*rxPreambleDetect)(void);          
        void (*rxSyncWordDone)(void);            
        void (*rxHeaderDone)(bool isOk);         
        void (*txTimeout)(void);                 
        void (*rxTimeout)(void);                 
        void (*rxError)(IrqErrorCode_t errCode); 
        void (*cadDone)(bool cadFlag);           
    } SX126xCallbacks_t;
 
    void SX126xInit(DioIrqHandler dioIrq);
 
    void SX126xReInit(DioIrqHandler dioIrq);
 
    RadioOperatingModes_t SX126xGetOperatingMode(void);
 
    void SX126xSetOperatingMode(RadioOperatingModes_t mode);
 
    void SX126xCheckDeviceReady(void);
 
    void SX126xSetPayload(uint8_t *payload, uint8_t size);
 
    uint8_t SX126xGetPayload(uint8_t *payload, uint8_t *size, uint8_t maxSize);
 
    void SX126xSendPayload(uint8_t *payload, uint8_t size, uint32_t timeout);
 
    uint8_t SX126xSetSyncWord(uint8_t *syncWord);
 
    void SX126xSetCrcSeed(uint16_t seed);
 
    void SX126xSetCrcPolynomial(uint16_t polynomial);
 
    void SX126xSetWhiteningSeed(uint16_t seed);
 
    uint32_t SX126xGetRandom(void);
 
    void SX126xSetSleep(SleepParams_t sleepConfig);
 
    void SX126xSetStandby(RadioStandbyModes_t mode);
 
    void SX126xSetFs(void);
 
    void SX126xSetTx(uint32_t timeout);
 
    void SX126xSetRx(uint32_t timeout);
 
    void SX126xSetRxBoosted(uint32_t timeout);
 
    void SX126xSetRxDutyCycle(uint32_t rxTime, uint32_t sleepTime);
 
    void SX126xSetCad(void);
 
    void SX126xSetTxContinuousWave(void);
 
    void SX126xSetTxInfinitePreamble(void);
 
    void SX126xSetStopRxTimerOnPreambleDetect(bool enable);
 
    void SX126xSetLoRaSymbNumTimeout(uint8_t SymbNum);
 
    void SX126xSetRegulatorMode(RadioRegulatorMode_t mode);
 
    void SX126xCalibrate(CalibrationParams_t calibParam);
 
    void SX126xCalibrateImage(uint32_t freq);
 
    void SX126xSetLongPreamble(uint8_t enable);
 
    void SX126xSetPaConfig(uint8_t paDutyCycle, uint8_t hpMax, uint8_t deviceSel, uint8_t paLut);
 
    void SX126xSetRxTxFallbackMode(uint8_t fallbackMode);
 
    void SX126xWriteRegisters(uint16_t address, uint8_t *buffer, uint16_t size);
 
    void SX126xReadRegisters(uint16_t address, uint8_t *buffer, uint16_t size);
 
    void SX126xWriteBuffer(uint8_t offset, uint8_t *buffer, uint8_t size);
 
    void SX126xReadBuffer(uint8_t offset, uint8_t *buffer, uint8_t size);
 
    void SX126xSetDioIrqParams(uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask);
 
    uint16_t SX126xGetIrqStatus(void);
 
    void SX126xSetDio2AsRfSwitchCtrl(uint8_t enable);
 
    void SX126xSetDio3AsTcxoCtrl(RadioTcxoCtrlVoltage_t tcxoVoltage, uint32_t timeout);
 
    void SX126xSetRfFrequency(uint32_t frequency);
 
    void SX126xSetPacketType(RadioPacketTypes_t packetType);
 
    RadioPacketTypes_t SX126xGetPacketType(void);
 
    void SX126xSetTxParams(int8_t power, RadioRampTimes_t rampTime);
 
    void SX126xSetModulationParams(ModulationParams_t *modParams);
 
    void SX126xSetPacketParams(PacketParams_t *packetParams);
 
    void SX126xSetCadParams(RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin, RadioCadExitModes_t cadExitMode, uint32_t cadTimeout);
 
    void SX126xSetBufferBaseAddress(uint8_t txBaseAddress, uint8_t rxBaseAddress);
 
    RadioStatus_t SX126xGetStatus(void);
 
    int8_t SX126xGetRssiInst(void);
 
    void SX126xGetRxBufferStatus(uint8_t *payloadLength, uint8_t *rxStartBuffer);
 
    void SX126xGetPacketStatus(PacketStatus_t *pktStatus);
 
    RadioError_t SX126xGetDeviceErrors(void);
 
    void SX126xClearDeviceErrors(void);
 
    void SX126xClearIrqStatus(uint16_t irq);
};
#endif // __SX126x_H__