Initial add for sx126x

embassy-lora/src/sx126x/sx126x_lora/mod_params.rs

@@ -0,0 +1,469 @@
+use core::fmt::Debug;
+
+use lorawan_device::async_device::radio as device;
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RadioError<BUS> {
+    SPI(BUS),
+    CS,
+    Reset,
+    AntRx,
+    AntTx,
+    Busy,
+    DIO1,
+    PayloadSizeMismatch(usize, usize),
+    RetentionListExceeded,
+    InvalidBandwidth,
+    ModulationParamsMissing,
+    PacketParamsMissing,
+    HeaderError,
+    CRCErrorUnexpected,
+    CRCErrorOnReceive,
+    TransmitTimeout,
+    ReceiveTimeout,
+    TimeoutUnexpected,
+    TransmitDoneUnexpected,
+    ReceiveDoneUnexpected,
+    CADUnexpected,
+}
+
+pub struct RadioSystemError {
+    pub rc_64khz_calibration: bool,
+    pub rc_13mhz_calibration: bool,
+    pub pll_calibration: bool,
+    pub adc_calibration: bool,
+    pub image_calibration: bool,
+    pub xosc_start: bool,
+    pub pll_lock: bool,
+    pub pa_ramp: bool,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum PacketType {
+    GFSK = 0x00,
+    LoRa = 0x01,
+    None = 0x0F,
+}
+
+impl PacketType {
+    pub const fn value(self) -> u8 {
+        self as u8
+    }
+    pub fn to_enum(value: u8) -> Self {
+        if value == 0x00 {
+            PacketType::GFSK
+        } else if value == 0x01 {
+            PacketType::LoRa
+        } else {
+            PacketType::None
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct PacketStatus {
+    pub rssi: i8,
+    pub snr: i8,
+    pub signal_rssi: i8,
+    pub freq_error: u32,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum RadioType {
+    SX1261,
+    SX1262,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum RadioMode {
+    Sleep = 0x00,                    // sleep mode
+    StandbyRC = 0x01,                // standby mode with RC oscillator
+    StandbyXOSC = 0x02,              // standby mode with XOSC oscillator
+    FrequencySynthesis = 0x03,       // frequency synthesis mode
+    Transmit = 0x04,                 // transmit mode
+    Receive = 0x05,                  // receive mode
+    ReceiveDutyCycle = 0x06,         // receive duty cycle mode
+    ChannelActivityDetection = 0x07, // channel activity detection mode
+}
+
+impl RadioMode {
+    /// Returns the value of the mode.
+    pub const fn value(self) -> u8 {
+        self as u8
+    }
+    pub fn to_enum(value: u8) -> Self {
+        if value == 0x00 {
+            RadioMode::Sleep
+        } else if value == 0x01 {
+            RadioMode::StandbyRC
+        } else if value == 0x02 {
+            RadioMode::StandbyXOSC
+        } else if value == 0x03 {
+            RadioMode::FrequencySynthesis
+        } else if value == 0x04 {
+            RadioMode::Transmit
+        } else if value == 0x05 {
+            RadioMode::Receive
+        } else if value == 0x06 {
+            RadioMode::ReceiveDutyCycle
+        } else if value == 0x07 {
+            RadioMode::ChannelActivityDetection
+        } else {
+            RadioMode::Sleep
+        }
+    }
+}
+
+pub enum RadioState {
+    Idle = 0x00,
+    RxRunning = 0x01,
+    TxRunning = 0x02,
+    ChannelActivityDetecting = 0x03,
+}
+
+impl RadioState {
+    /// Returns the value of the state.
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+pub struct RadioStatus {
+    pub cmd_status: u8,
+    pub chip_mode: u8,
+}
+
+impl RadioStatus {
+    pub fn value(self) -> u8 {
+        (self.chip_mode << 4) | (self.cmd_status << 1)
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum IrqMask {
+    None = 0x0000,
+    TxDone = 0x0001,
+    RxDone = 0x0002,
+    PreambleDetected = 0x0004,
+    SyncwordValid = 0x0008,
+    HeaderValid = 0x0010,
+    HeaderError = 0x0020,
+    CRCError = 0x0040,
+    CADDone = 0x0080,
+    CADActivityDetected = 0x0100,
+    RxTxTimeout = 0x0200,
+    All = 0xFFFF,
+}
+
+impl IrqMask {
+    pub fn value(self) -> u16 {
+        self as u16
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum Register {
+    PacketParams = 0x0704,          // packet configuration
+    PayloadLength = 0x0702,         // payload size
+    SynchTimeout = 0x0706,          // recalculated number of symbols
+    Syncword = 0x06C0,              // Syncword values
+    LoRaSyncword = 0x0740,          // LoRa Syncword value
+    GeneratedRandomNumber = 0x0819, //32-bit generated random number
+    AnaLNA = 0x08E2,                // disable the LNA
+    AnaMixer = 0x08E5,              // disable the mixer
+    RxGain = 0x08AC,                // RX gain (0x94: power saving, 0x96: rx boosted)
+    XTATrim = 0x0911,               // device internal trimming capacitor
+    OCP = 0x08E7,                   // over current protection max value
+    RetentionList = 0x029F,         // retention list
+    IQPolarity = 0x0736,            // optimize the inverted IQ operation (see DS_SX1261-2_V1.2 datasheet chapter 15.4)
+    TxModulation = 0x0889, // modulation quality with 500 kHz LoRa Bandwidth (see DS_SX1261-2_V1.2 datasheet chapter 15.1)
+    TxClampCfg = 0x08D8,   // better resistance to antenna mismatch (see DS_SX1261-2_V1.2 datasheet chapter 15.2)
+    RTCCtrl = 0x0902,      // RTC control
+    EvtClr = 0x0944,       // event clear
+}
+
+impl Register {
+    pub fn addr(self) -> u16 {
+        self as u16
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum OpCode {
+    GetStatus = 0xC0,
+    WriteRegister = 0x0D,
+    ReadRegister = 0x1D,
+    WriteBuffer = 0x0E,
+    ReadBuffer = 0x1E,
+    SetSleep = 0x84,
+    SetStandby = 0x80,
+    SetFS = 0xC1,
+    SetTx = 0x83,
+    SetRx = 0x82,
+    SetRxDutyCycle = 0x94,
+    SetCAD = 0xC5,
+    SetTxContinuousWave = 0xD1,
+    SetTxContinuousPremable = 0xD2,
+    SetPacketType = 0x8A,
+    GetPacketType = 0x11,
+    SetRFFrequency = 0x86,
+    SetTxParams = 0x8E,
+    SetPAConfig = 0x95,
+    SetCADParams = 0x88,
+    SetBufferBaseAddress = 0x8F,
+    SetModulationParams = 0x8B,
+    SetPacketParams = 0x8C,
+    GetRxBufferStatus = 0x13,
+    GetPacketStatus = 0x14,
+    GetRSSIInst = 0x15,
+    GetStats = 0x10,
+    ResetStats = 0x00,
+    CfgDIOIrq = 0x08,
+    GetIrqStatus = 0x12,
+    ClrIrqStatus = 0x02,
+    Calibrate = 0x89,
+    CalibrateImage = 0x98,
+    SetRegulatorMode = 0x96,
+    GetErrors = 0x17,
+    ClrErrors = 0x07,
+    SetTCXOMode = 0x97,
+    SetTxFallbackMode = 0x93,
+    SetRFSwitchMode = 0x9D,
+    SetStopRxTimerOnPreamble = 0x9F,
+    SetLoRaSymbTimeout = 0xA0,
+}
+
+impl OpCode {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+pub struct SleepParams {
+    pub wakeup_rtc: bool, // get out of sleep mode if wakeup signal received from RTC
+    pub reset: bool,
+    pub warm_start: bool,
+}
+
+impl SleepParams {
+    pub fn value(self) -> u8 {
+        ((self.warm_start as u8) << 2) | ((self.reset as u8) << 1) | (self.wakeup_rtc as u8)
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum StandbyMode {
+    RC = 0x00,
+    XOSC = 0x01,
+}
+
+impl StandbyMode {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum RegulatorMode {
+    UseLDO = 0x00,
+    UseDCDC = 0x01,
+}
+
+impl RegulatorMode {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct CalibrationParams {
+    pub rc64k_enable: bool,     // calibrate RC64K clock
+    pub rc13m_enable: bool,     // calibrate RC13M clock
+    pub pll_enable: bool,       // calibrate PLL
+    pub adc_pulse_enable: bool, // calibrate ADC Pulse
+    pub adc_bulkn_enable: bool, // calibrate ADC bulkN
+    pub adc_bulkp_enable: bool, // calibrate ADC bulkP
+    pub img_enable: bool,
+}
+
+impl CalibrationParams {
+    pub fn value(self) -> u8 {
+        ((self.img_enable as u8) << 6)
+            | ((self.adc_bulkp_enable as u8) << 5)
+            | ((self.adc_bulkn_enable as u8) << 4)
+            | ((self.adc_pulse_enable as u8) << 3)
+            | ((self.pll_enable as u8) << 2)
+            | ((self.rc13m_enable as u8) << 1)
+            | ((self.rc64k_enable as u8) << 0)
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum TcxoCtrlVoltage {
+    Ctrl1V6 = 0x00,
+    Ctrl1V7 = 0x01,
+    Ctrl1V8 = 0x02,
+    Ctrl2V2 = 0x03,
+    Ctrl2V4 = 0x04,
+    Ctrl2V7 = 0x05,
+    Ctrl3V0 = 0x06,
+    Ctrl3V3 = 0x07,
+}
+
+impl TcxoCtrlVoltage {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum RampTime {
+    Ramp10Us = 0x00,
+    Ramp20Us = 0x01,
+    Ramp40Us = 0x02,
+    Ramp80Us = 0x03,
+    Ramp200Us = 0x04,
+    Ramp800Us = 0x05,
+    Ramp1700Us = 0x06,
+    Ramp3400Us = 0x07,
+}
+
+impl RampTime {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum SpreadingFactor {
+    _5 = 0x05,
+    _6 = 0x06,
+    _7 = 0x07,
+    _8 = 0x08,
+    _9 = 0x09,
+    _10 = 0x0A,
+    _11 = 0x0B,
+    _12 = 0x0C,
+}
+
+impl SpreadingFactor {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+impl From<device::SpreadingFactor> for SpreadingFactor {
+    fn from(sf: device::SpreadingFactor) -> Self {
+        match sf {
+            device::SpreadingFactor::_7 => SpreadingFactor::_7,
+            device::SpreadingFactor::_8 => SpreadingFactor::_8,
+            device::SpreadingFactor::_9 => SpreadingFactor::_9,
+            device::SpreadingFactor::_10 => SpreadingFactor::_10,
+            device::SpreadingFactor::_11 => SpreadingFactor::_11,
+            device::SpreadingFactor::_12 => SpreadingFactor::_12,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Bandwidth {
+    _500KHz = 0x06,
+    _250KHz = 0x05,
+    _125KHz = 0x04,
+}
+
+impl Bandwidth {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+
+    pub fn value_in_hz(self) -> u32 {
+        match self {
+            Bandwidth::_125KHz => 125000u32,
+            Bandwidth::_250KHz => 250000u32,
+            Bandwidth::_500KHz => 500000u32,
+        }
+    }
+}
+
+impl From<device::Bandwidth> for Bandwidth {
+    fn from(bw: device::Bandwidth) -> Self {
+        match bw {
+            device::Bandwidth::_500KHz => Bandwidth::_500KHz,
+            device::Bandwidth::_250KHz => Bandwidth::_250KHz,
+            device::Bandwidth::_125KHz => Bandwidth::_125KHz,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum CodingRate {
+    _4_5 = 0x01,
+    _4_6 = 0x02,
+    _4_7 = 0x03,
+    _4_8 = 0x04,
+}
+
+impl CodingRate {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+impl From<device::CodingRate> for CodingRate {
+    fn from(cr: device::CodingRate) -> Self {
+        match cr {
+            device::CodingRate::_4_5 => CodingRate::_4_5,
+            device::CodingRate::_4_6 => CodingRate::_4_6,
+            device::CodingRate::_4_7 => CodingRate::_4_7,
+            device::CodingRate::_4_8 => CodingRate::_4_8,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct ModulationParams {
+    pub spreading_factor: SpreadingFactor,
+    pub bandwidth: Bandwidth,
+    pub coding_rate: CodingRate,
+    pub low_data_rate_optimize: u8,
+}
+
+#[derive(Clone, Copy)]
+pub struct PacketParams {
+    pub preamble_length: u16,  // number of LoRa symbols in the preamble
+    pub implicit_header: bool, // if the header is explicit, it will be transmitted in the LoRa packet, but is not transmitted if the header is implicit (known fixed length)
+    pub payload_length: u8,
+    pub crc_on: bool,
+    pub iq_inverted: bool,
+}
+
+#[derive(Clone, Copy)]
+pub enum CADSymbols {
+    _1 = 0x00,
+    _2 = 0x01,
+    _4 = 0x02,
+    _8 = 0x03,
+    _16 = 0x04,
+}
+
+impl CADSymbols {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum CADExitMode {
+    CADOnly = 0x00,
+    CADRx = 0x01,
+    CADLBT = 0x10,
+}
+
+impl CADExitMode {
+    pub fn value(self) -> u8 {
+        self as u8
+    }
+}