USER0

Struct USER0 

Source
pub struct USER0 { /* private fields */ }
Expand description

user0

Implementations§

Source§

impl USER0

Source

pub const PTR: *const RegisterBlock = {0xf0001600 as *const generated::user0::RegisterBlock}

Pointer to the register block

Source

pub const fn ptr() -> *const RegisterBlock

Return the pointer to the register block

Source

pub unsafe fn steal() -> Self

Steal an instance of this peripheral

§Safety

Ensure that the new instance of the peripheral cannot be used in a way that may race with any existing instances, for example by only accessing read-only or write-only registers, or by consuming the original peripheral and using critical sections to coordinate access between multiple new instances.

Additionally, other software such as HALs may rely on only one peripheral instance existing to ensure memory safety; ensure no stolen instances are passed to such software.

Methods from Deref<Target = RegisterBlock>§

Source

pub fn mode(&self) -> &MODE

0x00 - Mode register. This :class:csr.Register contains an array of pin_count read/write fields. Each field is 2-bit wide and its possible values are defined by the :class:PinMode enumeration. If pin_count is 8, then the register has the following fields: .. bitfield:: :bits: 16 [ { “name”: “pin[0]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[1]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[2]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[3]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[4]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[5]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[6]”, “bits”: 2, “attr”: “RW” }, { “name”: “pin[7]”, “bits”: 2, “attr”: “RW” }, ] Parameters ––––– pin_count : :class:int Number of GPIO pins.

Source

pub fn input(&self) -> &INPUT

0x01 - Input register. This :class:csr.Register contains an array of pin_count read-only fields. Each field is 1-bit wide and driven by the input of its associated pin in the :attr:Peripheral.pins array. Values sampled from pin inputs go through :attr:Peripheral.input_stages synchronization stages (on a rising edge of ClockSignal("sync")) before reaching the register. If pin_count is 8, then the register has the following fields: .. bitfield:: :bits: 8 [ { “name”: “pin[0]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[1]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[2]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[3]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[4]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[5]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[6]”, “bits”: 1, “attr”: “R” }, { “name”: “pin[7]”, “bits”: 1, “attr”: “R” }, ] Parameters ––––– pin_count : :class:int Number of GPIO pins.

Source

pub fn output(&self) -> &OUTPUT

0x02 - Output register. This :class:csr.Register contains an array of pin_count read/write fields. Each field is 1-bit wide and drives the output of its associated pin in the :attr:Peripheral.pins array, depending on its associated :class:~Peripheral.Mode field. If pin_count is 8, then the register has the following fields: .. bitfield:: :bits: 8 [ { “name”: “pin[0]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[1]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[2]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[3]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[4]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[5]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[6]”, “bits”: 1, “attr”: “RW” }, { “name”: “pin[7]”, “bits”: 1, “attr”: “RW” }, ] Parameters ––––– pin_count : :class:int Number of GPIO pins.

Source

pub fn set_clr(&self) -> &SET_CLR

0x03 - Output set/clear register. This :class:csr.Register contains an array of pin_count write-only fields. Each field is 2-bit wide; writing it can modify its associated :class:~Peripheral.Output field as a side-effect. If pin_count is 8, then the register has the following fields: .. bitfield:: :bits: 16 [ { “name”: “pin[0]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[1]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[2]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[3]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[4]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[5]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[6]”, “bits”: 2, “attr”: “W” }, { “name”: “pin[7]”, “bits”: 2, “attr”: “W” }, ]

  • Writing 0b01 to a field sets its associated :class:~Peripheral.Output field. - Writing 0b10 to a field clears its associated :class:~Peripheral.Output field. - Writing 0b00 or 0b11 to a field has no side-effect. Parameters ––––– pin_count : :class:int Number of GPIO pins.

Trait Implementations§

Source§

impl Debug for USER0

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Deref for USER0

Source§

type Target = RegisterBlock

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl Send for USER0

Auto Trait Implementations§

§

impl Freeze for USER0

§

impl RefUnwindSafe for USER0

§

impl !Sync for USER0

§

impl Unpin for USER0

§

impl UnwindSafe for USER0

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.