Struct CPU

pub struct CPU {
    pub reg: Registers,
    pub flags: Flags,
    pub pc: u16,
    pub sp: u16,
    pub bus: Bus,
    pub halt: bool,
    pub int: (bool, u8),
    pub inte: bool,
    pub debug: Debug,
    /* private fields */
}

Fields

reg: Registers

flags: Flags

pc: u16

sp: u16

bus: Bus

halt: bool

int: (bool, u8)

Interrupt request : true / false, instruction to execute (normally a RST command)

inte: bool

Interrupt enable bit

debug: Debug

Outputs CPU state and disassembled code to stdout after each execute()

3E 0f     MVI A,$0f
PC : 0x0003	SP : 0xff00	S : 0	Z : 0	A : 0	P : 0	C : 0
B : 0x00	C : 0x00	D : 0x00	E : 0x00	H : 0x00	L : 0x00 ...

Implementations

impl CPU

pub fn export_snapshot(&mut self) -> Vec<u8>

pub fn import_snapshot( &mut self, snapshot: Vec<u8>, ) -> Result<(), SnapshotError>

impl CPU

pub fn new(size: u16) -> CPU

Creates a new CPU instance and its 16 bits address bus.

Examples found in repository

examples/interrupt_test.rs (line 13)

fn load_execute() -> Result<(), Box<dyn Error>> {
    let a: Vec<String> = env::args().collect();
    let mut c = CPU::new(0xFFFF);
    c.debug.switch = true;

    // Loads assembled program into memory
    c.bus.load_bin(&a[1], 0x000)?;

    c.sp = 0xff00;
    c.inte = false;
    c.int = (true, 0xcf);

    loop {
        c.execute();
        println!("{}\n", c.debug.string);
        if c.pc == 0x0000 {
            break;
        } //  if CP/M warm boot -> we exit
    }
    Ok(())
}

examples/cpmrun.rs (line 13)

fn load_execute() -> Result<(), Box<dyn Error>> {
    let a: Vec<String> = env::args().collect();
    let mut c = CPU::new(0xFFFF);
    // Loads assembled program into memory
    c.bus.load_bin(&a[1], 0x100)?;

    // RET at 0x05 for mocking of CP/M BDOS system calls
    c.bus.write_word(0x0005, 0xc9);

    // Setting PC to 0x0100 (CP/M Binaries are loaded with a 256 byte offset)
    c.pc = 0x0100;

    /* Setting up stack : by disassembling CP/M software, it seems
    that the $0006 address is read to set the stack by some programs */
    c.bus.write_word(0x0006, 0xFF00);

    /* Setting up stack in case of the program does not read the $0006 address
    and does not set any stack. */
    c.sp = 0xFF00;

    loop {
        c.execute();
        if c.pc == 0x0005 {
            bdos_call(&c)
        }
        if c.pc == 0x0000 {
            break;
        } //  if CP/M warm boot -> we exit
    }
    Ok(())
}

pub fn set_freq(&mut self, f: f32)

Sets CPU frequency (MHz)

use intel8080::cpu::CPU;
let mut c = CPU::new(0xFFFF);
c.set_freq(1.7);            // CPU will run at 1.7 Mhz

pub fn execute_timed(&mut self) -> Option<u32>

Fetches and executes one instruction from (pc). Returns the sleep time when slice_max_cycles is reached.

pub fn execute(&mut self) -> u32

Fetches and executes one instruction from (pc). Returns the number of consumed clock cycles. No execution speed limit.

Examples found in repository

examples/interrupt_test.rs (line 24)

fn load_execute() -> Result<(), Box<dyn Error>> {
    let a: Vec<String> = env::args().collect();
    let mut c = CPU::new(0xFFFF);
    c.debug.switch = true;

    // Loads assembled program into memory
    c.bus.load_bin(&a[1], 0x000)?;

    c.sp = 0xff00;
    c.inte = false;
    c.int = (true, 0xcf);

    loop {
        c.execute();
        println!("{}\n", c.debug.string);
        if c.pc == 0x0000 {
            break;
        } //  if CP/M warm boot -> we exit
    }
    Ok(())
}

examples/cpmrun.rs (line 32)

fn load_execute() -> Result<(), Box<dyn Error>> {
    let a: Vec<String> = env::args().collect();
    let mut c = CPU::new(0xFFFF);
    // Loads assembled program into memory
    c.bus.load_bin(&a[1], 0x100)?;

    // RET at 0x05 for mocking of CP/M BDOS system calls
    c.bus.write_word(0x0005, 0xc9);

    // Setting PC to 0x0100 (CP/M Binaries are loaded with a 256 byte offset)
    c.pc = 0x0100;

    /* Setting up stack : by disassembling CP/M software, it seems
    that the $0006 address is read to set the stack by some programs */
    c.bus.write_word(0x0006, 0xFF00);

    /* Setting up stack in case of the program does not read the $0006 address
    and does not set any stack. */
    c.sp = 0xFF00;

    loop {
        c.execute();
        if c.pc == 0x0005 {
            bdos_call(&c)
        }
        if c.pc == 0x0000 {
            break;
        } //  if CP/M warm boot -> we exit
    }
    Ok(())
}

impl CPU

pub fn dasm(&self, address: u16) -> String

Disassembles code at (address)