Struct atsamd_hal::sercom::spi::Config

pub struct Config<P, M = Master, Z = DefaultSize>where
    P: ValidPads,
    M: OpMode,
    Z: Size,{ /* private fields */ }

A configurable SPI peripheral in its disabled state

See the module-level documentation for more details on declaring and instantiating Pads types.

Implementations

impl<P: ValidPads> Config<P>

pub fn new(
    apb_clk_ctrl: &APB_CLK_CTRL,
    sercom: P::Sercom,
    pads: P,
    freq: impl Into<Hertz>
) -> Self

Create a new Config in the default configuration

This function will enable the corresponding APB clock, reset the Sercom peripheral, and return a Config in the default configuration. The default OpMode is Master, while the default Size is an EightBit CharSize for SAMD11 and SAMD21 chips or a Length of U1 for SAMx5x chips. Note that Config takes ownership of both the PAC Sercom struct as well as the Pads.

Users must configure GCLK manually. The freq parameter represents the GCLK frequency for this Sercom instance.

impl<P, M, Z> Config<P, M, Z>where
    P: ValidPads,
    M: OpMode,
    Z: Size,

pub unsafe fn sercom(&self) -> &P::Sercom

Obtain a reference to the PAC SERCOM struct

Directly accessing the SERCOM could break the invariants of the type-level tracking in this module, so it is unsafe.

pub fn reset(self) -> Config<P>

Trigger the Sercom’s SWRST and return a Config in the default configuration.

pub fn free(self) -> (P::Sercom, P)

Consume the Config, reset the peripheral, and return the Sercom and Pads

pub fn op_mode<M2: OpMode>(self) -> Config<P, M2, Z>

Change the OpMode

pub fn length<L2: Length>(self) -> Config<P, M, L2>

Change the transaction Length using the builder pattern

To use a run-time dynamic length, set the Length type to DynLength and then use the dyn_length method.

pub fn get_cpol(&self) -> Polarity

Get the clock polarity

pub fn set_cpol(&mut self, cpol: Polarity)

Set the clock polarity

pub fn cpol(self, cpol: Polarity) -> Self

Set the clock polarity using the builder pattern

pub fn get_cpha(&self) -> Phase

Get the clock phase

pub fn set_cpha(&mut self, cpha: Phase)

Set the clock phase

pub fn cpha(self, cpha: Phase) -> Self

Set the clock phase using the builder pattern

pub fn get_spi_mode(&self) -> Mode

Get the SPI mode (clock polarity & phase)

pub fn set_spi_mode(&mut self, mode: Mode)

Set the SPI mode (clock polarity & phase)

pub fn spi_mode(self, mode: Mode) -> Self

Set the SPI mode (clock polarity & phase) using the builder pattern

pub fn get_bit_order(&self) -> BitOrder

Get the bit order of transmission (MSB/LSB first)

This only affects the order of bits within each byte. Bytes are always transferred in little endian order from the 32-bit DATA register.

pub fn set_bit_order(&mut self, order: BitOrder)

Set the bit order of transmission (MSB/LSB first) using the builder pattern

This only affects the order of bits within each byte. Bytes are always transferred in little endian order from the 32-bit DATA register.

pub fn bit_order(self, order: BitOrder) -> Self

Set the bit order of transmission (MSB/LSB first) using the builder pattern

This only affects the order of bits within each byte. Bytes are always transferred in little endian order from the 32-bit DATA register.

pub fn get_baud(&mut self) -> Hertz

Get the baud rate

The returned baud rate may not exactly match what was set.

pub fn set_baud(&mut self, baud: impl Into<Hertz>)

Set the baud rate

This function will calculate the best BAUD register setting based on the stored GCLK frequency and desired baud rate. The maximum baud rate is half the GCLK frequency. The minimum baud rate is the GCLK frequency / 512. Values outside this range will saturate at the extremes.

pub fn baud(self, baud: impl Into<Hertz>) -> Self

Set the baud rate using the builder API

This function will calculate the best BAUD register setting based on the stored GCLK frequency and desired baud rate. The maximum baud rate is half the GCLK frequency. The minimum baud rate is the GCLK frequency / 512. Values outside this range will saturate at the extremes.

pub fn get_ibon(&self) -> bool

Read the enabled state of the immediate buffer overflow notification

If set to true, an Error::Overflow will be issued as soon as an overflow occurs. Otherwise, it will not be issued until its place within the data stream.

pub fn set_ibon(&mut self, enabled: bool)

Enable or disable the immediate buffer overflow notification

If set to true, an Error::Overflow will be issued as soon as an overflow occurs. Otherwise, it will not be issued until its place within the data stream.

pub fn ibon(self, enabled: bool) -> Self

Enable or disable the immediate buffer overflow notification using the builder API

If set to true, an Error::Overflow will be issued as soon as an overflow occurs. Otherwise, it will not be issued until its place within the data stream.

pub fn get_run_in_standby(&self) -> bool

Read the enable state of run in standby mode

pub fn set_run_in_standby(&mut self, enabled: bool)

Enable or disable run in standby mode

pub fn run_in_standby(self, enabled: bool) -> Self

Enable or disable run in standby mode using the builder API

pub fn enable(self) -> Spi<Self, P::Capability>where
    Self: ValidConfig,

Enable the SPI peripheral

SPI transactions are not possible until the peripheral is enabled. This function is limited to ValidConfigs.

impl<P, M> Config<P, M, DynLength>where
    P: ValidPads,
    M: OpMode,

pub fn get_dyn_length(&self) -> u8

Get the transaction length

pub fn set_dyn_length(&mut self, length: u8)

Set the transaction length

Write the LENGTH register to set the transaction length. If the length is zero, it will be set to 1.

pub fn dyn_length(self, length: u8) -> Self

Set the transaction length using the builder API

Write the LENGTH register to set the transaction length. If the length is zero, it will be set to 1.

Trait Implementations

impl<P, M, Z> AnyConfig for Config<P, M, Z>where
    P: ValidPads,
    M: OpMode,
    Z: Size,

type Sercom = <P as PadSet>::Sercom

type Pads = P

type Capability = <P as ValidPads>::Capability

type OpMode = M

type Size = Z

type Word = <Z as Length>::Word

impl<P, M, Z> AsMut<Config<P, M, Z>> for Config<P, M, Z>where
    P: ValidPads,
    M: OpMode,
    Z: Size,

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C, A> AsRef<Config<<C as AnyConfig>::Pads, <C as AnyConfig>::OpMode, <C as AnyConfig>::Size>> for Spi<C, A>where
    C: ValidConfig,
    A: Capability,

Get a shared reference to the underlying Config struct

This can be used to call the various get_* functions on Config

fn as_ref(&self) -> &SpecificConfig<C>

Converts this type into a shared reference of the (usually inferred) input type.

impl<P, M, Z> AsRef<Config<P, M, Z>> for Config<P, M, Z>where
    P: ValidPads,
    M: OpMode,
    Z: Size,

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<P, Z> ValidConfig for Config<P, Master, Z>where
    P: ValidPads<SS = NoneT>,
    Z: Size,

impl<P, Z> ValidConfig for Config<P, MasterHWSS, Z>where
    P: ValidPads,
    Z: Size,
    P::SS: SomePad,

impl<P, Z> ValidConfig for Config<P, Slave, Z>where
    P: ValidPads,
    Z: Size,
    P::SS: SomePad,