/* ______ _ / _____) _ | | ( (____ _____ ____ _| |_ _____ ____| |__ \____ \| ___ | (_ _) ___ |/ ___) _ \ _____) ) ____| | | || |_| ____( (___| | | | (______/|_____)_|_|_| \__)_____)\____)_| |_| (C)2016 Semtech Description: Driver for SX1280 devices License: Revised BSD License, see LICENSE.TXT file include in the project Maintainer: Miguel Luis, Gregory Cristian and Matthieu Verdy */ #ifndef __SX1280_H__ #define __SX1280_H__ #include #include #include /*! * \brief Enables/disables driver debug features */ #define SX1280_DEBUG 0 /*! * \brief Hardware IO IRQ callback function definition */ typedef void ( DioIrqHandler )( void ); /*! * \brief Provides the frequency of the chip running on the radio and the frequency step * * \remark These defines are used for computing the frequency divider to set the RF frequency */ #define XTAL_FREQ 52000000 #define FREQ_STEP ( ( double )( XTAL_FREQ / pow( 2.0, 18.0 ) ) ) /*! * \brief Compensation delay for SetAutoTx/Rx functions in microseconds */ #define AUTO_RX_TX_OFFSET 33 /*! * \brief The address of the register holding the firmware version MSB */ #define REG_LR_FIRMWARE_VERSION_MSB 0x0153 /*! * \brief The address of the register holding the first byte defining the CRC seed * * \remark Only used for packet types GFSK and Flrc */ #define REG_LR_CRCSEEDBASEADDR 0x09C8 /*! * \brief The address of the register holding the first byte defining the CRC polynomial * * \remark Only used for packet types GFSK and Flrc */ #define REG_LR_CRCPOLYBASEADDR 0x09C6 /*! * \brief The address of the register holding the first byte defining the whitening seed * * \remark Only used for packet types GFSK, FLRC and BLE */ #define REG_LR_WHITSEEDBASEADDR 0x09C5 /*! * \brief The address of the register holding the ranging id check length * * \remark Only used for packet type Ranging */ #define REG_LR_RANGINGIDCHECKLENGTH 0x0931 /*! * \brief The address of the register holding the device ranging id * * \remark Only used for packet type Ranging */ #define REG_LR_DEVICERANGINGADDR 0x0916 /*! * \brief The address of the register holding the device ranging id * * \remark Only used for packet type Ranging */ #define REG_LR_REQUESTRANGINGADDR 0x0912 /*! * \brief The address of the register holding ranging results configuration * and the corresponding mask * * \remark Only used for packet type Ranging */ #define REG_LR_RANGINGRESULTCONFIG 0x0924 #define MASK_RANGINGMUXSEL 0xCF /*! * \brief The address of the register holding the first byte of ranging results * Only used for packet type Ranging */ #define REG_LR_RANGINGRESULTBASEADDR 0x0961 /*! * \brief The address of the register allowing to read ranging results * * \remark Only used for packet type Ranging */ #define REG_LR_RANGINGRESULTSFREEZE 0x097F /*! * \brief The address of the register holding the first byte of ranging calibration * * \remark Only used for packet type Ranging */ #define REG_LR_RANGINGRERXTXDELAYCAL 0x092C /*! *\brief The address of the register holding the ranging filter window size * * \remark Only used for packet type Ranging */ #define REG_LR_RANGINGFILTERWINDOWSIZE 0x091E /*! *\brief The address of the register to reset for clearing ranging filter * * \remark Only used for packet type Ranging */ #define REG_LR_RANGINGRESULTCLEARREG 0x0923 #define REG_RANGING_RSSI 0x0964 /*! * \brief The default number of samples considered in built-in ranging filter */ #define DEFAULT_RANGING_FILTER_SIZE 127 /*! * \brief The address of the register holding LORA packet parameters */ #define REG_LR_PACKETPARAMS 0x903 /*! * \brief The address of the register holding payload length * * \remark Do NOT try to read it directly. Use GetRxBuffer( ) instead. */ #define REG_LR_PAYLOADLENGTH 0x901 /*! * \brief The address of the instruction RAM and its size */ #define IRAM_START_ADDRESS 0x8000 #define IRAM_SIZE 0x4000 /*! * \brief The addresses of the registers holding SyncWords values * * \remark The addresses depends on the Packet Type in use, and not all * SyncWords are available for every Packet Type */ #define REG_LR_SYNCWORDBASEADDRESS1 0x09CE #define REG_LR_SYNCWORDBASEADDRESS2 0x09D3 #define REG_LR_SYNCWORDBASEADDRESS3 0x09D8 /*! * \brief The MSB address and mask used to read the estimated frequency * error */ #define REG_LR_ESTIMATED_FREQUENCY_ERROR_MSB 0x0954 #define REG_LR_ESTIMATED_FREQUENCY_ERROR_MASK 0x0FFFFF /*! * \brief Defines how many bit errors are tolerated in sync word detection */ #define REG_LR_SYNCWORDTOLERANCE 0x09CD /*! * \brief Register for MSB Access Address (BLE) */ #define REG_LR_BLE_ACCESS_ADDRESS 0x09CF #define BLE_ADVERTIZER_ACCESS_ADDRESS 0x8E89BED6 /*! * \brief Register address and mask for LNA regime selection */ #define REG_LNA_REGIME 0x0891 #define MASK_LNA_REGIME 0xC0 /*! * \brief Register and mask enabling manual gain control */ #define REG_ENABLE_MANUAL_GAIN_CONTROL 0x089F #define MASK_MANUAL_GAIN_CONTROL 0x80 /*! * \brief Register and mask controlling demodulation detection */ #define REG_DEMOD_DETECTION 0x0895 #define MASK_DEMOD_DETECTION 0xFE /*! * \brief Register and mask setting manual gain value */ #define REG_MANUAL_GAIN_VALUE 0x089E #define MASK_MANUAL_GAIN_VALUE 0xF0 /*! * \brief Selector values to configure LNA regime */ typedef enum{ LNA_LOW_POWER_MODE, //!< Allow maximum efficiency of sx1280 (default) LNA_HIGH_SENSITIVITY_MODE, //!< Allow to use highest three steps of LNA gain and increase current consumption }RadioLnaSettings_t; /*! * \brief Structure describing the radio status */ typedef union { /*! * \brief Structure of the radio status */ struct { uint8_t CpuBusy : 1; //!< Flag for CPU radio busy uint8_t DmaBusy : 1; //!< Flag for DMA busy uint8_t CmdStatus : 3; //!< Command status uint8_t ChipMode : 3; //!< Chip mode }Fields; /*! * \brief Serialized radio status */ uint8_t Value; }RadioStatus_t; /*! * \brief Represents the states of the radio */ typedef enum { RF_IDLE = 0x00, //!< The radio is idle RF_RX_RUNNING, //!< The radio is in reception state RF_TX_RUNNING, //!< The radio is in transmission state RF_CAD, //!< The radio is doing channel activity detection }RadioStates_t; /*! * \brief Represents the operating mode the radio is actually running */ typedef enum { MODE_SLEEP = 0x00, //! The radio is in sleep mode MODE_STDBY_RC, //! The radio is in standby mode with RC oscillator MODE_STDBY_XOSC, //! The radio is in standby mode with XOSC oscillator MODE_FS, //! The radio is in frequency synthesis mode MODE_TX, //! The radio is in transmit mode MODE_RX, //! The radio is in receive mode MODE_CAD //! The radio is in channel activity detection mode }RadioOperatingModes_t; /*! * \brief Declares the oscillator in use while in standby mode * * Using the STDBY_RC standby mode allow to reduce the energy consumption * STDBY_XOSC should be used for time critical applications */ typedef enum { STDBY_RC = 0x00, STDBY_XOSC = 0x01, }RadioStandbyModes_t; /*! * \brief Declares the power regulation used to power the device * * This command allows the user to specify if DC-DC or LDO is used for power regulation. * Using only LDO implies that the Rx or Tx current is doubled */ typedef enum { USE_LDO = 0x00, //! Use LDO (default value) USE_DCDC = 0x01, //! Use DCDC }RadioRegulatorModes_t; /*! * \brief Represents the possible packet type (i.e. modem) used */ typedef enum { PACKET_TYPE_GFSK = 0x00, PACKET_TYPE_LORA, PACKET_TYPE_RANGING, PACKET_TYPE_FLRC, PACKET_TYPE_BLE, PACKET_TYPE_NONE = 0x0F, }RadioPacketTypes_t; /*! * \brief Represents the ramping time for power amplifier */ typedef enum { RADIO_RAMP_02_US = 0x00, RADIO_RAMP_04_US = 0x20, RADIO_RAMP_06_US = 0x40, RADIO_RAMP_08_US = 0x60, RADIO_RAMP_10_US = 0x80, RADIO_RAMP_12_US = 0xA0, RADIO_RAMP_16_US = 0xC0, RADIO_RAMP_20_US = 0xE0, }RadioRampTimes_t; /*! * \brief Represents the number of symbols to be used for channel activity detection operation */ typedef enum { LORA_CAD_01_SYMBOL = 0x00, LORA_CAD_02_SYMBOL = 0x20, LORA_CAD_04_SYMBOL = 0x40, LORA_CAD_08_SYMBOL = 0x60, LORA_CAD_16_SYMBOL = 0x80, }RadioLoRaCadSymbols_t; /*! * \brief Represents the possible combinations of bitrate and bandwidth for * GFSK and BLE packet types * * The bitrate is expressed in Mb/s and the bandwidth in MHz */ typedef enum { GFSK_BLE_BR_2_000_BW_2_4 = 0x04, GFSK_BLE_BR_1_600_BW_2_4 = 0x28, GFSK_BLE_BR_1_000_BW_2_4 = 0x4C, GFSK_BLE_BR_1_000_BW_1_2 = 0x45, GFSK_BLE_BR_0_800_BW_2_4 = 0x70, GFSK_BLE_BR_0_800_BW_1_2 = 0x69, GFSK_BLE_BR_0_500_BW_1_2 = 0x8D, GFSK_BLE_BR_0_500_BW_0_6 = 0x86, GFSK_BLE_BR_0_400_BW_1_2 = 0xB1, GFSK_BLE_BR_0_400_BW_0_6 = 0xAA, GFSK_BLE_BR_0_250_BW_0_6 = 0xCE, GFSK_BLE_BR_0_250_BW_0_3 = 0xC7, GFSK_BLE_BR_0_125_BW_0_3 = 0xEF, }RadioGfskBleBitrates_t; /*! * \brief Represents the modulation index used in GFSK and BLE packet * types */ typedef enum { GFSK_BLE_MOD_IND_0_35 = 0, GFSK_BLE_MOD_IND_0_50 = 1, GFSK_BLE_MOD_IND_0_75 = 2, GFSK_BLE_MOD_IND_1_00 = 3, GFSK_BLE_MOD_IND_1_25 = 4, GFSK_BLE_MOD_IND_1_50 = 5, GFSK_BLE_MOD_IND_1_75 = 6, GFSK_BLE_MOD_IND_2_00 = 7, GFSK_BLE_MOD_IND_2_25 = 8, GFSK_BLE_MOD_IND_2_50 = 9, GFSK_BLE_MOD_IND_2_75 = 10, GFSK_BLE_MOD_IND_3_00 = 11, GFSK_BLE_MOD_IND_3_25 = 12, GFSK_BLE_MOD_IND_3_50 = 13, GFSK_BLE_MOD_IND_3_75 = 14, GFSK_BLE_MOD_IND_4_00 = 15, }RadioGfskBleModIndexes_t; /*! * \brief Represents the possible combination of bitrate and bandwidth for FLRC * packet type * * The bitrate is in Mb/s and the bitrate in MHz */ typedef enum { FLRC_BR_2_600_BW_2_4 = 0x04, FLRC_BR_2_080_BW_2_4 = 0x28, FLRC_BR_1_300_BW_1_2 = 0x45, FLRC_BR_1_040_BW_1_2 = 0x69, FLRC_BR_0_650_BW_0_6 = 0x86, FLRC_BR_0_520_BW_0_6 = 0xAA, FLRC_BR_0_325_BW_0_3 = 0xC7, FLRC_BR_0_260_BW_0_3 = 0xEB, }RadioFlrcBitrates_t; /*! * \brief Represents the possible values for coding rate parameter in FLRC * packet type */ typedef enum { FLRC_CR_1_2 = 0x00, FLRC_CR_3_4 = 0x02, FLRC_CR_1_0 = 0x04, }RadioFlrcCodingRates_t; /*! * \brief Represents the modulation shaping parameter for GFSK, FLRC and BLE * packet types */ typedef enum { RADIO_MOD_SHAPING_BT_OFF = 0x00, //! No filtering RADIO_MOD_SHAPING_BT_1_0 = 0x10, RADIO_MOD_SHAPING_BT_0_5 = 0x20, }RadioModShapings_t; /*! * \brief Represents the possible spreading factor values in LORA packet types */ typedef enum { LORA_SF5 = 0x50, LORA_SF6 = 0x60, LORA_SF7 = 0x70, LORA_SF8 = 0x80, LORA_SF9 = 0x90, LORA_SF10 = 0xA0, LORA_SF11 = 0xB0, LORA_SF12 = 0xC0, }RadioLoRaSpreadingFactors_t; /*! * \brief Represents the bandwidth values for LORA packet type */ typedef enum { LORA_BW_0200 = 0x34, LORA_BW_0400 = 0x26, LORA_BW_0800 = 0x18, LORA_BW_1600 = 0x0A, }RadioLoRaBandwidths_t; /*! * \brief Represents the coding rate values for LORA packet type */ typedef enum { LORA_CR_4_5 = 0x01, LORA_CR_4_6 = 0x02, LORA_CR_4_7 = 0x03, LORA_CR_4_8 = 0x04, LORA_CR_LI_4_5 = 0x05, LORA_CR_LI_4_6 = 0x06, LORA_CR_LI_4_7 = 0x07, }RadioLoRaCodingRates_t; /*! * \brief Represents the preamble length values for GFSK and FLRC packet * types * 编码率（Coding Rate, CR） 是一个关键参数， * 用于确定数据传输中的前向纠错能力（Forward Error Correction, FEC）。 * 编码率直接影响数据的可靠性和冗余性，是在低功耗广域网（LPWAN）应用中平衡通信可靠性和效率的重要因素。 */ typedef enum { PREAMBLE_LENGTH_04_BITS = 0x00, //!< Preamble length: 04 bits PREAMBLE_LENGTH_08_BITS = 0x10, //!< Preamble length: 08 bits PREAMBLE_LENGTH_12_BITS = 0x20, //!< Preamble length: 12 bits PREAMBLE_LENGTH_16_BITS = 0x30, //!< Preamble length: 16 bits PREAMBLE_LENGTH_20_BITS = 0x40, //!< Preamble length: 20 bits PREAMBLE_LENGTH_24_BITS = 0x50, //!< Preamble length: 24 bits PREAMBLE_LENGTH_28_BITS = 0x60, //!< Preamble length: 28 bits PREAMBLE_LENGTH_32_BITS = 0x70, //!< Preamble length: 32 bits }RadioPreambleLengths_t; /*! * \brief Represents the SyncWord length for FLRC packet type */ typedef enum { FLRC_NO_SYNCWORD = 0x00, FLRC_SYNCWORD_LENGTH_4_BYTE = 0x04, }RadioFlrcSyncWordLengths_t; /*! * \brief The length of sync words for GFSK packet type */ typedef enum { GFSK_SYNCWORD_LENGTH_1_BYTE = 0x00, //!< Sync word length: 1 byte GFSK_SYNCWORD_LENGTH_2_BYTE = 0x02, //!< Sync word length: 2 bytes GFSK_SYNCWORD_LENGTH_3_BYTE = 0x04, //!< Sync word length: 3 bytes GFSK_SYNCWORD_LENGTH_4_BYTE = 0x06, //!< Sync word length: 4 bytes GFSK_SYNCWORD_LENGTH_5_BYTE = 0x08, //!< Sync word length: 5 bytes }RadioSyncWordLengths_t; /*! * \brief Represents the possible combinations of SyncWord correlators * activated for GFSK and FLRC packet types */ typedef enum { RADIO_RX_MATCH_SYNCWORD_OFF = 0x00, //!< No correlator turned on, i.e. do not search for SyncWord RADIO_RX_MATCH_SYNCWORD_1 = 0x10, RADIO_RX_MATCH_SYNCWORD_2 = 0x20, RADIO_RX_MATCH_SYNCWORD_1_2 = 0x30, RADIO_RX_MATCH_SYNCWORD_3 = 0x40, RADIO_RX_MATCH_SYNCWORD_1_3 = 0x50, RADIO_RX_MATCH_SYNCWORD_2_3 = 0x60, RADIO_RX_MATCH_SYNCWORD_1_2_3 = 0x70, }RadioSyncWordRxMatchs_t; /*! * \brief Radio packet length mode for GFSK and FLRC packet types */ typedef enum { RADIO_PACKET_FIXED_LENGTH = 0x00, //!< The packet is known on both sides, no header included in the packet RADIO_PACKET_VARIABLE_LENGTH = 0x20, //!< The packet is on variable size, header included }RadioPacketLengthModes_t; /*! * \brief Represents the CRC length for GFSK and FLRC packet types * * \warning Not all configurations are available for both GFSK and FLRC * packet type. Refer to the datasheet for possible configuration. */ typedef enum { RADIO_CRC_OFF = 0x00, //!< No CRC in use RADIO_CRC_1_BYTES = 0x10, RADIO_CRC_2_BYTES = 0x20, RADIO_CRC_3_BYTES = 0x30, }RadioCrcTypes_t; /*! * \brief Radio whitening mode activated or deactivated for GFSK, FLRC and * BLE packet types */ typedef enum { RADIO_WHITENING_ON = 0x00, RADIO_WHITENING_OFF = 0x08, }RadioWhiteningModes_t; /*! * \brief Holds the packet length mode of a LORA packet type */ typedef enum { LORA_PACKET_VARIABLE_LENGTH = 0x00, //!< The packet is on variable size, header included LORA_PACKET_FIXED_LENGTH = 0x80, //!< The packet is known on both sides, no header included in the packet LORA_PACKET_EXPLICIT = LORA_PACKET_VARIABLE_LENGTH, LORA_PACKET_IMPLICIT = LORA_PACKET_FIXED_LENGTH, }RadioLoRaPacketLengthsModes_t; /*! * \brief Represents the CRC mode for LORA packet type */ typedef enum { LORA_CRC_ON = 0x20, //!< CRC activated LORA_CRC_OFF = 0x00, //!< CRC not used }RadioLoRaCrcModes_t; /*! * \brief Represents the IQ mode for LORA packet type */ typedef enum { LORA_IQ_NORMAL = 0x40, LORA_IQ_INVERTED = 0x00, }RadioLoRaIQModes_t; /*! * \brief Represents the length of the ID to check in ranging operation */ typedef enum { RANGING_IDCHECK_LENGTH_08_BITS = 0x00, RANGING_IDCHECK_LENGTH_16_BITS, RANGING_IDCHECK_LENGTH_24_BITS, RANGING_IDCHECK_LENGTH_32_BITS, }RadioRangingIdCheckLengths_t; /*! * \brief Represents the result type to be used in ranging operation */ typedef enum { RANGING_RESULT_RAW = 0x00, RANGING_RESULT_AVERAGED = 0x01, RANGING_RESULT_DEBIASED = 0x02, RANGING_RESULT_FILTERED = 0x03, }RadioRangingResultTypes_t; /*! * \brief Represents the connection state for BLE packet type */ typedef enum { BLE_PAYLOAD_LENGTH_MAX_31_BYTES = 0x00, BLE_PAYLOAD_LENGTH_MAX_37_BYTES = 0x20, BLE_TX_TEST_MODE = 0x40, BLE_PAYLOAD_LENGTH_MAX_255_BYTES = 0x80, }RadioBleConnectionStates_t; /*! * \brief Represents the CRC field length for BLE packet type */ typedef enum { BLE_CRC_OFF = 0x00, BLE_CRC_3B = 0x10, }RadioBleCrcFields_t; /*! * \brief Represents the specific packets to use in BLE packet type */ typedef enum { BLE_PRBS_9 = 0x00, //!< Pseudo Random Binary Sequence based on 9th degree polynomial BLE_PRBS_15 = 0x0C, //!< Pseudo Random Binary Sequence based on 15th degree polynomial BLE_EYELONG_1_0 = 0x04, //!< Repeated '11110000' sequence BLE_EYELONG_0_1 = 0x18, //!< Repeated '00001111' sequence BLE_EYESHORT_1_0 = 0x08, //!< Repeated '10101010' sequence BLE_EYESHORT_0_1 = 0x1C, //!< Repeated '01010101' sequence BLE_ALL_1 = 0x10, //!< Repeated '11111111' sequence BLE_ALL_0 = 0x14, //!< Repeated '00000000' sequence }RadioBlePacketTypes_t; /*! * \brief Represents the interruption masks available for the radio * * \remark Note that not all these interruptions are available for all packet types */ typedef enum { IRQ_RADIO_NONE = 0x0000, IRQ_TX_DONE = 0x0001, IRQ_RX_DONE = 0x0002, IRQ_SYNCWORD_VALID = 0x0004, IRQ_SYNCWORD_ERROR = 0x0008, IRQ_HEADER_VALID = 0x0010, IRQ_HEADER_ERROR = 0x0020, IRQ_CRC_ERROR = 0x0040, IRQ_RANGING_SLAVE_RESPONSE_DONE = 0x0080, IRQ_RANGING_SLAVE_REQUEST_DISCARDED = 0x0100, IRQ_RANGING_MASTER_RESULT_VALID = 0x0200, IRQ_RANGING_MASTER_RESULT_TIMEOUT = 0x0400, IRQ_RANGING_SLAVE_REQUEST_VALID = 0x0800, IRQ_CAD_DONE = 0x1000, IRQ_CAD_ACTIVITY_DETECTED = 0x2000, IRQ_RX_TX_TIMEOUT = 0x4000, IRQ_PREAMBLE_DETECTED = 0x8000, IRQ_RADIO_ALL = 0xFFFF, }RadioIrqMasks_t; /*! * \brief Represents the digital input/output of the radio */ typedef enum { RADIO_DIO1 = 0x02, RADIO_DIO2 = 0x04, RADIO_DIO3 = 0x08, }RadioDios_t; /*! * \brief Represents the tick size available for Rx/Tx timeout operations */ typedef enum { RADIO_TICK_SIZE_0015_US = 0x00, RADIO_TICK_SIZE_0062_US = 0x01, RADIO_TICK_SIZE_1000_US = 0x02, RADIO_TICK_SIZE_4000_US = 0x03, }RadioTickSizes_t; /*! * \brief Represents the role of the radio during ranging operations */ typedef enum { RADIO_RANGING_ROLE_SLAVE = 0x00, RADIO_RANGING_ROLE_MASTER = 0x01, }RadioRangingRoles_t; /*! * \brief Represents all possible opcode understood by the radio ? */ typedef enum RadioCommands_u { RADIO_GET_STATUS = 0xC0, RADIO_WRITE_REGISTER = 0x18, RADIO_READ_REGISTER = 0x19, RADIO_WRITE_BUFFER = 0x1A, RADIO_READ_BUFFER = 0x1B, 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 = 0x03, RADIO_SET_RFFREQUENCY = 0x86, RADIO_SET_TXPARAMS = 0x8E, RADIO_SET_CADPARAMS = 0x88, RADIO_SET_BUFFERBASEADDRESS = 0x8F, RADIO_SET_MODULATIONPARAMS = 0x8B, RADIO_SET_PACKETPARAMS = 0x8C, RADIO_GET_RXBUFFERSTATUS = 0x17, RADIO_GET_PACKETSTATUS = 0x1D, RADIO_GET_RSSIINST = 0x1F, RADIO_SET_DIOIRQPARAMS = 0x8D, RADIO_GET_IRQSTATUS = 0x15, RADIO_CLR_IRQSTATUS = 0x97, RADIO_CALIBRATE = 0x89, RADIO_SET_REGULATORMODE = 0x96, RADIO_SET_SAVECONTEXT = 0xD5, RADIO_SET_AUTOTX = 0x98, RADIO_SET_AUTOFS = 0x9E, RADIO_SET_LONGPREAMBLE = 0x9B, RADIO_SET_UARTSPEED = 0x9D, RADIO_SET_RANGING_ROLE = 0xA3, }RadioCommands_t; /*! * \brief Represents an amount of time measurable by the radio clock * * @code * Time = Step * NbSteps * Example: * Step = RADIO_TICK_SIZE_4000_US( 4 ms ) * NbSteps = 1000 * Time = 4e-3 * 1000 = 4 seconds * @endcode */ typedef struct TickTime_s { RadioTickSizes_t Step; //!< The step of ticktime /*! * \brief The number of steps for ticktime * Special values are: * - 0x0000 for single mode * - 0xFFFF for continuous mode */ uint16_t NbSteps; }TickTime_t; /*! * \brief RX_TX_CONTINUOUS and RX_TX_SINGLE are two particular values for TickTime. * The former keep the radio in Rx or Tx mode, even after successfull reception * or transmission. It should never generate Timeout interrupt. * The later let the radio enought time to make one reception or transmission. * No Timeout interrupt is generated, and the radio fall in StandBy mode after * reception or transmission. */ #define RX_TX_CONTINUOUS ( TickTime_t ){ RADIO_TICK_SIZE_0015_US, 0xFFFF } #define RX_TX_SINGLE ( TickTime_t ){ RADIO_TICK_SIZE_0015_US, 0 } /*! * \brief The type describing the modulation parameters for every packet types 描述每种数据包类型的调制参数的类型 */ typedef struct { RadioPacketTypes_t PacketType; //!< Packet to which the modulation parameters are referring to.调制参数所指的分组 // union struct { /*! * \brief Holds the GFSK modulation parameters * * In GFSK modulation, the bit-rate and bandwidth are linked together. In this structure, its values are set using the same token. */ struct { RadioGfskBleBitrates_t BitrateBandwidth; //!< The bandwidth and bit-rate values for BLE and GFSK modulations RadioGfskBleModIndexes_t ModulationIndex; //!< The coding rate for BLE and GFSK modulations RadioModShapings_t ModulationShaping; //!< The modulation shaping for BLE and GFSK modulations }Gfsk; /*! * \brief Holds the LORA modulation parameters * * LORA modulation is defined by Spreading Factor (SF), Bandwidth and Coding Rate */ struct { RadioLoRaSpreadingFactors_t SpreadingFactor; //!< Spreading Factor for the LORA modulation LORA调制的扩频因子 RadioLoRaBandwidths_t Bandwidth; //!< Bandwidth for the LORA modulation 带宽 RadioLoRaCodingRates_t CodingRate; //!< Coding rate for the LORA modulation 编码率 }LoRa; /*! * \brief Holds the FLRC modulation parameters * * In FLRC modulation, the bit-rate and bandwidth are linked together. In this structure, its values are set using the same token. */ struct { RadioFlrcBitrates_t BitrateBandwidth; //!< The bandwidth and bit-rate values for FLRC modulation RadioFlrcCodingRates_t CodingRate; //!< The coding rate for FLRC modulation RadioModShapings_t ModulationShaping; //!< The modulation shaping for FLRC modulation }Flrc; /*! * \brief Holds the BLE modulation parameters * * In BLE modulation, the bit-rate and bandwidth are linked together. In this structure, its values are set using the same token. */ struct { RadioGfskBleBitrates_t BitrateBandwidth; //!< The bandwidth and bit-rate values for BLE and GFSK modulations RadioGfskBleModIndexes_t ModulationIndex; //!< The coding rate for BLE and GFSK modulations RadioModShapings_t ModulationShaping; //!< The modulation shaping for BLE and GFSK modulations }Ble; }Params; //!< Holds the modulation parameters structure }ModulationParams_t; /*! * \brief Structure describing the error codes for callback functions */ typedef enum { IRQ_HEADER_ERROR_CODE = 0x00, IRQ_SYNCWORD_ERROR_CODE, IRQ_CRC_ERROR_CODE, IRQ_RANGING_ON_LORA_ERROR_CODE, }IrqErrorCode_t; /*! * \brief Structure describing the ranging codes for callback functions */ typedef enum { IRQ_RANGING_SLAVE_ERROR_CODE = 0x00, IRQ_RANGING_SLAVE_VALID_CODE, IRQ_RANGING_MASTER_ERROR_CODE, IRQ_RANGING_MASTER_VALID_CODE, }IrqRangingCode_t; /*! * \brief The radio callbacks structure * Holds function pointers to be called on radio interrupts */ typedef struct { void ( *txDone )( void ); //!< Pointer to a function run on successful transmission void ( *rxDone )( void ); //!< Pointer to a function run on successful reception void ( *rxSyncWordDone )( void ); //!< Pointer to a function run on successful SyncWord reception void ( *rxHeaderDone )( void ); //!< Pointer to a function run on successful Header reception void ( *txTimeout )( void ); //!< Pointer to a function run on transmission timeout void ( *rxTimeout )( void ); //!< Pointer to a function run on reception timeout void ( *rxError )( IrqErrorCode_t errCode ); //!< Pointer to a function run on reception error void ( *rangingDone )( IrqRangingCode_t val ); //!< Pointer to a function run on ranging terminated void ( *cadDone )( bool cadFlag ); //!< Pointer to a function run on channel activity detected }RadioCallbacks_t; /*! * \brief The type describing the packet parameters for every packet types */ typedef struct { RadioPacketTypes_t PacketType; //!< Packet to which the packet parameters are referring to. // union struct { /*! * \brief Holds the GFSK packet parameters */ struct { RadioPreambleLengths_t PreambleLength; //!< The preamble length for GFSK packet type RadioSyncWordLengths_t SyncWordLength; //!< The synchronization word length for GFSK packet type RadioSyncWordRxMatchs_t SyncWordMatch; //!< The synchronization correlator to use to check synchronization word RadioPacketLengthModes_t HeaderType; //!< If the header is explicit, it will be transmitted in the GFSK packet. If the header is implicit, it will not be transmitted uint8_t PayloadLength; //!< Size of the payload in the GFSK packet RadioCrcTypes_t CrcLength; //!< Size of the CRC block in the GFSK packet RadioWhiteningModes_t Whitening; //!< Usage of whitening on payload and CRC blocks plus header block if header type is variable }Gfsk; /*! * \brief Holds the LORA packet parameters */ struct { uint8_t PreambleLength; //!< The preamble length is the number of LORA symbols in the preamble. To set it, use the following formula @code Number of symbols = PreambleLength[3:0] * ( 2^PreambleLength[7:4] ) @endcode RadioLoRaPacketLengthsModes_t HeaderType; //!< If the header is explicit, it will be transmitted in the LORA packet. If the header is implicit, it will not be transmitted uint8_t PayloadLength; //!< Size of the payload in the LORA packet RadioLoRaCrcModes_t CrcMode; //!< Size of CRC block in LORA packet RadioLoRaIQModes_t InvertIQ; //!< Allows to swap IQ for LORA packet }LoRa; /*! * \brief Holds the FLRC packet parameters */ struct { RadioPreambleLengths_t PreambleLength; //!< The preamble length for FLRC packet type RadioFlrcSyncWordLengths_t SyncWordLength; //!< The synchronization word length for FLRC packet type RadioSyncWordRxMatchs_t SyncWordMatch; //!< The synchronization correlator to use to check synchronization word RadioPacketLengthModes_t HeaderType; //!< If the header is explicit, it will be transmitted in the FLRC packet. If the header is implicit, it will not be transmitted. uint8_t PayloadLength; //!< Size of the payload in the FLRC packet RadioCrcTypes_t CrcLength; //!< Size of the CRC block in the FLRC packet RadioWhiteningModes_t Whitening; //!< Usage of whitening on payload and CRC blocks plus header block if header type is variable }Flrc; /*! * \brief Holds the BLE packet parameters */ struct { RadioBleConnectionStates_t ConnectionState; //!< The BLE state RadioBleCrcFields_t CrcField; //!< Size of the CRC block in the BLE packet RadioBlePacketTypes_t BlePacketType; //!< Special BLE packet types RadioWhiteningModes_t Whitening; //!< Usage of whitening on PDU and CRC blocks of BLE packet }Ble; }Params; //!< Holds the packet parameters structure }PacketParams_t; /*! * \brief Represents the packet status for every packet type */ typedef struct { RadioPacketTypes_t packetType; //!< Packet to which the packet status are referring to. union { struct { int8_t RssiAvg; //!< The averaged RSSI int8_t RssiSync; //!< The RSSI measured on last packet struct { bool SyncError :1; //!< SyncWord error on last packet bool LengthError :1; //!< Length error on last packet bool CrcError :1; //!< CRC error on last packet bool AbortError :1; //!< Abort error on last packet bool HeaderReceived :1; //!< Header received on last packet bool PacketReceived :1; //!< Packet received bool PacketControlerBusy :1; //!< Packet controller busy }ErrorStatus; //!< The error status Byte struct { bool RxNoAck :1; //!< No acknowledgment received for Rx with variable length packets bool PacketSent :1; //!< Packet sent, only relevant in Tx mode }TxRxStatus; //!< The Tx/Rx status Byte uint8_t SyncAddrStatus :3; //!< The id of the correlator who found the packet }Gfsk; struct { int8_t RssiPkt; //!< The RSSI of the last packet int8_t SnrPkt; //!< The SNR of the last packet struct { bool SyncError :1; //!< SyncWord error on last packet bool LengthError :1; //!< Length error on last packet bool CrcError :1; //!< CRC error on last packet bool AbortError :1; //!< Abort error on last packet bool HeaderReceived :1; //!< Header received on last packet bool PacketReceived :1; //!< Packet received bool PacketControlerBusy :1; //!< Packet controller busy }ErrorStatus; //!< The error status Byte struct { bool RxNoAck :1; //!< No acknowledgment received for Rx with variable length packets bool PacketSent :1; //!< Packet sent, only relevant in Tx mode }TxRxStatus; //!< The Tx/Rx status Byte uint8_t SyncAddrStatus :3; //!< The id of the correlator who found the packet }LoRa; struct { int8_t RssiAvg; //!< The averaged RSSI int8_t RssiSync; //!< The RSSI of the last packet struct { bool SyncError :1; //!< SyncWord error on last packet bool LengthError :1; //!< Length error on last packet bool CrcError :1; //!< CRC error on last packet bool AbortError :1; //!< Abort error on last packet bool HeaderReceived :1; //!< Header received on last packet bool PacketReceived :1; //!< Packet received bool PacketControlerBusy :1; //!< Packet controller busy }ErrorStatus; //!< The error status Byte struct { uint8_t RxPid :2; //!< PID of the Rx bool RxNoAck :1; //!< No acknowledgment received for Rx with variable length packets bool RxPidErr :1; //!< Received PID error bool PacketSent :1; //!< Packet sent, only relevant in Tx mode }TxRxStatus; //!< The Tx/Rx status Byte uint8_t SyncAddrStatus :3; //!< The id of the correlator who found the packet }Flrc; struct { int8_t RssiAvg; //!< The averaged RSSI int8_t RssiSync; //!< The RSSI of the last packet struct { bool SyncError :1; //!< SyncWord error on last packet bool LengthError :1; //!< Length error on last packet bool CrcError :1; //!< CRC error on last packet bool AbortError :1; //!< Abort error on last packet bool HeaderReceived :1; //!< Header received on last packet bool PacketReceived :1; //!< Packet received bool PacketControlerBusy :1; //!< Packet controller busy }ErrorStatus; //!< The error status Byte struct { bool PacketSent :1; //!< Packet sent, only relevant in Tx mode }TxRxStatus; //!< The Tx/Rx status Byte uint8_t SyncAddrStatus :3; //!< The id of the correlator who found the packet }Ble; }Params; }PacketStatus_t; /*! * \brief Represents the Rx internal counters values when GFSK or LORA packet type is used */ typedef struct { RadioPacketTypes_t packetType; //!< Packet to which the packet status are referring to. union { struct { uint16_t PacketReceived; //!< Number of received packets uint16_t CrcError; //!< Number of CRC errors uint16_t LengthError; //!< Number of length errors uint16_t SyncwordError; //!< Number of sync-word errors }Gfsk; struct { uint16_t PacketReceived; //!< Number of received packets uint16_t CrcError; //!< Number of CRC errors uint16_t HeaderValid; //!< Number of valid headers }LoRa; }Params; }RxCounter_t; /*! * \brief Represents a calibration configuration */ typedef struct { uint8_t RC64KEnable : 1; //!< Calibrate RC64K clock uint8_t RC13MEnable : 1; //!< Calibrate RC13M clock uint8_t PLLEnable : 1; //!< Calibrate PLL uint8_t ADCPulseEnable : 1; //!< Calibrate ADC Pulse uint8_t ADCBulkNEnable : 1; //!< Calibrate ADC bulkN uint8_t ADCBulkPEnable : 1; //!< Calibrate ADC bulkP }CalibrationParams_t; /*! * \brief Represents a sleep mode configuration */ typedef struct { uint8_t WakeUpRTC : 1; //!< Get out of sleep mode if wakeup signal received from RTC uint8_t InstructionRamRetention : 1; //!< InstructionRam is conserved during sleep uint8_t DataBufferRetention : 1; //!< Data buffer is conserved during sleep uint8_t DataRamRetention : 1; //!< Data ram is conserved during sleep }SleepParams_t; /*! * \brief Compute the two's complement for a register of size lower than * 32bits * * \param [in] num The register to be two's complemented * \param [in] bitCnt The position of the sign bit */ //static int32_t SX1280complement2( const uint32_t num, const uint8_t bitCnt ); /*! * \brief Returns the value of LoRa bandwidth from driver's value * * The value is returned in Hz so that it can be represented as an integer * type. Most computation should be done as integer to reduce floating * point related errors. * * \retval loRaBw The value of the current bandwidth in Hz */ int32_t SX1280GetLoRaBandwidth( void ); /*! * \brief Returns the corrected raw value of ranging * * \retval correction Corrected ranging raw value */ double SX1280GetRangingCorrectionPerSfBwGain( const RadioLoRaSpreadingFactors_t sf, const RadioLoRaBandwidths_t bw, const int8_t gain); /*! * \brief Returns the short range corrected distance * * \retval Corrected Distance corrected ditance */ double SX1280ComputeRangingCorrectionPolynome(const RadioLoRaSpreadingFactors_t sf, const RadioLoRaBandwidths_t bw, const double median); /*! * \brief DIOs interrupt callback * * \remark Called to handle all 3 DIOs pins */ void SX1280OnDioIrq( void ); /*! * \brief Set the role of the radio during ranging operations * * \param [in] role Role of the radio */ void SX1280SetRangingRole( RadioRangingRoles_t role ); /*! * \brief Initializes the radio driver */ void SX1280Init( RadioCallbacks_t *callbacks ); /*! * \brief Set the driver in polling mode. * * In polling mode the application is responsible to call ProcessIrqs( ) to * execute callbacks functions. * The default mode is Interrupt Mode. * @code * // Initializations and callbacks declaration/definition * radio = SX1280( mosi, miso, sclk, nss, busy, int1, int2, int3, rst, &callbacks ); * radio.Init( ); * radio.SetPollingMode( ); * * while( true ) * { * // IRQ processing is automatically done * radio.ProcessIrqs( ); // <-- here, as well as callback functions * // calls * // Do some applicative work * } * @endcode * * \see SX1280SetInterruptMode */ void SX1280SetPollingMode( void ); /*! * \brief Set the driver in interrupt mode. * * In interrupt mode, the driver communicate with the radio during the * interruption by direct calls to ProcessIrqs( ). The main advantage is * the possibility to have low power application architecture. * This is the default mode. * @code * // Initializations and callbacks declaration/definition * radio = SX1280( mosi, miso, sclk, nss, busy, int1, int2, int3, rst, &callbacks ); * radio.Init( ); * radio.SetInterruptMode( ); // Optionnal. Driver default behavior * * while( true ) * { * // Do some applicative work * } * @endcode * * \see SX1280SetPollingMode */ void SX1280SetInterruptMode( void ); /*! * \brief Initializes the radio registers to the recommended default values */ void SX1280SetRegistersDefault( void ); /*! * \brief Returns the current device firmware version * * \retval version Firmware version */ uint16_t SX1280GetFirmwareVersion( void ); /*! * \brief Gets the current Operation Mode of the Radio * * \retval RadioOperatingModes_t last operating mode */ RadioOperatingModes_t SX1280GetOpMode( void ); /*! * \brief Gets the current radio status * * \retval status Radio status */ RadioStatus_t SX1280GetStatus( void ); /*! * \brief Sets the radio in sleep mode * * \param [in] sleepConfig The sleep configuration describing data * retention and RTC wake-up */ void SX1280SetSleep( SleepParams_t sleepConfig ); /*! * \brief Sets the radio in configuration mode * * \param [in] mode The standby mode to put the radio into */ void SX1280SetStandby( RadioStandbyModes_t mode ); /*! * \brief Sets the radio in FS mode */ void SX1280SetFs( void ); /*! * \brief Sets the radio in transmission mode * * \param [in] timeout Structure describing the transmission timeout value */ void SX1280SetTx( TickTime_t timeout ); /*! * \brief Sets the radio in reception mode * * \param [in] timeout Structure describing the reception timeout value */ void SX1280SetRx( TickTime_t timeout ); /*! * \brief Sets the Rx duty cycle management parameters * * \param [in] rxTime Structure describing reception timeout value * \param [in] sleepTime Structure describing sleep timeout value */ void SX1280SetRxDutyCycle( RadioTickSizes_t Step, uint16_t NbStepRx, uint16_t RxNbStepSleep ); /*! * \brief Sets the radio in CAD mode * * \see SX1280::SetCadParams */ void SX1280SetCad( void ); /*! * \brief Sets the radio in continuous wave transmission mode */ void SX1280SetTxContinuousWave( void ); /*! * \brief Sets the radio in continuous preamble transmission mode */ void SX1280SetTxContinuousPreamble( void ); /*! * \brief Sets the radio for the given protocol * * \param [in] packetType [PACKET_TYPE_GFSK, PACKET_TYPE_LORA, * PACKET_TYPE_RANGING, PACKET_TYPE_FLRC, * PACKET_TYPE_BLE] * * \remark This method has to be called before SetRfFrequency, * SetModulationParams and SetPacketParams */ void SX1280SetPacketType( RadioPacketTypes_t packetType ); /*! * \brief Gets the current radio protocol * * \retval packetType [PACKET_TYPE_GFSK, PACKET_TYPE_LORA, * PACKET_TYPE_RANGING, PACKET_TYPE_FLRC, * PACKET_TYPE_BLE, PACKET_TYPE_NONE] */ RadioPacketTypes_t SX1280GetPacketType( void ); /*! * \brief Sets the RF frequency * * \param [in] frequency RF frequency [Hz] */ void SX1280SetRfFrequency( uint32_t frequency ); /*! * \brief Sets the transmission parameters * * \param [in] power RF output power [-18..13] dBm * \param [in] rampTime Transmission ramp up time */ void SX1280SetTxParams( int8_t power, RadioRampTimes_t rampTime ); /*! * \brief Sets the number of symbols to be used for Channel Activity * Detection operation * * \param [in] cadSymbolNum The number of symbol to use for Channel Activity * Detection operations [LORA_CAD_01_SYMBOL, LORA_CAD_02_SYMBOL, * LORA_CAD_04_SYMBOL, LORA_CAD_08_SYMBOL, LORA_CAD_16_SYMBOL] */ void SX1280SetCadParams( RadioLoRaCadSymbols_t cadSymbolNum ); /*! * \brief Sets the data buffer base address for transmission and reception * * \param [in] txBaseAddress Transmission base address * \param [in] rxBaseAddress Reception base address */ void SX1280SetBufferBaseAddresses( uint8_t txBaseAddress, uint8_t rxBaseAddress ); /*! * \brief Set the modulation parameters * * \param [in] modParams A structure describing the modulation parameters */ void SX1280SetModulationParams( ModulationParams_t *modParams ); /*! * \brief Sets the packet parameters * * \param [in] packetParams A structure describing the packet parameters */ void SX1280SetPacketParams( PacketParams_t *packetParams ); /*! * \brief Gets the last received packet buffer status * * \param [out] payloadLength Last received packet payload length * \param [out] rxStartBuffer Last received packet buffer address pointer */ void SX1280GetRxBufferStatus( uint8_t *payloadLength, uint8_t *rxStartBuffer ); /*! * \brief Gets the last received packet payload length * * \param [out] pktStatus A structure of packet status */ void SX1280GetPacketStatus( PacketStatus_t *pktStatus ); /*! * \brief Returns the instantaneous RSSI value for the last packet received * * \retval rssiInst Instantaneous RSSI */ int8_t SX1280GetRssiInst( void ); /*! * \brief Sets the IRQ mask and DIO masks * * \param [in] irqMask General IRQ mask * \param [in] dio1Mask DIO1 mask * \param [in] dio2Mask DIO2 mask * \param [in] dio3Mask DIO3 mask */ void SX1280SetDioIrqParams( uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask ); /*! * \brief Returns the current IRQ status * * \retval irqStatus IRQ status */ uint16_t SX1280GetIrqStatus( void ); /*! * \brief Clears the IRQs * * \param [in] irq IRQ(s) to be cleared */ void SX1280ClearIrqStatus( uint16_t irq ); /*! * \brief Calibrates the given radio block * * \param [in] calibParam The description of blocks to be calibrated */ void SX1280Calibrate( CalibrationParams_t calibParam ); /*! * \brief Sets the power regulators operating mode * * \param [in] mode [0: LDO, 1:DC_DC] */ void SX1280SetRegulatorMode( RadioRegulatorModes_t mode ); /*! * \brief Saves the current selected modem configuration into data RAM */ void SX1280SetSaveContext( void ); /*! * \brief Sets the chip to automatically send a packet after the end of a packet reception * * \remark The offset is automatically compensated inside the function * * \param [in] time The delay in us after which a Tx is done */ void SX1280SetAutoTx( uint16_t time ); /*! * \brief Stop the chip from automatically sending a packet after the end of a packet reception * if previously activated with SX1280SetAutoTx command * * \see SX1280SetAutoTx */ void SX1280StopAutoTx( void ); /*! * \brief Sets the chip to automatically receive a packet after the end of a packet transmission * * \remark The offset is automatically compensated inside the function * * \param [in] time The delay in us after which a Rx is done */ void SX1280SetAutoFS( uint8_t enable ); /*! * \brief Enables or disables long preamble detection mode * * \param [in] enable [0: Disable, 1: Enable] */ void SX1280SetLongPreamble( uint8_t enable ); /*! * \brief Saves the payload to be send in the radio buffer * * \param [in] payload A pointer to the payload * \param [in] size The size of the payload */ void SX1280SetPayload( uint8_t *payload, uint8_t size ); /*! * \brief Reads the payload received. If the received payload is longer * than maxSize, then the method returns 1 and do not set size and payload. * * \param [out] payload A pointer to a buffer into which the payload will be copied * \param [out] size A pointer to the size of the payload received * \param [in] maxSize The maximal size allowed to copy into the buffer */ uint8_t SX1280GetPayload( uint8_t *payload, uint8_t *size, uint8_t maxSize ); /*! * \brief Sends a payload * * \param [in] payload A pointer to the payload to send * \param [in] size The size of the payload to send * \param [in] timeout The timeout for Tx operation */ void SX1280SendPayload( uint8_t *payload, uint8_t size, TickTime_t timeout ); /*! * \brief Sets the Sync Word given by index used in GFSK, FLRC and BLE protocols * * \remark 5th byte isn't used in FLRC and BLE protocols * * \param [in] syncWordIdx Index of SyncWord to be set [1..3] * \param [in] syncWord SyncWord bytes ( 5 bytes ) * * \retval status [0: OK, 1: NOK] */ uint8_t SX1280SetSyncWord( uint8_t syncWordIdx, uint8_t *syncWord ); /*! * \brief Defines how many error bits are tolerated in sync word detection * * \param [in] errorBits Number of error bits supported to validate the Sync word detection * ( default is 4 bit, minimum is 1 bit ) */ void SX1280SetSyncWordErrorTolerance( uint8_t errorBits ); /*! * \brief Sets the Initial value for the LFSR used for the CRC calculation * * \param [in] seed Initial LFSR value ( 4 bytes ) * */ void SX1280SetCrcSeed( uint16_t seed ); /*! * \brief Set the Access Address field of BLE packet * * \param [in] accessAddress The access address to be used for next BLE packet sent */ void SX1280SetBleAccessAddress( uint32_t accessAddress ); /*! * \brief Set the Access Address for Advertizer BLE packets * * All advertizer BLE packets must use a particular value for Access * Address field. This method sets it. * * \see SX1280::SetBleAccessAddress */ void SX1280SetBleAdvertizerAccessAddress( void ); /*! * \brief Sets the seed used for the CRC calculation * * \param [in] seed The seed value * */ void SX1280SetCrcPolynomial( uint16_t seed ); /*! * \brief Sets the Initial value of the LFSR used for the whitening in GFSK, FLRC and BLE protocols * * \param [in] seed Initial LFSR value */ void SX1280SetWhiteningSeed( uint8_t seed ); /*! * \brief Enable manual gain and disable AGC * * \see SX1280SetManualGainValue, SX1280DisableManualGain */ void SX1280EnableManualGain( void ); /*! * \brief Disable the manual gain control and enable AGC * * \see SX1280EnableManualGain */ void SX1280DisableManualGain( void ); /*! * \brief Set the gain for LNA * * SX1280EnableManualGain must be call before using this function * * \param [in] gain The value of gain to set, refer to datasheet for value meaning * * \see SX1280EnableManualGain, SX1280DisableManualGain */ void SX1280SetManualGainValue( uint8_t gain ); /*! * \brief Configure the LNA regime of operation * * \param [in] lnaSetting The LNA setting. Possible values are * LNA_LOW_POWER_MODE and * LNA_HIGH_SENSITIVITY_MODE */ void SX1280SetLNAGainSetting( const RadioLnaSettings_t lnaSetting ); /*! * \brief Sets the number of bits used to check that ranging request match ranging ID * * \param [in] length [0: 8 bits, 1: 16 bits, * 2: 24 bits, 3: 32 bits] */ void SX1280SetRangingIdLength( RadioRangingIdCheckLengths_t length ); /*! * \brief Sets ranging device id * * \param [in] address Device address */ void SX1280SetDeviceRangingAddress( uint32_t address ); /*! * \brief Sets the device id to ping in a ranging request * * \param [in] address Address of the device to ping */ void SX1280SetRangingRequestAddress( uint32_t address ); /*! * \brief Return the ranging result value * * \param [in] resultType Specifies the type of result. * [0: RAW, 1: Averaged, * 2: De-biased, 3:Filtered] * * \retval ranging The ranging measure filtered according to resultType [m] */ double SX1280GetRangingResult( RadioRangingResultTypes_t resultType ); /*! * \brief Sets the standard processing delay between Master and Slave * * \param [in] cal RxTx delay offset for correcting ranging bias. * * The calibration value reflects the group delay of the radio front end and * must be re-performed for each new SX1280 PCB design. The value is obtained * empirically by either conducted measurement in a known electrical length * coaxial RF cable (where the design is connectorised) or by radiated * measurement, at a known distance, where an antenna is present. * The result of the calibration process is that the SX1280 ranging result * accurately reflects the physical range, the calibration procedure therefore * removes the average timing error from the time-of-flight measurement for a * given design. * * The values are Spreading Factor dependents, and depend also of the board * design. Some typical values are provided in the next table. * * Spreading Factor | Calibration Value * ---------------- | ----------------- * SF5 | 12200 * SF6 | 12200 * SF7 | 12400 * SF8 | 12650 * SF9 | 12940 * SF10 | 13000 * SF11 | 13060 * SF12 | 13120 */ void SX1280SetRangingCalibration( uint16_t cal ); /*! * \brief Return the last ranging result power indicator * * The value returned is not an absolute power measurement. It is * a relative power measurement. * * \retval deltaThreshold A relative power indicator */ uint8_t SX1280GetRangingPowerDeltaThresholdIndicator( void ); /*! * \brief Clears the ranging filter */ void SX1280RangingClearFilterResult( void ); /*! * \brief Set the number of samples considered in the built-in filter * * \param [in] numSample The number of samples to use built-in filter * [8..255] * * \remark Value inferior to 8 will be silently set to 8 */ void SX1280RangingSetFilterNumSamples( uint8_t numSample ); /*! * \brief Return the Estimated Frequency Error in LORA and RANGING operations * * \retval efe The estimated frequency error [Hz] */ double SX1280GetFrequencyError( void ); /*! * \brief Process the analysis of radio IRQs and calls callback functions * depending on radio state */ void SX1280ProcessIrqs( void ); /*! * \brief Clears the instruction RAM */ void SX1280ClearInstructionRam( void ); /*! * \brief Parses 1 HEX file line and writes the content to the instruction memory * * \param [in] line HEX file line string * * \retval status [0: ERROR, 1:OK] */ int8_t SX1280ParseHexFileLine( char* line ); /*! * \brief Gets individual fields for the given HEX file line * * \param [in] line HEX file line string * \param [out] bytes Bytes array to be written to the instruction memory * \param [out] addr Instruction memory address where to write the bytes array * \param [out] num Number of bytes in Bytes array * \param [out] code HEX file line type [0: instruction, 1: end of file, 2: begin of file] * * \retval status [0: ERROR, 1:OK] */ int8_t SX1280GetHexFileLineFields( char* line, uint8_t *bytes, uint16_t *addr, uint16_t *num, uint8_t *code ); #endif // __SX1280_H__