1 files changed, 84 insertions, 76 deletions

diff --git a/src/devices/system_device.rs b/src/devices/system_device.rs
index 383bb08..097c616 100644
--- a/src/devices/system_device.rs
+++ b/src/devices/system_device.rs
@@ -1,80 +1,78 @@
-use bedrock_core::*;
+use crate::*;
 
 
 pub struct SystemDevice {
-    pub name: ReadBuffer,
-    pub authors: ReadBuffer,
-    pub can_wake: u16,
-    pub wake_id: u8,
+    /// Name and version of this system.
+    pub name: StringBuffer,
+    /// Authors of this system.
+    pub authors: StringBuffer,
+    /// Mask of all devices permitted to wake from sleep.
+    pub wake_mask: u16,
+    /// Slot number of device that most recently woke the system.
+    pub wake_slot: u8,
+    /// True if the system has been put to sleep.
     pub asleep: bool,
+    /// Mask of all connected devices.
+    pub connected_devices: u16,
+    /// Name of the first custom device.
+    pub custom1: StringBuffer,
+    /// Name of the second custom device.
+    pub custom2: StringBuffer,
+    /// Name of the third custom device.
+    pub custom3: StringBuffer,
+    /// Name of the fourth custom device.
+    pub custom4: StringBuffer,
 }
 
-impl SystemDevice {
-    pub fn new() -> Self {
-        let pkg_version = env!("CARGO_PKG_VERSION");
-        let pkg_name = env!("CARGO_PKG_NAME");
-        let pkg_authors = env!("CARGO_PKG_AUTHORS");
-        let name_str = format!("{pkg_name}/{pkg_version}");
-        let authors_str = pkg_authors.replace(":", "\n");
-        Self {
-            name: ReadBuffer::from_str(&name_str),
-            authors: ReadBuffer::from_str(&authors_str),
-            can_wake: 0,
-            wake_id: 0,
-            asleep: false,
-        }
-    }
-
-    pub fn can_wake(&self, dev_id: u8) -> bool {
-        test_bit!(self.can_wake, 0x8000 >> dev_id)
-    }
-}
 
 impl Device for SystemDevice {
     fn read(&mut self, port: u8) -> u8 {
         match port {
-            0x0 => self.name.read(),
-            0x1 => self.authors.read(),
-            0x2 => 0x00,
+            0x0 => 0x00,
+            0x1 => 0x00,
+            0x2 => self.wake_slot,
             0x3 => 0x00,
-            0x4 => 0x00,
-            0x5 => 0x00,
-            0x6 => 0b1111_1100,
-            0x7 => 0b0000_0000,  // TODO: Update when fs and stream implemented
-            0x8 => 0x00,
-            0x9 => 0x00,
-            0xa => self.wake_id,
-            0xb => 0x00,
-            0xc => 0x00,
-            0xd => 0x00,
-            0xe => 0x00,
-            0xf => 0x00,
+            0x4 => self.custom1.read(),
+            0x5 => self.custom2.read(),
+            0x6 => self.custom3.read(),
+            0x7 => self.custom4.read(),
+            0x8 => self.name.read(),
+            0x9 => self.authors.read(),
+            0xA => 0x00,
+            0xB => 0x00,
+            0xC => 0x00,
+            0xD => 0x00,
+            0xE => read_h!(self.connected_devices),
+            0xF => read_l!(self.connected_devices),
             _ => unreachable!(),
         }
     }
 
     fn write(&mut self, port: u8, value: u8) -> Option<Signal> {
         match port {
-            0x0 => self.name.pointer = 0,
-            0x1 => self.authors.pointer = 0,
-            0x2 => (),
-            0x3 => (),
-            0x4 => (),
-            0x5 => (),
-            0x6 => (),
-            0x7 => (),
-            0x8 => write_h!(self.can_wake, value),
-            0x9 => {
-                write_l!(self.can_wake, value);
+            0x0 => write_h!(self.wake_mask, value),
+            0x1 => {
+                write_l!(self.wake_mask, value);
                 self.asleep = true;
                 return Some(Signal::Sleep);
-            },
-            0xa => (),
-            0xb => return Some(Signal::Fork),
-            0xc => (),
-            0xd => (),
-            0xe => (),
-            0xf => (),
+            }
+            0x2 =>  (),
+            0x3 => match value {
+                0 => return Some(Signal::Reset),
+                _ => return Some(Signal::Fork),
+            }
+            0x4 => self.custom1.restart(),
+            0x5 => self.custom2.restart(),
+            0x6 => self.custom3.restart(),
+            0x7 => self.custom4.restart(),
+            0x8 => self.name.restart(),
+            0x9 => self.authors.restart(),
+            0xA => (),
+            0xB => (),
+            0xC => (),
+            0xD => (),
+            0xE => (),
+            0xF => (),
             _ => unreachable!(),
         };
         return None;
@@ -83,29 +81,39 @@ impl Device for SystemDevice {
     fn wake(&mut self) -> bool {
         true
     }
+
+    fn reset(&mut self) {
+        self.wake_mask = 0;
+        self.wake_slot = 0;
+        self.custom1.restart();
+        self.custom2.restart();
+        self.custom3.restart();
+        self.custom4.restart();
+        self.name.restart();
+        self.authors.restart();
+    }
 }
 
 
-pub struct ReadBuffer {
-    pub bytes: Vec<u8>,
-    pub pointer: usize,
-}
+impl SystemDevice {
+    pub fn new(connected_devices: u16) -> Self {
+        let pkg_name = env!("CARGO_PKG_NAME");
+        let pkg_version = env!("CARGO_PKG_VERSION");
+        let pkg_authors = env!("CARGO_PKG_AUTHORS");
+        let name = format!("{pkg_name}/{pkg_version}");
+        let authors = pkg_authors.replace(':', "\n");
 
-impl ReadBuffer {
-    pub fn from_str(text: &str) -> Self {
         Self {
-            bytes: text.bytes().collect(),
-            pointer: 0,
-        }
-    }
-
-    pub fn read(&mut self) -> u8 {
-        let pointer = self.pointer;
-        self.pointer += 1;
-        match self.bytes.get(pointer) {
-            Some(byte) => *byte,
-            None => 0,
+            name: StringBuffer::from_str(&name),
+            authors: StringBuffer::from_str(&authors),
+            wake_mask: 0,
+            wake_slot: 0,
+            asleep: false,
+            connected_devices,
+            custom1: StringBuffer::new(),
+            custom2: StringBuffer::new(),
+            custom3: StringBuffer::new(),
+            custom4: StringBuffer::new(),
         }
     }
 }
-