Struct peripherals::Fields

pub struct Fields<R: RegisterValue, T = ()> { /* fields omitted */ }

A set of register fields

Created by:

• Combining (with |) fields generated by the periph! or the register! macro.
• Default or Fields::empty: a set with no fields.

Usable with:

• Reg::fields or Value&Fields: read some FieldValues from the register. They can then be compared or written back.
• Reg::toggle or Value^Fields: toggle these fields (only for single-bit fields).

These fields be combined together with |, & and ^. For operators that returns the same type as their first operand, the “assign” form (i.e. |=, &= and ^=) can also be used.

Example

use peripherals::{register, Fields, Value};

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

// Obtain it with the `empty` method or by combining fields
let empty = Fields::<Register>::empty();
assert_eq!(empty.mask(), 0b0000);
let bits_12 = Register::BIT1 | Register::BIT2;
assert_eq!(bits_12.mask(), 0b0011);
let fields = Register::BIT1 | Register::TWO_BITS;
assert_eq!(fields.mask(), 0b1101);

// Combine fields together
assert_eq!(bits_12 | fields, Register::BIT1 | Register::BIT2 | Register::TWO_BITS);
assert_eq!(bits_12 & fields, Register::BIT1);
assert_eq!(bits_12 ^ fields, Register::BIT2 | Register::TWO_BITS);

assert_eq!(bits_12 | empty, bits_12);
assert_eq!(bits_12 & empty, empty);
assert_eq!(bits_12 ^ empty, bits_12);

let mut value = Value::reset();
assert_eq!(value.value(), 0b1001);

// Use it to read fields
let value_12 = value & (Register::BIT1 | Register::BIT2);
assert_eq!(value_12.bits(), 0b001);
assert_eq!((value & Register::TWO_BITS).bits(), 0b1000);

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

// Write back bits previously read
value |= value_12;
assert_eq!(value.value(), 0b1001);

Implementations

impl<R: RegisterValue, T> Fields<R, T>

pub fn mask(self) -> R::Int

Get the raw mask

pub unsafe fn from_raw(mask: R::Int) -> Fields<R, T>

Build from raw mask

Safety

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

pub fn empty() -> Fields<R, T>

An empty set with no fields

Trait Implementations

impl<R: RegisterValue, T: Into<Fields<R>>, U> BitAnd<T> for Fields<R, U> where
    T: Either<U>, 

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> BitAndAssign<T> for Fields<R, U> where
    T: Either<U, Output = U>, 

fn bitand_assign(&mut self, other: T)

Performs the &= operation.

impl<R: RegisterValue, T: Into<Fields<R>>, U> BitOr<T> for Fields<R, U> where
    T: Both<U>, 

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> BitOrAssign<T> for Fields<R, U> where
    T: Both<U, Output = U>, 

fn bitor_assign(&mut self, other: T)

Performs the |= operation.

impl<R: RegisterValue, T: Into<Fields<R>>, U> BitXor<T> for Fields<R, U> where
    T: Both<U>, 

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: Into<Fields<R>>, U> BitXorAssign<T> for Fields<R, U> where
    T: Both<U, Output = U>, 

fn bitxor_assign(&mut self, other: T)

Performs the ^= operation.

impl<R: RegisterValue, T> Clone for Fields<R, T>

fn clone(&self) -> Fields<R, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: RegisterValue, T> Debug for Fields<R, T>

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

Formats the value using the given formatter.

impl<R: RegisterValue, T> Default for Fields<R, T>

fn default() -> Fields<R, T>

Returns the “default value” for a type.

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> From<Fields<R, Toggle>> for Fields<R, ()>

fn from(fields: Fields<R, Toggle>) -> Fields<R, ()>

Performs the conversion.

impl<R: RegisterValue, T> MayToggle for Fields<R, T>

type Toggle = T

Toggle if it can be toggled, () otherwise

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

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 Fields<R, T>