Struct radio_sx127x::Sx127x

pub struct Sx127x<Hal> { /* private fields */ }

Sx127x device object

Operating functions are implemented as traits from the radio package

Implementations

impl<Spi, CsPin, BusyPin, ReadyPin, SdnPin, PinError, Delay> Sx127x<Base<Spi, CsPin, BusyPin, ReadyPin, SdnPin, Delay>> where
    Spi: SpiBase,
    <Spi as SpiBase>::Error: Debug,
    CsPin: OutputPin<Error = PinError>,
    BusyPin: InputPin<Error = PinError>,
    ReadyPin: InputPin<Error = PinError>,
    SdnPin: OutputPin<Error = PinError>,
    PinError: Debug,
    Delay: DelayUs,
    <Delay as DelayUs>::Error: Debug, 

pub fn spi(
    spi: Spi,
    cs: CsPin,
    busy: BusyPin,
    ready: ReadyPin,
    sdn: SdnPin,
    delay: Delay,
    config: &Config
) -> Result<Self, Error<HalError<<Spi as SpiBase>::Error, PinError, <Delay as DelayUs>::Error>>>

Create an Sx127x with the provided SPI implementation and pins

impl<Hal> Sx127x<Hal> where
    Hal: Hal, 

pub fn new(
    hal: Hal,
    config: &Config
) -> Result<Self, Error<<Hal as Hal>::Error>>

Create a new radio instance over an arbitrary base::Base implementation

pub fn reset(&mut self) -> Result<(), Error<<Hal as Hal>::Error>>

Reset the device. This recalibrates and patches the device, however, still requires configuration.

pub fn configure(
    &mut self,
    config: &Config
) -> Result<(), Error<<Hal as Hal>::Error>>

(re)apply device configuration

pub fn silicon_version(&mut self) -> Result<u8, Error<<Hal as Hal>::Error>>

Fetch device silicon version

impl<Hal> Sx127x<Hal> where
    Hal: Hal, 

pub fn read_reg<R>(&mut self, reg: R) -> Result<u8, Error<<Hal as Hal>::Error>> where
    R: Copy + Clone + Debug + Into<u8>, 

Read a u8 value from the specified register

pub fn write_reg<R>(
    &mut self,
    reg: R,
    value: u8
) -> Result<(), Error<<Hal as Hal>::Error>> where
    R: Copy + Clone + Debug + Into<u8>, 

Write a u8 value to the specified register

pub fn update_reg<R>(
    &mut self,
    reg: R,
    mask: u8,
    value: u8
) -> Result<u8, Error<<Hal as Hal>::Error>> where
    R: Copy + Clone + Debug + Into<u8>, 

Update the specified register with the provided (value & mask)

Trait Implementations

impl<Hal> Channel for Sx127x<Hal> where
    Hal: Hal, 

fn set_channel(
    &mut self,
    channel: &Self::Channel
) -> Result<(), Error<<Hal as Hal>::Error>>

Set the LoRa mode channel for future receive or transmit operations

type Channel = Channel

Channel information

type Error = Error<<Hal as Hal>::Error>

Radio error type

impl<Hal> DelayUs for Sx127x<Hal> where
    Hal: Hal, 

type Error = Error<<Hal as Hal>::Error>

Enumeration of DelayUs errors

fn delay_us(&mut self, t: u32) -> Result<(), Error<<Hal as Hal>::Error>>

Pauses execution for at minimum us microseconds. Pause can be longer if the implementation requires it due to precision/timing issues.

fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error>

Pauses execution for at minimum ms milliseconds. Pause can be longer if the implementation requires it due to precision/timing issues.

impl<Hal> Interrupts for Sx127x<Hal> where
    Hal: Hal, 

fn get_interrupts(&mut self, clear: bool) -> Result<Self::Irq, Self::Error>

Fetch pending interrupts from the device If the clear option is set, this will also clear any pending flags

type Irq = Interrupts

Interrupt object

type Error = Error<<Hal as Hal>::Error>

Radio error

impl<Hal> Power for Sx127x<Hal> where
    Hal: Hal, 

fn set_power(&mut self, power: i8) -> Result<(), Error<<Hal as Hal>::Error>>

Set transmit power (using the existing PaConfig)

type Error = Error<<Hal as Hal>::Error>

Radio error type

impl<Hal> Receive for Sx127x<Hal> where
    Hal: Hal, 

fn start_receive(&mut self) -> Result<(), Self::Error>

Start receive mode

fn check_receive(&mut self, restart: bool) -> Result<bool, Self::Error>

Check receive state

This returns true if a boolean indicating whether a packet has been received. The restart option specifies whether transient timeout or CRC errors should be internally handled (returning Ok(false)) or passed back to the caller as errors.

fn get_received(
    &mut self,
    buff: &mut [u8]
) -> Result<(usize, Self::Info), Self::Error>

Fetch a received message

This copies data into the provided slice, updates the provided information object, and returns the number of bytes received on success

type Info = PacketInfo

Packet received info

type Error = Error<<Hal as Hal>::Error>

Radio error

impl<Hal> Rssi for Sx127x<Hal> where
    Hal: Hal, 

fn poll_rssi(&mut self) -> Result<i16, Error<<Hal as Hal>::Error>>

Poll for the current channel RSSI This should only be called in receive mode

type Error = Error<<Hal as Hal>::Error>

Radio error

impl<Hal> State for Sx127x<Hal> where
    Hal: Hal, 

fn get_state(&mut self) -> Result<Self::State, Self::Error>

Fetch device state

fn set_state(&mut self, state: Self::State) -> Result<(), Self::Error>

Set device state

type State = State

Radio state

type Error = Error<<Hal as Hal>::Error>

Radio error type

impl<Hal> Transmit for Sx127x<Hal> where
    Hal: Hal, 

fn start_transmit(&mut self, data: &[u8]) -> Result<(), Self::Error>

Start sending a packet

fn check_transmit(&mut self) -> Result<bool, Error<<Hal as Hal>::Error>>

Check for transmission completion This method should be polled (or checked following and interrupt) to indicate sending has completed

type Error = Error<<Hal as Hal>::Error>

Radio error