Struct Reg 

pub struct Reg<T: Copy, A: Access> { /* private fields */ }

Generic register structure. T refers to the data type of the register. Alternatively, A corresponds to the access level (e.g., read-only, read-write…).

Note

This structure assumes that it points to a valid peripheral register. If so, it is safe to read from or write to the register. However, keep in mind that read-modify-write operations may lead to wrong behavior.

Implementations

impl<T: Copy, A: Access> Reg<T, A>

pub const unsafe fn new(ptr: *mut T) -> Self

Creates a new register from a pointer.

Safety

The pointer must be valid and must be correctly aligned.

pub const fn get_ptr(self) -> *mut T

Returns a pointer to the register.

impl<T: Copy, A: Read> Reg<T, A>

pub fn read(self) -> T

Performs a volatile read of the peripheral register with no side effects.

Note

If you want to perform a read-modify-write operation, use Reg::modify instead.

impl<T: Copy, A: Write> Reg<T, A>

pub fn write(self, val: T)

Performs a volatile write of the peripheral register.

Note

If you want to perform a read-modify-write operation, use Reg::modify instead.

impl<T: Copy, A: Read + Write> Reg<T, A>

pub fn modify<R>(self, f: impl FnOnce(&mut T) -> R) -> R

It modifies the value of the register according to a given function f. After writing the new value to the register, it returns the value returned by f.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

impl<A: Read> Reg<u8, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> u8

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<u8, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: u8)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<u16, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> u16

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<u16, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: u16)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<u32, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> u32

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<u32, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: u32)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<u64, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> u64

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<u64, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: u64)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<u128, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> u128

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<u128, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: u128)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<usize, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> usize

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<usize, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: usize)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<i8, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> i8

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<i8, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: i8)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<i16, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> i16

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<i16, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: i16)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<i32, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> i32

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<i32, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: i32)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<i64, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> i64

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<i64, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: i64)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<i128, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> i128

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<i128, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: i128)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read> Reg<isize, A>

pub fn read_bit(self, n: usize) -> bool

Reads the nth bit of the register.

pub fn read_bits(self, start: usize, end: usize) -> isize

Reads a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<isize, A>

pub fn clear_bit(self, n: usize)

Clears the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn set_bit(self, n: usize)

Sets the nth bit of the register.

Note

It performs a non-atomic read-modify-write operation, which may lead to wrong behavior.

pub fn write_bits(self, start: usize, end: usize, val: isize)

Writes a range of bits of the register specified by the start and end indexes, both included.

impl<A: Read + Write> Reg<u8, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicU8

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<u16, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicU16

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<u32, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicU32

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<u64, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicU64

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<usize, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicUsize

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<i8, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicI8

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<i16, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicI16

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<i32, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicI32

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<i64, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicI64

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

impl<A: Read + Write> Reg<isize, A>

pub unsafe fn as_atomic<'a>(&self) -> &'a AtomicIsize

Creates a new atomic reference to the register.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations for the whole lifetime 'a.

pub unsafe fn atomic_clear_bit(&self, n: usize, order: Ordering)

Clears the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

pub unsafe fn atomic_set_bit(&self, n: usize, order: Ordering)

Sets the nth bit of the register atomically.

Safety

• Register must be properly aligned for atomic operations.
• The register must not be accessed through non-atomic operations until this function returns.

Trait Implementations

impl<T: Clone + Copy, A: Clone + Access> Clone for Reg<T, A>

fn clone(&self) -> Reg<T, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy, A: Debug + Access> Debug for Reg<T, A>

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

Formats the value using the given formatter.

impl<T: PartialEq + Copy, A: PartialEq + Access> PartialEq for Reg<T, A>

fn eq(&self, other: &Reg<T, A>) -> 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<T: Copy + Copy, A: Copy + Access> Copy for Reg<T, A>

impl<T: Eq + Copy, A: Eq + Access> Eq for Reg<T, A>

impl<T: Copy + Send, A: Access> Send for Reg<T, A>

impl<T: Copy, A: Access> StructuralPartialEq for Reg<T, A>

impl<T: Copy + Sync, A: Access> Sync for Reg<T, A>