RamRomComputer now reads from ROM and writes to RAM and reads back from RAM

core/src/computers/kim1/mod.rs

@@ -5,7 +5,7 @@ pub mod reset;
 use std::fs;
 use std::path::Path;
 use crate::constants::constants_system::SIZE_1KB;
-use crate::mos6502cpu::cpu::Mos6502Cpu;
+use crate::mos6502cpu::Mos6502Cpu;
 use crate::periph::at28c256::At28C256;
 use crate::periph::hm62256::Hm62256;
 use crate::periph::kim1_keypad::Kim1Keypad;

core/src/computers/ram_rom/backplane.rs

@@ -24,7 +24,28 @@ impl Backplane for RamRomComputer {
     }
 
     fn tick(&mut self) {
-        todo!()
+        println!("Preparing to tick the backplane. - ${:04x} ${:02x} {}", self.address_bus, self.data_bus, self.read_mode);
+
+        // who are we talking to?
+        match self.address_bus {
+            0x0000..=0x3fff => {
+                // RAM
+                println!("ADDRESSING RAM");
+                let (ram_address_bus, ram_data_bus) = self.ram.tick(self.address_bus, self.data_bus, self.read_mode, true);
+                if self.read_mode {
+                    self.data_bus = ram_data_bus;
+                }
+            },
+            0x4000..=0x7fff => {
+                // ROM
+                println!("ADDRESSING ROM");
+                let (rom_address_bus, rom_data_bus) = self.rom.tick(self.address_bus, self.data_bus, self.read_mode);
+                self.data_bus = rom_data_bus;
+            }
+            _ => {
+                // Out of range
+            }
+        }
     }
     fn set_read_mode(&mut self, new_mode: bool) {
         self.read_mode = new_mode;
@@ -41,8 +62,9 @@ impl Backplane for RamRomComputer {
 
 impl RamRomComputer {
     pub fn new() -> RamRomComputer {
+        let rom = At28C256::new(0x4000, 0x7fff, (0..255).collect());
         RamRomComputer {
-            rom: At28C256::default(),
+            rom,
             ram: Hm62256::default(),
             data_bus: 0x00,
             address_bus: 0x0000,

core/src/computers/rom_only/backplane.rs

@@ -1,27 +1,16 @@
-use crate::constants::constants_system::{SIZE_32KB, SIZE_64KB};
-use crate::periph::at28c256::At28C256;
+use crate::computers::rom_only::RomOnlyComputer;
 use crate::periph::backplane::Backplane;
-use crate::periph::rom_chip::RomChip;
-pub struct RomOnlyComputer {
-    rom: At28C256,
-    data_bus: u8,
-    address_bus: u16,
-    read_mode: bool,
-}
 
 impl Backplane for RomOnlyComputer {
     fn data_bus(&self) -> u8 { self.data_bus }
     fn address_bus(&self) -> u16 { self.address_bus }
     fn read_mode(&self) -> bool { self.read_mode }
-
     fn set_read_mode(&mut self, new_mode: bool) {
         self.read_mode = new_mode
     }
-
     fn set_data_bus(&mut self, new_value: u8) {
         self.data_bus = new_value
     }
-
     fn set_address_bus(&mut self, new_value: u16) {
         self.address_bus = new_value
     }
@@ -38,22 +27,3 @@ impl Backplane for RomOnlyComputer {
         println!("COMPUTER: Done ticking.");
     }
 }
-
-impl RomOnlyComputer {
-    pub fn new() -> RomOnlyComputer {
-        let mut working = vec![0x00u8; SIZE_32KB];
-        for index in 0..SIZE_32KB {
-            working[index] = index as u8;
-        }
-        RomOnlyComputer::program(working)
-    }
-
-    pub fn program(rom: Vec<u8>) -> RomOnlyComputer {
-        RomOnlyComputer {
-            rom: At28C256::new(0x000, 0x3fff, rom),
-            address_bus: 0x0000,
-            data_bus: 0x00,
-            read_mode: true,
-        }
-    }
-}

core/src/computers/rom_only/debug_memory.rs

@@ -0,0 +1,13 @@
+use crate::computers::rom_only::RomOnlyComputer;
+
+impl RomOnlyComputer {
+    pub fn debug_memory(&self, start_offset: u16, end_offset: u16) -> Vec<u8> {
+        let mut data = vec![];
+         let size = end_offset - start_offset;
+        for index in 0..size {
+            println!("Index {index} for {}", index + start_offset);
+        }
+
+        data
+    }
+}

core/src/computers/rom_only/mod.rs

@@ -1 +1,14 @@
+use crate::periph::at28c256::At28C256;
+
 pub mod backplane;
+pub mod new;
+pub mod program;
+pub mod debug_memory;
+mod rom_chunks;
+
+pub struct RomOnlyComputer {
+    pub(crate) rom: At28C256,
+    pub(crate) data_bus: u8,
+    pub(crate) address_bus: u16,
+    pub(crate) read_mode: bool,
+}

core/src/computers/rom_only/new.rs

@@ -0,0 +1,13 @@
+use crate::computers::rom_only::RomOnlyComputer;
+use crate::constants::constants_system::SIZE_32KB;
+
+impl RomOnlyComputer {
+    pub fn new() -> RomOnlyComputer {
+        let mut working = vec![0x00u8; SIZE_32KB];
+        for index in 0..SIZE_32KB {
+            working[index] = index as u8;
+        }
+        RomOnlyComputer::program(working)
+    }
+
+}

core/src/computers/rom_only/program.rs

@@ -0,0 +1,14 @@
+use crate::computers::rom_only::RomOnlyComputer;
+use crate::constants::constants_system::SIZE_32KB;
+use crate::periph::at28c256::At28C256;
+
+impl RomOnlyComputer {
+    pub fn program(rom: Vec<u8>) -> RomOnlyComputer {
+        RomOnlyComputer {
+            rom: At28C256::new(0x000, 0x3fff, rom),
+            address_bus: 0x0000,
+            data_bus: 0x00,
+            read_mode: true,
+        }
+    }
+}

core/src/computers/rom_only/rom_chunks.rs

@@ -0,0 +1,8 @@
+use std::slice::Chunks;
+use crate::computers::rom_only::RomOnlyComputer;
+
+impl RomOnlyComputer {
+    pub fn rom_chunks(&self, size: usize) -> Chunks<u8> {
+        self.rom.chunks(size)
+    }
+}