Struct peripherals::Field

pub struct Field<R, T, I> { /* fields omitted */ }

A single register field

Created by:

• Associated constants on register defined with the periph! or the register! macros.

Usable with:

• Reg::field or Value::field: read this field to its specific type.
• Reg::toggle or Value^Field: toggle these fields (only for single-bit fields).

These fields be combined together with |, & and ^, producing Fields.

Example

use peripherals::{register, Value};

register! {
    Register: u8 = 0b1001 {
        BIT1: 0 = struct Bit1(bool);
        BIT2: 1 = struct Bit2(bool);
        TWO_BITS: 2..3 = struct TwoBits(u8);
    }
}

// Obtain it from the associated constants on the register
assert_eq!(Register::BIT1.mask(), 0b0001);
assert_eq!(Register::TWO_BITS.mask(), 0b1100);

// Use it to read fields
let mut value = Value::reset();
assert_eq!(value.value(), 0b1001);

assert_eq!(value.field(Register::BIT1), Bit1(true));
assert_eq!(value.field(Register::BIT2), Bit2(false));
assert_eq!(value.field(Register::TWO_BITS), TwoBits(0b10));

// Toggle single-bit fields
value ^= Register::BIT1;
assert_eq!(value.value(), 0b1000);
value ^= Register::BIT2;
assert_eq!(value.value(), 0b1010);

Implementations

impl<R, T, I> Field<R, T, I>

pub fn mask(self) -> I

Get the raw mask

pub fn offset(self) -> usize

Get the field offset

pub const unsafe fn from_raw(mask: I, offset: usize) -> Field<R, T, I>

Build from raw mask

Safety

You should ensure the mask is valid for the fields of the associated register.

Trait Implementations

impl<R: RegisterValue, T: Into<Fields<R>>, U: MayToggle> BitAnd<T> for Field<R, U, R::Int> where
    T: Either<U::Toggle>, 

type Output = Fields<R, T::Output>

The resulting type after applying the & operator.

fn bitand(self, other: T) -> Self::Output

Performs the & operation.

impl<R: RegisterValue, T: Into<Fields<R>>, U: MayToggle> BitOr<T> for Field<R, U, R::Int> where
    T: Both<U::Toggle>, 

type Output = Fields<R, T::Output>

The resulting type after applying the | operator.

fn bitor(self, other: T) -> Self::Output

Performs the | operation.

impl<R: RegisterValue, T: Into<Fields<R>>, U: MayToggle> BitXor<T> for Field<R, U, R::Int> where
    T: Both<U::Toggle>, 

type Output = Fields<R, T::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, other: T) -> Self::Output

Performs the ^ operation.

impl<R: RegisterValue, T> Clone for Field<R, T, R::Int>

fn clone(&self) -> Field<R, T, R::Int>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: RegisterValue, T> Debug for Field<R, T, R::Int>

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

Formats the value using the given formatter.

impl<R: RegisterValue, T> From<Field<R, T, <R as RegisterValue>::Int>> for Fields<R, ()>

fn from(field: Field<R, T, R::Int>) -> Fields<R, ()>

Performs the conversion.

impl<R: RegisterValue, T: MayToggle<Toggle = Toggle>> From<Field<R, T, <R as RegisterValue>::Int>> for Fields<R, Toggle>

fn from(field: Field<R, T, R::Int>) -> Fields<R, Toggle>

Performs the conversion.

impl<R: RegisterValue, T: MayToggle> MayToggle for Field<R, T, R::Int>

type Toggle = T::Toggle

Toggle if it can be toggled, () otherwise

impl<R: RegisterValue, T: Into<Fields<R>> + Copy, U> PartialEq<T> for Field<R, U, R::Int>

fn eq(&self, other: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<R: RegisterValue, T> Copy for Field<R, T, R::Int>

impl<R: RegisterValue, T> Eq for Field<R, T, R::Int>