Struct EngineControl 

pub struct EngineControl {

    pub regs: Registers,
    pub running: bool,
    pub done: bool,
    pub done_unread: bool,
    pub gie: bool,
    pub ier: bool,
    pub isr: bool,
    pub ticks: b64,
    pub start_tick: b64,
    pub done_tick: b64,
    pub ticks_hi: b32,
    pub aw_addr: b12,
    pub aw_have: bool,
    pub w_data: b32,
    pub w_have: bool,
    pub b_valid: bool,
    pub r_valid: bool,
    pub r_data: b32,
}

Resettable control state.

This one register holds the configuration, the run state machine, the timing counters and the AXI4-Lite handshake latches. All of it resets to zero (see Default for Engine), which is the IDLE state with no arguments.

Fields

regs: Registers

Configuration (the host-written arguments).

running: bool

Running: set by ap_start, cleared when the last frame is acknowledged.

done: bool

Finished (sticky until reset). Blocks a second start and any argument write, enforcing one run per reset.

done_unread: bool

ap_done not yet read by the host. ap_ctrl_hs makes ap_done clear on read, so this bit is cleared when AP_CTRL is read.

gie: bool

Global interrupt enable (GIE, bit 0 of 0x004).

ier: bool

Interrupt enable (done) (IER, bit 0 of 0x008).

isr: bool

Interrupt status (done) (ISR, bit 0 of 0x00c). Set when the run finishes; the host toggles it by writing 1.

ticks: b64

Free-running cycle counter (64 bits). Counts every clock from reset; the host uses it both to time the run and, by sampling it twice against its own wall clock, to measure the clock frequency.

start_tick: b64

Tick at start (64 bits): the value of ticks on the cycle the start write was handled.

done_tick: b64

Tick when the last frame was acknowledged (64 bits).

ticks_hi: b32

High half captured when TICKS lo is read. A 64-bit counter is read as two 32-bit words; capturing the high half at the moment the low half is read makes the pair consistent even if the low half wraps in between.

aw_addr: b12

Latched write address (12 bits). AXI4-Lite may deliver the address (AW) and the data (W) on different cycles, so each is held until both have arrived.

aw_have: bool

A write address is latched.

w_data: b32

Latched write data (32 bits).

w_have: bool

Write data is latched.

b_valid: bool

Write response pending (B valid); held until the host’s b_ready.

r_valid: bool

Read data pending (R valid); held until the host’s r_ready.

r_data: b32

Read data (32 bits), held stable while r_valid waits.

Trait Implementations

impl Clone for EngineControl

fn clone(&self) -> EngineControl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineControl

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

Formats the value using the given formatter.

impl Digital for EngineControl

const BITS: usize

Associated constant that gives the total number of bits needed to represent the value.

fn static_kind() -> Kind

Returns the [Kind] (run time type descriptor) of the value as a static method

fn bin(self) -> Box<[BitX]>

Returns the binary representation of the value as a vector of [BitX].

fn dont_care() -> Self

Returns a “don’t care” value for the type.

fn bits() -> usize

Returns the number of bits needed to represent the value.

fn kind(&self) -> Kind

Returns the [Kind] (run time type descriptor) of the value.

fn typed_bits(self) -> TypedBits

Returns the value as a [TypedBits], which includes both the bits and the kind.

fn discriminant(self) -> TypedBits

Returns the discriminant of the value as a [TypedBits].

fn variant_kind(self) -> Kind

Returns the [Kind] of the variant if the value is an enum with variants.

fn binary_string(self) -> String

Returns the binary representation of the value as a string of ‘0’, ‘1’, and ‘X’.

impl PartialEq for EngineControl

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

impl StructuralPartialEq for EngineControl