#[repr(transparent)]pub struct Reg<REG: RegisterSpec> { /* private fields */ }
Expand description
This structure provides volatile access to registers.
Implementations
sourceimpl<REG: RegisterSpec> Reg<REG>
impl<REG: RegisterSpec> Reg<REG>
sourceimpl<REG: Readable> Reg<REG>
impl<REG: Readable> Reg<REG>
sourcepub fn read(&self) -> REG::Reader
pub fn read(&self) -> REG::Reader
Reads the contents of a Readable
register.
You can read the raw contents of a register by using bits
:
let bits = periph.reg.read().bits();
or get the content of a particular field of a register:
let reader = periph.reg.read();
let bits = reader.field1().bits();
let flag = reader.field2().bit_is_set();
sourceimpl<REG: Resettable + Writable> Reg<REG>
impl<REG: Resettable + Writable> Reg<REG>
sourcepub fn reset(&self)
pub fn reset(&self)
Writes the reset value to Writable
register.
Resets the register to its initial state.
sourcepub fn write<F>(&self, f: F)where
F: FnOnce(&mut REG::Writer) -> &mut W<REG>,
pub fn write<F>(&self, f: F)where
F: FnOnce(&mut REG::Writer) -> &mut W<REG>,
Writes bits to a Writable
register.
You can write raw bits into a register:
periph.reg.write(|w| unsafe { w.bits(rawbits) });
or write only the fields you need:
periph.reg.write(|w| w
.field1().bits(newfield1bits)
.field2().set_bit()
.field3().variant(VARIANT)
);
In the latter case, other fields will be set to their reset value.
sourceimpl<REG: Writable> Reg<REG>where
REG::Ux: Default,
impl<REG: Writable> Reg<REG>where
REG::Ux: Default,
sourcepub unsafe fn write_with_zero<F>(&self, f: F)where
F: FnOnce(&mut REG::Writer) -> &mut W<REG>,
pub unsafe fn write_with_zero<F>(&self, f: F)where
F: FnOnce(&mut REG::Writer) -> &mut W<REG>,
Writes 0 to a Writable
register.
Similar to write
, but unused bits will contain 0.
sourceimpl<REG: Readable + Writable> Reg<REG>
impl<REG: Readable + Writable> Reg<REG>
sourcepub fn modify<F>(&self, f: F)where
for<'w> F: FnOnce(®::Reader, &'w mut REG::Writer) -> &'w mut W<REG>,
pub fn modify<F>(&self, f: F)where
for<'w> F: FnOnce(®::Reader, &'w mut REG::Writer) -> &'w mut W<REG>,
Modifies the contents of the register by reading and then writing it.
E.g. to do a read-modify-write sequence to change parts of a register:
periph.reg.modify(|r, w| unsafe { w.bits(
r.bits() | 3
) });
or
periph.reg.modify(|_, w| w
.field1().bits(newfield1bits)
.field2().set_bit()
.field3().variant(VARIANT)
);
Other fields will have the value they had before the call to modify
.