Struct radio_sx1231::Sx1231

pub struct Sx1231<Spi, CsPin, SpiError, PinError> { /* fields omitted */ }

Sx1231 device object

Operating functions are implemented as traits from the radio package

Implementations

impl<Spi, CsPin, SpiError, PinError> Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

pub fn new(spi: Spi, cs: CsPin) -> Self

Create a new radio instance with the provided SPI implementation and pins

pub fn free(self) -> (Spi, CsPin)

Return hardware resources for reuse

impl<Spi, CsPin, SpiError, PinError> Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

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

(re)apply device configuration

pub fn silicon_version(&mut self) -> Result<u8, Error<SpiError, PinError>>

Fetch device silicon version

pub fn set_frequency(
    &mut self,
    freq: u32
) -> Result<(), Error<SpiError, PinError>>

impl<Spi, CsPin, SpiError, PinError> Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

pub fn set_state_checked(
    &mut self,
    state: ModemMode
) -> Result<(), Error<SpiError, PinError>>

Trait Implementations

impl<Spi, CsPin, SpiError, PinError> Channel for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

fn set_channel(
    &mut self,
    channel: &Channel
) -> Result<(), Error<SpiError, PinError>>

Set the channel for future receive or transmit operations

type Channel = Channel

Channel information

type Error = Error<SpiError, PinError>

Radio error type

impl<Spi, CsPin, SpiError, PinError> Interrupts for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

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 = IrqFlags

Interrupt object

type Error = Error<SpiError, PinError>

Radio error

impl<Spi, CsPin, SpiError, PinError> Power for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

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

Set transmit power (using the existing PaConfig)

type Error = Error<SpiError, PinError>

Radio error type

impl<Spi, CsPin, SpiError, PinError> Receive for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

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,
    data: &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<SpiError, PinError>

Radio error

impl<Spi, CsPin, SpiError, PinError, Word, Bytes> Registers<Word> for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug,
    Word: RegisterWord<Bytes = Bytes>,
    Bytes: Default + AsMut<[u8]>, 

type Error = Error<SpiError, PinError>

fn read_register<R: Register<Word = Word>>(
    &mut self
) -> Result<R, Error<SpiError, PinError>>

Read a register value

fn write_register<R: Register<Word = Word>>(
    &mut self,
    r: R
) -> Result<(), Error<SpiError, PinError>>

Write a register value

fn update_register<R, F>(&mut self, f: F) -> Result<R, Self::Error> where
    R: Register<Word = Word>,
    F: Fn(R) -> R, 

Update a register value

impl<Spi, CsPin, SpiError, PinError> Rssi for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

fn poll_rssi(&mut self) -> Result<i16, Error<SpiError, PinError>>

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

type Error = Error<SpiError, PinError>

Radio error

impl<Spi, CsPin, SpiError, PinError> State for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

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

Fetch device modem mode

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

Set device modem mode

type State = ModemMode

Radio state

type Error = Error<SpiError, PinError>

Radio error type

impl<Spi, CsPin, SpiError, PinError> Transmit for Sx1231<Spi, CsPin, SpiError, PinError> where
    Spi: Transfer<u8, Error = SpiError> + Write<u8, Error = SpiError>,
    CsPin: OutputPin<Error = PinError>,
    SpiError: Debug,
    PinError: Debug, 

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

Start sending a packet

fn check_transmit(&mut self) -> Result<bool, Error<SpiError, PinError>>

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

type Error = Error<SpiError, PinError>

Radio error