Struct Fields 

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

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

where T: Either<U> + Into<Fields<R>>,

type Output = Fields<R, <T as Either<U>>::Output>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<R: RegisterValue, T, U> BitAndAssign<T> for Fields<R, U>

where T: Either<U, Output = U> + Into<Fields<R>>,

fn bitand_assign(&mut self, other: T)

Performs the &= operation.

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

where T: Both<U> + Into<Fields<R>>,

type Output = Fields<R, <T as Both<U>>::Output>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<R: RegisterValue, T, U> BitOrAssign<T> for Fields<R, U>

where T: Both<U, Output = U> + Into<Fields<R>>,

fn bitor_assign(&mut self, other: T)

Performs the |= operation.

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

where T: Both<U> + Into<Fields<R>>,

type Output = Fields<R, <T as Both<U>>::Output>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<R: RegisterValue, T, U> BitXorAssign<T> for Fields<R, U>

where T: Both<U, Output = U> + Into<Fields<R>>,

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 duplicate 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, ()>

Converts to this type from the input type.

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>

Converts to this type from the input type.

impl<R: RegisterValue> From<Fields<R, Toggle>> for Fields<R, ()>

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

Converts to this type from the input type.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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