Struct serpente::sercom::v2::spi::Config

pub struct Config<P, M = Master, C = EightBit> where
    C: CharSize,
    P: ValidPads,
    M: OpMode,  { /* fields omitted */ }

A configurable, disabled SPI peripheral

This struct represents a configurable SPI peripheral in its disabled state. It is generic over the set of Pads, OpMode and CharSize. Upon creation, the Config takes ownership of the Sercom and resets it, returning it configured as an SPI peripheral in Master OpMode with an EightBit CharSize.

Config uses a builder-pattern API to configure the peripheral, culminating in a call to enable, which consumes the Config and returns an enabled Spi peripheral. The enable function is restricted to ValidConfigs.

Implementations

impl<P> Config<P, Master, EightBit> where
    P: ValidPads, 

pub fn new(
    pm: &PM,
    sercom: <P as PadSet>::Sercom,
    pad_map: P,
    freq: impl Into<Hertz>
) -> Config<P, Master, EightBit>

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, Master OpMode with an EightBit CharSize. Config takes ownership of the Sercom and Pads.

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

impl<P, M, C> Config<P, M, C> where
    C: CharSize,
    P: ValidPads,
    M: OpMode, 

pub fn reset(self) -> Config<P, Master, EightBit>

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

pub unsafe fn sercom(&self) -> &<P as PadSet>::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 free(self) -> (<P as PadSet>::Sercom, P)

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

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

Change the OpMode

pub fn char_size<C2>(self) -> Config<P, M, C2> where
    C2: CharSize, 

Change the CharSize

pub fn cpol(self, cpol: Polarity) -> Config<P, M, C>

Change the clock polarity

pub fn cpha(self, cpha: Phase) -> Config<P, M, C>

Change the clock phase

pub fn spi_mode(self, mode: Mode) -> Config<P, M, C>

Change the SPI mode (clock polarity & phase)

pub fn msb_first(self, msb_first: bool) -> Config<P, M, C>

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

pub fn baud<B>(self, baud: B) -> Config<P, M, C> where
    B: 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 immediate_overflow_notification(&mut self, set: bool)

Control the 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 run_in_standby(&mut self, set: bool)

Run in standby mode

When set, the SPI peripheral will run in standby mode. See the datasheet for more details.

pub fn enable_interrupts(&mut self, flags: Flags)

Enable interrupts for the specified flags

pub fn disable_interrupts(&mut self, flags: Flags)

Disable interrupts for the specified flags

pub fn enable(self) -> Spi<Config<P, M, C>> where
    Config<P, M, C>: ValidConfig, 

Enable the SPI peripheral

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

Trait Implementations

impl<P, M, C> AnyConfig for Config<P, M, C> where
    C: CharSize,
    P: ValidPads,
    M: OpMode, 

type Sercom = <P as PadSet>::Sercom

type Pads = P

type OpMode = M

type CharSize = C

type Word = <C as CharSize>::Word

impl<P, M, C> AsMut<Config<P, M, C>> for Config<P, M, C> where
    C: CharSize,
    P: ValidPads,
    M: OpMode, 

pub fn as_mut(&mut self) -> &mut Config<P, M, C>

Performs the conversion.

impl<P, M, C> AsRef<Config<P, M, C>> for Config<P, M, C> where
    C: CharSize,
    P: ValidPads,
    M: OpMode, 

pub fn as_ref(&self) -> &Config<P, M, C>

Performs the conversion.

impl<P, C> ValidConfig for Config<P, Slave, C> where
    C: CharSize,
    P: ValidPads + TxOrRx,
    <P as PadSet>::SS: SomePad, 

impl<P, C> ValidConfig for Config<P, MasterHWSS, C> where
    C: CharSize,
    P: ValidPads + TxOrRx,
    <P as PadSet>::SS: SomePad, 

impl<P, C> ValidConfig for Config<P, Master, C> where
    C: CharSize,
    P: ValidPads<SS = NoneT> + TxOrRx,