Struct acs::logic::fast::alu::Alu

pub struct Alu {
    pub x: Signal16,
    pub y: Signal16,
    pub zx: Signal,
    pub nx: Signal,
    pub zy: Signal,
    pub ny: Signal,
    pub f: Signal,
    pub no: Signal,
    pub out: Signal16,
    pub zr: Signal,
    pub ng: Signal,
}

Arithmetic Logic Unit

Fields

x: Signal16

y: Signal16

zx: Signal

Set x input to zero

nx: Signal

Negates x input

zy: Signal

Set y input to zero

ny: Signal

f: Signal

• False selects the & function
• True selects the + function

no: Signal

Negates the output

out: Signal16

zr: Signal

Whether the output is zero

ng: Signal

Whether the output is negative

Implementations

impl Alu

pub fn sim(
    &mut self,
    x: Signal16,
    y: Signal16,
    zx: Signal,
    nx: Signal,
    zy: Signal,
    ny: Signal,
    f: Signal,
    no: Signal
) -> (Signal16, Signal, Signal)

Carries out the ALU simulation.

It takes as input two main signals: x and y. Then the following:

• zx: Set x to zero.
• nx: Negate x.
• zy: Set y to zero.
• ny: Negate y.
• f:
  • LO selects the & function
  • HI selects the + function
• no: Negate out signal.

It can return one of the following: 0, 1, -1, x, y, !x, !y, -x, -y, x+1, y+1, x-1, y-1, x+y, x-y, y-x, x&y, x|y,

And two more signals which tell whether the result is zero or negative in this exact order.

pub fn set_x(&mut self, x: Signal16)

pub fn set_y(&mut self, y: Signal16)

pub fn out(&self) -> Signal16

Trait Implementations

impl Default for Alu

fn default() -> Alu

Returns the “default value” for a type.

impl Unit for Alu

fn eval(&mut self)

Evaluates the logic expression as we do with arithmetic without advancing the time.

fn tick(&mut self)

Carries out the tick-phase of a clock cycle: LOW

fn tock(&mut self)

Carries out the tock-phase of a clock cycle: HIGH