summaryrefslogtreecommitdiff
path: root/embassy-lora/src/sx126x/sx126x_lora/subroutine.rs
diff options
context:
space:
mode:
Diffstat (limited to 'embassy-lora/src/sx126x/sx126x_lora/subroutine.rs')
-rw-r--r--embassy-lora/src/sx126x/sx126x_lora/subroutine.rs674
1 files changed, 674 insertions, 0 deletions
diff --git a/embassy-lora/src/sx126x/sx126x_lora/subroutine.rs b/embassy-lora/src/sx126x/sx126x_lora/subroutine.rs
new file mode 100644
index 00000000..2e78b919
--- /dev/null
+++ b/embassy-lora/src/sx126x/sx126x_lora/subroutine.rs
@@ -0,0 +1,674 @@
+use embedded_hal::digital::v2::OutputPin;
+use embedded_hal_async::digital::Wait;
+use embedded_hal_async::spi::SpiBus;
+
+use super::mod_params::*;
+use super::LoRa;
+
+// Internal frequency of the radio
+const SX126X_XTAL_FREQ: u32 = 32000000;
+
+// Scaling factor used to perform fixed-point operations
+const SX126X_PLL_STEP_SHIFT_AMOUNT: u32 = 14;
+
+// PLL step - scaled with SX126X_PLL_STEP_SHIFT_AMOUNT
+const SX126X_PLL_STEP_SCALED: u32 = SX126X_XTAL_FREQ >> (25 - SX126X_PLL_STEP_SHIFT_AMOUNT);
+
+// Maximum value for parameter symbNum
+const SX126X_MAX_LORA_SYMB_NUM_TIMEOUT: u8 = 248;
+
+// Provides board-specific functionality for Semtech SX126x-based boards
+
+impl<SPI, CTRL, WAIT, BUS> LoRa<SPI, CTRL, WAIT>
+where
+ SPI: SpiBus<u8, Error = BUS>,
+ CTRL: OutputPin,
+ WAIT: Wait,
+{
+ // Initialize the radio driver
+ pub(super) async fn sub_init(&mut self) -> Result<(), RadioError<BUS>> {
+ self.brd_reset().await?;
+ self.brd_wakeup().await?;
+ self.sub_set_standby(StandbyMode::RC).await?;
+ self.brd_io_tcxo_init().await?;
+ self.brd_io_rf_switch_init().await?;
+ self.image_calibrated = false;
+ Ok(())
+ }
+
+ // Wakeup the radio if it is in Sleep mode and check that Busy is low
+ pub(super) async fn sub_check_device_ready(&mut self) -> Result<(), RadioError<BUS>> {
+ let operating_mode = self.brd_get_operating_mode();
+ if operating_mode == RadioMode::Sleep || operating_mode == RadioMode::ReceiveDutyCycle {
+ self.brd_wakeup().await?;
+ }
+ self.brd_wait_on_busy().await?;
+ Ok(())
+ }
+
+ // Save the payload to be sent in the radio buffer
+ pub(super) async fn sub_set_payload(&mut self, payload: &[u8]) -> Result<(), RadioError<BUS>> {
+ self.brd_write_buffer(0x00, payload).await?;
+ Ok(())
+ }
+
+ // Read the payload received.
+ pub(super) async fn sub_get_payload(&mut self, buffer: &mut [u8]) -> Result<u8, RadioError<BUS>> {
+ let (size, offset) = self.sub_get_rx_buffer_status().await?;
+ if (size as usize) > buffer.len() {
+ Err(RadioError::PayloadSizeMismatch(size as usize, buffer.len()))
+ } else {
+ self.brd_read_buffer(offset, buffer).await?;
+ Ok(size)
+ }
+ }
+
+ // Send a payload
+ pub(super) async fn sub_send_payload(&mut self, payload: &[u8], timeout: u32) -> Result<(), RadioError<BUS>> {
+ self.sub_set_payload(payload).await?;
+ self.sub_set_tx(timeout).await?;
+ Ok(())
+ }
+
+ // Get a 32-bit random value generated by the radio. A valid packet type must have been configured before using this command.
+ //
+ // The radio must be in reception mode before executing this function. This code can potentially result in interrupt generation. It is the responsibility of
+ // the calling code to disable radio interrupts before calling this function, and re-enable them afterwards if necessary, or be certain that any interrupts
+ // generated during this process will not cause undesired side-effects in the software.
+ //
+ // The random numbers produced by the generator do not have a uniform or Gaussian distribution. If uniformity is needed, perform appropriate software post-processing.
+ pub(super) async fn sub_get_random(&mut self) -> Result<u32, RadioError<BUS>> {
+ let mut reg_ana_lna_buffer_original = [0x00u8];
+ let mut reg_ana_mixer_buffer_original = [0x00u8];
+ let mut reg_ana_lna_buffer = [0x00u8];
+ let mut reg_ana_mixer_buffer = [0x00u8];
+ let mut number_buffer = [0x00u8, 0x00u8, 0x00u8, 0x00u8];
+
+ self.brd_read_registers(Register::AnaLNA, &mut reg_ana_lna_buffer_original)
+ .await?;
+ reg_ana_lna_buffer[0] = reg_ana_lna_buffer_original[0] & (!(1 << 0));
+ self.brd_write_registers(Register::AnaLNA, &reg_ana_lna_buffer).await?;
+
+ self.brd_read_registers(Register::AnaMixer, &mut reg_ana_mixer_buffer_original)
+ .await?;
+ reg_ana_mixer_buffer[0] = reg_ana_mixer_buffer_original[0] & (!(1 << 7));
+ self.brd_write_registers(Register::AnaMixer, &reg_ana_mixer_buffer)
+ .await?;
+
+ // Set radio in continuous reception
+ self.sub_set_rx(0xFFFFFFu32).await?;
+
+ self.brd_read_registers(Register::GeneratedRandomNumber, &mut number_buffer)
+ .await?;
+
+ self.sub_set_standby(StandbyMode::RC).await?;
+
+ self.brd_write_registers(Register::AnaLNA, &reg_ana_lna_buffer_original)
+ .await?;
+ self.brd_write_registers(Register::AnaMixer, &reg_ana_mixer_buffer_original)
+ .await?;
+
+ Ok(Self::convert_u8_buffer_to_u32(&number_buffer))
+ }
+
+ // Set the radio in sleep mode
+ pub(super) async fn sub_set_sleep(&mut self, sleep_config: SleepParams) -> Result<(), RadioError<BUS>> {
+ self.brd_ant_sleep()?;
+
+ if !sleep_config.warm_start {
+ self.image_calibrated = false;
+ }
+
+ self.brd_write_command(OpCode::SetSleep, &[sleep_config.value()])
+ .await?;
+ self.brd_set_operating_mode(RadioMode::Sleep);
+ Ok(())
+ }
+
+ // Set the radio in configuration mode
+ pub(super) async fn sub_set_standby(&mut self, mode: StandbyMode) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetStandby, &[mode.value()]).await?;
+ if mode == StandbyMode::RC {
+ self.brd_set_operating_mode(RadioMode::StandbyRC);
+ } else {
+ self.brd_set_operating_mode(RadioMode::StandbyXOSC);
+ }
+
+ self.brd_ant_sleep()?;
+ Ok(())
+ }
+
+ // Set the radio in FS mode
+ pub(super) async fn sub_set_fs(&mut self) -> Result<(), RadioError<BUS>> {
+ // antenna settings ???
+ self.brd_write_command(OpCode::SetFS, &[]).await?;
+ self.brd_set_operating_mode(RadioMode::FrequencySynthesis);
+ Ok(())
+ }
+
+ // Set the radio in transmission mode with timeout specified
+ pub(super) async fn sub_set_tx(&mut self, timeout: u32) -> Result<(), RadioError<BUS>> {
+ let buffer = [
+ Self::timeout_1(timeout),
+ Self::timeout_2(timeout),
+ Self::timeout_3(timeout),
+ ];
+
+ self.brd_ant_set_tx()?;
+
+ self.brd_set_operating_mode(RadioMode::Transmit);
+ self.brd_write_command(OpCode::SetTx, &buffer).await?;
+ Ok(())
+ }
+
+ // Set the radio in reception mode with timeout specified
+ pub(super) async fn sub_set_rx(&mut self, timeout: u32) -> Result<(), RadioError<BUS>> {
+ let buffer = [
+ Self::timeout_1(timeout),
+ Self::timeout_2(timeout),
+ Self::timeout_3(timeout),
+ ];
+
+ self.brd_ant_set_rx()?;
+
+ self.brd_set_operating_mode(RadioMode::Receive);
+ self.brd_write_registers(Register::RxGain, &[0x94u8]).await?;
+ self.brd_write_command(OpCode::SetRx, &buffer).await?;
+ Ok(())
+ }
+
+ // Set the radio in reception mode with Boosted LNA gain and timeout specified
+ pub(super) async fn sub_set_rx_boosted(&mut self, timeout: u32) -> Result<(), RadioError<BUS>> {
+ let buffer = [
+ Self::timeout_1(timeout),
+ Self::timeout_2(timeout),
+ Self::timeout_3(timeout),
+ ];
+
+ self.brd_ant_set_rx()?;
+
+ self.brd_set_operating_mode(RadioMode::Receive);
+ // set max LNA gain, increase current by ~2mA for around ~3dB in sensitivity
+ self.brd_write_registers(Register::RxGain, &[0x96u8]).await?;
+ self.brd_write_command(OpCode::SetRx, &buffer).await?;
+ Ok(())
+ }
+
+ // Set the Rx duty cycle management parameters
+ pub(super) async fn sub_set_rx_duty_cycle(&mut self, rx_time: u32, sleep_time: u32) -> Result<(), RadioError<BUS>> {
+ let buffer = [
+ ((rx_time >> 16) & 0xFF) as u8,
+ ((rx_time >> 8) & 0xFF) as u8,
+ (rx_time & 0xFF) as u8,
+ ((sleep_time >> 16) & 0xFF) as u8,
+ ((sleep_time >> 8) & 0xFF) as u8,
+ (sleep_time & 0xFF) as u8,
+ ];
+
+ // antenna settings ???
+
+ self.brd_write_command(OpCode::SetRxDutyCycle, &buffer).await?;
+ self.brd_set_operating_mode(RadioMode::ReceiveDutyCycle);
+ Ok(())
+ }
+
+ // Set the radio in CAD mode
+ pub(super) async fn sub_set_cad(&mut self) -> Result<(), RadioError<BUS>> {
+ self.brd_ant_set_rx()?;
+
+ self.brd_write_command(OpCode::SetCAD, &[]).await?;
+ self.brd_set_operating_mode(RadioMode::ChannelActivityDetection);
+ Ok(())
+ }
+
+ // Set the radio in continuous wave transmission mode
+ pub(super) async fn sub_set_tx_continuous_wave(&mut self) -> Result<(), RadioError<BUS>> {
+ self.brd_ant_set_tx()?;
+
+ self.brd_write_command(OpCode::SetTxContinuousWave, &[]).await?;
+ self.brd_set_operating_mode(RadioMode::Transmit);
+ Ok(())
+ }
+
+ // Set the radio in continuous preamble transmission mode
+ pub(super) async fn sub_set_tx_infinite_preamble(&mut self) -> Result<(), RadioError<BUS>> {
+ self.brd_ant_set_tx()?;
+
+ self.brd_write_command(OpCode::SetTxContinuousPremable, &[]).await?;
+ self.brd_set_operating_mode(RadioMode::Transmit);
+ Ok(())
+ }
+
+ // Decide which interrupt will stop the internal radio rx timer.
+ // false timer stop after header/syncword detection
+ // true timer stop after preamble detection
+ pub(super) async fn sub_set_stop_rx_timer_on_preamble_detect(
+ &mut self,
+ enable: bool,
+ ) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetStopRxTimerOnPreamble, &[enable as u8])
+ .await?;
+ Ok(())
+ }
+
+ // Set the number of symbols the radio will wait to validate a reception
+ pub(super) async fn sub_set_lora_symb_num_timeout(&mut self, symb_num: u16) -> Result<(), RadioError<BUS>> {
+ let mut exp = 0u8;
+ let mut reg;
+ let mut mant = ((core::cmp::min(symb_num, SX126X_MAX_LORA_SYMB_NUM_TIMEOUT as u16) as u8) + 1) >> 1;
+ while mant > 31 {
+ mant = (mant + 3) >> 2;
+ exp += 1;
+ }
+ reg = mant << ((2 * exp) + 1);
+
+ self.brd_write_command(OpCode::SetLoRaSymbTimeout, &[reg]).await?;
+
+ if symb_num != 0 {
+ reg = exp + (mant << 3);
+ self.brd_write_registers(Register::SynchTimeout, &[reg]).await?;
+ }
+
+ Ok(())
+ }
+
+ // Set the power regulators operating mode (LDO or DC_DC). Using only LDO implies that the Rx or Tx current is doubled
+ pub(super) async fn sub_set_regulator_mode(&mut self, mode: RegulatorMode) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetRegulatorMode, &[mode.value()])
+ .await?;
+ Ok(())
+ }
+
+ // Calibrate the given radio block
+ pub(super) async fn sub_calibrate(&mut self, calibrate_params: CalibrationParams) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::Calibrate, &[calibrate_params.value()])
+ .await?;
+ Ok(())
+ }
+
+ // Calibrate the image rejection based on the given frequency
+ pub(super) async fn sub_calibrate_image(&mut self, freq: u32) -> Result<(), RadioError<BUS>> {
+ let mut cal_freq = [0x00u8, 0x00u8];
+
+ if freq > 900000000 {
+ cal_freq[0] = 0xE1;
+ cal_freq[1] = 0xE9;
+ } else if freq > 850000000 {
+ cal_freq[0] = 0xD7;
+ cal_freq[1] = 0xDB;
+ } else if freq > 770000000 {
+ cal_freq[0] = 0xC1;
+ cal_freq[1] = 0xC5;
+ } else if freq > 460000000 {
+ cal_freq[0] = 0x75;
+ cal_freq[1] = 0x81;
+ } else if freq > 425000000 {
+ cal_freq[0] = 0x6B;
+ cal_freq[1] = 0x6F;
+ }
+ self.brd_write_command(OpCode::CalibrateImage, &cal_freq).await?;
+ Ok(())
+ }
+
+ // Activate the extention of the timeout when a long preamble is used
+ pub(super) async fn sub_set_long_preamble(&mut self, _enable: u8) -> Result<(), RadioError<BUS>> {
+ Ok(()) // no operation currently
+ }
+
+ // Set the transmission parameters
+ // hp_max 0 for sx1261, 7 for sx1262
+ // device_sel 1 for sx1261, 0 for sx1262
+ // pa_lut 0 for 14dBm LUT, 1 for 22dBm LUT
+ pub(super) async fn sub_set_pa_config(
+ &mut self,
+ pa_duty_cycle: u8,
+ hp_max: u8,
+ device_sel: u8,
+ pa_lut: u8,
+ ) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetPAConfig, &[pa_duty_cycle, hp_max, device_sel, pa_lut])
+ .await?;
+ Ok(())
+ }
+
+ // Define into which mode the chip goes after a TX / RX done
+ pub(super) async fn sub_set_rx_tx_fallback_mode(&mut self, fallback_mode: u8) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetTxFallbackMode, &[fallback_mode])
+ .await?;
+ Ok(())
+ }
+
+ // Set the IRQ mask and DIO masks
+ pub(super) async fn sub_set_dio_irq_params(
+ &mut self,
+ irq_mask: u16,
+ dio1_mask: u16,
+ dio2_mask: u16,
+ dio3_mask: u16,
+ ) -> Result<(), RadioError<BUS>> {
+ let mut buffer = [0x00u8; 8];
+
+ buffer[0] = ((irq_mask >> 8) & 0x00FF) as u8;
+ buffer[1] = (irq_mask & 0x00FF) as u8;
+ buffer[2] = ((dio1_mask >> 8) & 0x00FF) as u8;
+ buffer[3] = (dio1_mask & 0x00FF) as u8;
+ buffer[4] = ((dio2_mask >> 8) & 0x00FF) as u8;
+ buffer[5] = (dio2_mask & 0x00FF) as u8;
+ buffer[6] = ((dio3_mask >> 8) & 0x00FF) as u8;
+ buffer[7] = (dio3_mask & 0x00FF) as u8;
+ self.brd_write_command(OpCode::CfgDIOIrq, &buffer).await?;
+ Ok(())
+ }
+
+ // Return the current IRQ status
+ pub(super) async fn sub_get_irq_status(&mut self) -> Result<u16, RadioError<BUS>> {
+ let mut irq_status = [0x00u8, 0x00u8];
+ self.brd_read_command(OpCode::GetIrqStatus, &mut irq_status).await?;
+ Ok(((irq_status[0] as u16) << 8) | (irq_status[1] as u16))
+ }
+
+ // Indicate if DIO2 is used to control an RF Switch
+ pub(super) async fn sub_set_dio2_as_rf_switch_ctrl(&mut self, enable: bool) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetRFSwitchMode, &[enable as u8]).await?;
+ Ok(())
+ }
+
+ // Indicate if the radio main clock is supplied from a TCXO
+ // tcxo_voltage voltage used to control the TCXO on/off from DIO3
+ // timeout duration given to the TCXO to go to 32MHz
+ pub(super) async fn sub_set_dio3_as_tcxo_ctrl(
+ &mut self,
+ tcxo_voltage: TcxoCtrlVoltage,
+ timeout: u32,
+ ) -> Result<(), RadioError<BUS>> {
+ let buffer = [
+ tcxo_voltage.value() & 0x07,
+ Self::timeout_1(timeout),
+ Self::timeout_2(timeout),
+ Self::timeout_3(timeout),
+ ];
+ self.brd_write_command(OpCode::SetTCXOMode, &buffer).await?;
+
+ Ok(())
+ }
+
+ // Set the RF frequency (Hz)
+ pub(super) async fn sub_set_rf_frequency(&mut self, frequency: u32) -> Result<(), RadioError<BUS>> {
+ let mut buffer = [0x00u8; 4];
+
+ if !self.image_calibrated {
+ self.sub_calibrate_image(frequency).await?;
+ self.image_calibrated = true;
+ }
+
+ let freq_in_pll_steps = Self::convert_freq_in_hz_to_pll_step(frequency);
+
+ buffer[0] = ((freq_in_pll_steps >> 24) & 0xFF) as u8;
+ buffer[1] = ((freq_in_pll_steps >> 16) & 0xFF) as u8;
+ buffer[2] = ((freq_in_pll_steps >> 8) & 0xFF) as u8;
+ buffer[3] = (freq_in_pll_steps & 0xFF) as u8;
+ self.brd_write_command(OpCode::SetRFFrequency, &buffer).await?;
+ Ok(())
+ }
+
+ // Set the radio for the given protocol (LoRa or GFSK). This method has to be called before setting RF frequency, modulation paramaters, and packet paramaters.
+ pub(super) async fn sub_set_packet_type(&mut self, packet_type: PacketType) -> Result<(), RadioError<BUS>> {
+ self.packet_type = packet_type;
+ self.brd_write_command(OpCode::SetPacketType, &[packet_type.value()])
+ .await?;
+ Ok(())
+ }
+
+ // Get the current radio protocol (LoRa or GFSK)
+ pub(super) fn sub_get_packet_type(&mut self) -> PacketType {
+ self.packet_type
+ }
+
+ // Set the transmission parameters
+ // power RF output power [-18..13] dBm
+ // ramp_time transmission ramp up time
+ pub(super) async fn sub_set_tx_params(
+ &mut self,
+ mut power: i8,
+ ramp_time: RampTime,
+ ) -> Result<(), RadioError<BUS>> {
+ if self.brd_get_radio_type() == RadioType::SX1261 {
+ if power == 15 {
+ self.sub_set_pa_config(0x06, 0x00, 0x01, 0x01).await?;
+ } else {
+ self.sub_set_pa_config(0x04, 0x00, 0x01, 0x01).await?;
+ }
+
+ if power >= 14 {
+ power = 14;
+ } else if power < -17 {
+ power = -17;
+ }
+ } else {
+ // Provide better resistance of the SX1262 Tx to antenna mismatch (see DS_SX1261-2_V1.2 datasheet chapter 15.2)
+ let mut tx_clamp_cfg = [0x00u8];
+ self.brd_read_registers(Register::TxClampCfg, &mut tx_clamp_cfg).await?;
+ tx_clamp_cfg[0] = tx_clamp_cfg[0] | (0x0F << 1);
+ self.brd_write_registers(Register::TxClampCfg, &tx_clamp_cfg).await?;
+
+ self.sub_set_pa_config(0x04, 0x07, 0x00, 0x01).await?;
+
+ if power > 22 {
+ power = 22;
+ } else if power < -9 {
+ power = -9;
+ }
+ }
+
+ // power conversion of negative number from i8 to u8 ???
+ self.brd_write_command(OpCode::SetTxParams, &[power as u8, ramp_time.value()])
+ .await?;
+ Ok(())
+ }
+
+ // Set the modulation parameters
+ pub(super) async fn sub_set_modulation_params(&mut self) -> Result<(), RadioError<BUS>> {
+ if self.modulation_params.is_some() {
+ let mut buffer = [0x00u8; 4];
+
+ // Since this driver only supports LoRa, ensure the packet type is set accordingly
+ self.sub_set_packet_type(PacketType::LoRa).await?;
+
+ let modulation_params = self.modulation_params.unwrap();
+ buffer[0] = modulation_params.spreading_factor.value();
+ buffer[1] = modulation_params.bandwidth.value();
+ buffer[2] = modulation_params.coding_rate.value();
+ buffer[3] = modulation_params.low_data_rate_optimize;
+
+ self.brd_write_command(OpCode::SetModulationParams, &buffer).await?;
+ Ok(())
+ } else {
+ Err(RadioError::ModulationParamsMissing)
+ }
+ }
+
+ // Set the packet parameters
+ pub(super) async fn sub_set_packet_params(&mut self) -> Result<(), RadioError<BUS>> {
+ if self.packet_params.is_some() {
+ let mut buffer = [0x00u8; 6];
+
+ // Since this driver only supports LoRa, ensure the packet type is set accordingly
+ self.sub_set_packet_type(PacketType::LoRa).await?;
+
+ let packet_params = self.packet_params.unwrap();
+ buffer[0] = ((packet_params.preamble_length >> 8) & 0xFF) as u8;
+ buffer[1] = (packet_params.preamble_length & 0xFF) as u8;
+ buffer[2] = packet_params.implicit_header as u8;
+ buffer[3] = packet_params.payload_length;
+ buffer[4] = packet_params.crc_on as u8;
+ buffer[5] = packet_params.iq_inverted as u8;
+
+ self.brd_write_command(OpCode::SetPacketParams, &buffer).await?;
+ Ok(())
+ } else {
+ Err(RadioError::PacketParamsMissing)
+ }
+ }
+
+ // Set the channel activity detection (CAD) parameters
+ // symbols number of symbols to use for CAD operations
+ // det_peak limit for detection of SNR peak used in the CAD
+ // det_min minimum symbol recognition for CAD
+ // exit_mode operation to be done at the end of CAD action
+ // timeout timeout value to abort the CAD activity
+
+ pub(super) async fn sub_set_cad_params(
+ &mut self,
+ symbols: CADSymbols,
+ det_peak: u8,
+ det_min: u8,
+ exit_mode: CADExitMode,
+ timeout: u32,
+ ) -> Result<(), RadioError<BUS>> {
+ let mut buffer = [0x00u8; 7];
+
+ buffer[0] = symbols.value();
+ buffer[1] = det_peak;
+ buffer[2] = det_min;
+ buffer[3] = exit_mode.value();
+ buffer[4] = Self::timeout_1(timeout);
+ buffer[5] = Self::timeout_2(timeout);
+ buffer[6] = Self::timeout_3(timeout);
+
+ self.brd_write_command(OpCode::SetCADParams, &buffer).await?;
+ self.brd_set_operating_mode(RadioMode::ChannelActivityDetection);
+ Ok(())
+ }
+
+ // Set the data buffer base address for transmission and reception
+ pub(super) async fn sub_set_buffer_base_address(
+ &mut self,
+ tx_base_address: u8,
+ rx_base_address: u8,
+ ) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::SetBufferBaseAddress, &[tx_base_address, rx_base_address])
+ .await?;
+ Ok(())
+ }
+
+ // Get the current radio status
+ pub(super) async fn sub_get_status(&mut self) -> Result<RadioStatus, RadioError<BUS>> {
+ let status = self.brd_read_command(OpCode::GetStatus, &mut []).await?;
+ Ok(RadioStatus {
+ cmd_status: (status & (0x07 << 1)) >> 1,
+ chip_mode: (status & (0x07 << 4)) >> 4,
+ })
+ }
+
+ // Get the instantaneous RSSI value for the last packet received
+ pub(super) async fn sub_get_rssi_inst(&mut self) -> Result<i8, RadioError<BUS>> {
+ let mut buffer = [0x00u8];
+ self.brd_read_command(OpCode::GetRSSIInst, &mut buffer).await?;
+ let rssi: i8 = ((-(buffer[0] as i32)) >> 1) as i8; // check this ???
+ Ok(rssi)
+ }
+
+ // Get the last received packet buffer status
+ pub(super) async fn sub_get_rx_buffer_status(&mut self) -> Result<(u8, u8), RadioError<BUS>> {
+ if self.packet_params.is_some() {
+ let mut status = [0x00u8; 2];
+ let mut payload_length_buffer = [0x00u8];
+
+ self.brd_read_command(OpCode::GetRxBufferStatus, &mut status).await?;
+ if (self.sub_get_packet_type() == PacketType::LoRa) && self.packet_params.unwrap().implicit_header {
+ self.brd_read_registers(Register::PayloadLength, &mut payload_length_buffer)
+ .await?;
+ } else {
+ payload_length_buffer[0] = status[0];
+ }
+
+ let payload_length = payload_length_buffer[0];
+ let offset = status[1];
+
+ Ok((payload_length, offset))
+ } else {
+ Err(RadioError::PacketParamsMissing)
+ }
+ }
+
+ // Get the last received packet payload status
+ pub(super) async fn sub_get_packet_status(&mut self) -> Result<PacketStatus, RadioError<BUS>> {
+ let mut status = [0x00u8; 3];
+ self.brd_read_command(OpCode::GetPacketStatus, &mut status).await?;
+
+ // check this ???
+ let rssi = ((-(status[0] as i32)) >> 1) as i8;
+ let snr = ((status[1] as i8) + 2) >> 2;
+ let signal_rssi = ((-(status[2] as i32)) >> 1) as i8;
+ let freq_error = self.frequency_error;
+
+ Ok(PacketStatus {
+ rssi,
+ snr,
+ signal_rssi,
+ freq_error,
+ })
+ }
+
+ // Get the possible system errors
+ pub(super) async fn sub_get_device_errors(&mut self) -> Result<RadioSystemError, RadioError<BUS>> {
+ let mut errors = [0x00u8; 2];
+ self.brd_read_command(OpCode::GetErrors, &mut errors).await?;
+
+ Ok(RadioSystemError {
+ rc_64khz_calibration: (errors[1] & (1 << 0)) != 0,
+ rc_13mhz_calibration: (errors[1] & (1 << 1)) != 0,
+ pll_calibration: (errors[1] & (1 << 2)) != 0,
+ adc_calibration: (errors[1] & (1 << 3)) != 0,
+ image_calibration: (errors[1] & (1 << 4)) != 0,
+ xosc_start: (errors[1] & (1 << 5)) != 0,
+ pll_lock: (errors[1] & (1 << 6)) != 0,
+ pa_ramp: (errors[0] & (1 << 0)) != 0,
+ })
+ }
+
+ // Clear all the errors in the device
+ pub(super) async fn sub_clear_device_errors(&mut self) -> Result<(), RadioError<BUS>> {
+ self.brd_write_command(OpCode::ClrErrors, &[0x00u8, 0x00u8]).await?;
+ Ok(())
+ }
+
+ // Clear the IRQs
+ pub(super) async fn sub_clear_irq_status(&mut self, irq: u16) -> Result<(), RadioError<BUS>> {
+ let mut buffer = [0x00u8, 0x00u8];
+ buffer[0] = ((irq >> 8) & 0xFF) as u8;
+ buffer[1] = (irq & 0xFF) as u8;
+ self.brd_write_command(OpCode::ClrIrqStatus, &buffer).await?;
+ Ok(())
+ }
+
+ // Utility functions
+
+ fn timeout_1(timeout: u32) -> u8 {
+ ((timeout >> 16) & 0xFF) as u8
+ }
+ fn timeout_2(timeout: u32) -> u8 {
+ ((timeout >> 8) & 0xFF) as u8
+ }
+ fn timeout_3(timeout: u32) -> u8 {
+ (timeout & 0xFF) as u8
+ }
+
+ // check this ???
+ fn convert_u8_buffer_to_u32(buffer: &[u8; 4]) -> u32 {
+ let b0 = buffer[0] as u32;
+ let b1 = buffer[1] as u32;
+ let b2 = buffer[2] as u32;
+ let b3 = buffer[3] as u32;
+ (b0 << 24) | (b1 << 16) | (b2 << 8) | b3
+ }
+
+ fn convert_freq_in_hz_to_pll_step(freq_in_hz: u32) -> u32 {
+ // Get integer and fractional parts of the frequency computed with a PLL step scaled value
+ let steps_int = freq_in_hz / SX126X_PLL_STEP_SCALED;
+ let steps_frac = freq_in_hz - (steps_int * SX126X_PLL_STEP_SCALED);
+
+ (steps_int << SX126X_PLL_STEP_SHIFT_AMOUNT)
+ + (((steps_frac << SX126X_PLL_STEP_SHIFT_AMOUNT) + (SX126X_PLL_STEP_SCALED >> 1)) / SX126X_PLL_STEP_SCALED)
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-02 15:48:41 +0000