Struct State

pub struct State {

    pub PC: Bitvector<14>,
    pub R: BitvectorArray<5, 8>,
    pub DDRB: Bitvector<8>,
    pub PORTB: Bitvector<8>,
    pub DDRC: Bitvector<7>,
    pub PORTC: Bitvector<7>,
    pub DDRD: Bitvector<8>,
    pub PORTD: Bitvector<8>,
    pub GPIOR0: Bitvector<8>,
    pub GPIOR1: Bitvector<8>,
    pub GPIOR2: Bitvector<8>,
    pub SPL: Bitvector<8>,
    pub SPH: Bitvector<8>,
    pub SREG: Bitvector<8>,
    pub SRAM: BitvectorArray<11, 8>,
}

ATmega328P system state.

Fields

PC: Bitvector<14>

Program counter.

R: BitvectorArray<5, 8>

General-purpose working registers.

32 (2⁵) 8-bit registers.

DDRB: Bitvector<8>

I/O address 0x4: data direction register.

PORTB: Bitvector<8>

I/O address 0x5: output/pullup register.

DDRC: Bitvector<7>

I/O address 0x7: data direction register.

PORTC: Bitvector<7>

I/O address 0x8: output/pullup register.

DDRD: Bitvector<8>

I/O address 0xA: data direction register.

PORTD: Bitvector<8>

I/O address 0xB: output/pullup register.

GPIOR0: Bitvector<8>

I/O address 0x1E: General Purpose I/O register 0.

GPIOR1: Bitvector<8>

I/O address 0x2A: General Purpose I/O register 1.

GPIOR2: Bitvector<8>

I/O address 0x2B: General Purpose I/O register 2.

SPL: Bitvector<8>

I/O address 0x3D: Stack Pointer Low.

SPH: Bitvector<8>

I/O address 0x3E: Stack Pointer High.

SREG: Bitvector<8>

I/O address 0x3F: Status Register.

SRAM: BitvectorArray<11, 8>

Static RAM.

Contains 2K (2¹¹) 8-bit cells.

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for State

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

Formats the value using the given formatter.

impl Hash for State

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for State

fn eq(&self, other: &State) -> 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 Eq for State

impl State for State

impl StructuralPartialEq for State