Trait Peripheral

Help

pub trait Peripheral: Sized {
    type P;

    // Required method
    unsafe fn clone_unchecked(&self) -> Self::P;

    // Provided methods
    fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>
       where Self: 'a { ... }
    fn map_into<U>(self) -> U
       where Self::P: Into<U>,
             U: Peripheral<P = U> { ... }
    fn map<U>(self, transform: impl FnOnce(Self::P) -> U) -> U
       where U: Peripheral<P = U> { ... }
}

Expand description

Trait for any type that can be used as a peripheral of type P.

This is used in driver constructors, to allow passing either owned peripherals (e.g. UART0), or borrowed peripherals (e.g. &mut UART0).

For example, if you have a driver with a constructor like this:

impl<'d, T> Uart<'d, T, Blocking> {
    pub fn new<TX: PeripheralOutput, RX: PeripheralInput>(
        uart: impl Peripheral<P = T> + 'd,
        rx: impl Peripheral<P = RX> + 'd,
        tx: impl Peripheral<P = TX> + 'd,
    ) -> Result<Self, Error> {
        Ok(Self { .. })
    }
}

You may call it with owned peripherals, which yields an instance that can live forever ('static):

let mut uart: Uart<'static, ...> = Uart::new(p.UART0, p.GPIO0, p.GPIO1);

Or you may call it with borrowed peripherals, which yields an instance that can only live for as long as the borrows last:

let mut uart: Uart<'_, ...> = Uart::new(&mut p.UART0, &mut p.GPIO0, &mut p.GPIO1);

§Implementation details, for HAL authors

When writing a HAL, the intended way to use this trait is to take impl Peripheral in the HAL’s public API (such as driver constructors), calling .into_ref() to obtain a PeripheralRef, and storing that in the driver struct.

.into_ref() on an owned T yields a PeripheralRef<'static, T>. .into_ref() on an &'a mut T yields a PeripheralRef<'a, T>.

Required Associated Types§

Source

type P

Peripheral singleton type

Required Methods§

Source

unsafe fn clone_unchecked(&self) -> Self::P

Unsafely clone (duplicate) a peripheral singleton.

§Safety

This returns an owned clone of the peripheral. You must manually ensure only one copy of the peripheral is in use at a time. For example, don’t create two SPI drivers on SPI1, because they will “fight” each other.

You should strongly prefer using into_ref() instead. It returns a PeripheralRef, which allows the borrow checker to enforce this at compile time.

Provided Methods§

Source

fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>
where Self: 'a,

Convert a value into a PeripheralRef.

When called on an owned T, yields a PeripheralRef<'static, T>. When called on an &'a mut T, yields a PeripheralRef<'a, T>.

Source

fn map_into(self) -> U
where Self::P: Into, U: Peripheral,

Map the peripheral using Into.

This converts from Peripheral to Peripheral, using an Into impl to convert from T to U.

Source

fn map(self, transform: impl FnOnce(Self::P) -> U) -> U
where U: Peripheral,

Map the peripheral using Into.

This converts from Peripheral to Peripheral, using an Into impl to convert from T to U.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait PeripheralCopy item path

§Implementation details, for HAL authors

Required Associated Types§

type P

Required Methods§

unsafe fn clone_unchecked(&self) -> Self::P

§Safety

Provided Methods§

fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>where Self: 'a,

fn map_into<U>(self) -> Uwhere Self::P: Into<U>, U: Peripheral<P = U>,

fn map<U>(self, transform: impl FnOnce(Self::P) -> U) -> Uwhere U: Peripheral<P = U>,

Dyn Compatibility§

Implementors§

impl Peripheral for Level

type P = Level

impl Peripheral for AnyGdmaChannel

type P = AnyGdmaChannel

impl Peripheral for AnyGdmaRxChannel

type P = AnyGdmaRxChannel

impl Peripheral for AnyGdmaTxChannel

type P = AnyGdmaTxChannel

impl Peripheral for DmaChannel0

type P = DmaChannel0

impl Peripheral for DmaChannel1

type P = DmaChannel1

impl Peripheral for DmaChannel2

type P = DmaChannel2

impl Peripheral for InputConnection

type P = InputConnection

impl Peripheral for InputSignal

type P = InputSignal

impl Peripheral for OutputConnection

type P = OutputConnection

impl Peripheral for OutputSignal

type P = OutputSignal

impl Peripheral for AnyPin

type P = AnyPin

impl Peripheral for Flex<'_>

type P = Flex<'_>

impl Peripheral for NoPin

type P = NoPin

impl Peripheral for AnyI2c

type P = AnyI2c

impl Peripheral for AnyI2s

type P = AnyI2s

impl Peripheral for ADC1

type P = ADC1

impl Peripheral for AES

type P = AES

impl Peripheral for APB_SARADC

type P = APB_SARADC

impl Peripheral for ASSIST_DEBUG

type P = ASSIST_DEBUG

impl Peripheral for ATOMIC

type P = ATOMIC

impl Peripheral for BT

type P = BT

impl Peripheral for DMA

type P = DMA

impl Peripheral for DS

type P = DS

impl Peripheral for ECC

type P = ECC

impl Peripheral for EFUSE

type P = EFUSE

impl Peripheral for EXTMEM

type P = EXTMEM

impl Peripheral for GPIO

type P = GPIO

impl Peripheral for GPIO_SD

type P = GPIO_SD

impl Peripheral for HINF

type P = HINF

impl Peripheral for HMAC

type P = HMAC

impl Peripheral for HP_APM

type P = HP_APM

impl Peripheral for HP_SYS

type P = HP_SYS

impl Peripheral for I2C0

Trait Peripheral

fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>
where Self: 'a,

fn map_into<U>(self) -> U
where Self::P: Into<U>, U: Peripheral<P = U>,

fn map<U>(self, transform: impl FnOnce(Self::P) -> U) -> U
where U: Peripheral<P = U>,