pub trait Peripheral: Sized + Sealed {
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> { ... }
}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<P = ..> 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§
Required Methods§
Sourceunsafe fn clone_unchecked(&self) -> Self::P
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§
Sourcefn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>where
Self: 'a,
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>.
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.