Separate core from desktop target

1 files changed, 130 insertions, 0 deletions

diff --git a/src/desktop/serial.rs b/src/desktop/serial.rs
new file mode 100644
index 0000000..342f7f5
--- /dev/null
+++ b/src/desktop/serial.rs
@@ -0,0 +1,130 @@
+use std::fs::File;
+use std::io::{Read, Write};
+use std::sync::mpsc::{self, Receiver, Sender};
+use std::thread;
+
+use crate::io::Serial;
+
+pub struct UnconnectedSerial {}
+
+impl Serial for UnconnectedSerial {
+    fn write(&mut self, byte: u8) {
+        println!("Writing {} to unconnected serial", byte);
+    }
+
+    fn read(&mut self) -> u8 {
+        println!("Reading 0 from unconnected serial");
+        0
+    }
+
+    fn new_transfer(&mut self) -> bool {
+        false
+    }
+
+    fn clock_master(&mut self) -> bool {
+        false
+    }
+
+    fn set_clock_master(&mut self, _clock_master: bool) {}
+}
+
+pub struct FIFOPackage {
+    t: bool,
+    value: u8,
+}
+
+pub struct FIFOSerial {
+    input: Receiver<u8>,
+    output: Sender<FIFOPackage>,
+    clock_change: Receiver<bool>,
+    last_read_byte: u8,
+    clock_master: bool,
+}
+
+impl FIFOSerial {
+    pub fn new(input_path: String, output_path: String) -> FIFOSerial {
+        let (tx, input) = mpsc::channel::<u8>();
+        let (clock_tx, clock_change) = mpsc::channel::<bool>();
+        thread::spawn(move || {
+            let mut input_f = File::open(input_path).unwrap();
+            loop {
+                let mut byte = [0, 0];
+
+                input_f.read(&mut byte).unwrap();
+                if byte[0] == 1 {
+                    tx.send(byte[1]).unwrap();
+                } else {
+                    clock_tx.send(byte[1] == 0).unwrap();
+                }
+            }
+        });
+
+        let (output, rx) = mpsc::channel::<FIFOPackage>();
+        thread::spawn(move || {
+            let mut output_f = File::create(output_path).unwrap();
+            for b in rx.iter() {
+                if b.t {
+                    output_f.write(&[1, b.value]).unwrap();
+                } else {
+                    output_f.write(&[0, b.value]).unwrap();
+                }
+            }
+        });
+
+        FIFOSerial {
+            input,
+            output,
+            clock_change,
+            last_read_byte: 0xff,
+            clock_master: false,
+        }
+    }
+}
+
+impl Serial for FIFOSerial {
+    fn write(&mut self, byte: u8) {
+        println!("Writing {} to fifo serial", byte);
+        if let Err(err) = self.output.send(FIFOPackage {
+            t: true,
+            value: byte,
+        }) {
+            eprintln!("Error while sending serial package: {}", err);
+        };
+    }
+
+    fn read(&mut self) -> u8 {
+        println!("Reading {} from fifo serial", self.last_read_byte);
+        self.last_read_byte
+    }
+
+    fn new_transfer(&mut self) -> bool {
+        match self.input.try_recv() {
+            Ok(byte) => {
+                println!("Received: {}", byte);
+                self.last_read_byte = byte;
+                true
+            }
+            _ => false,
+        }
+    }
+    fn clock_master(&mut self) -> bool {
+        match self.clock_change.try_recv() {
+            Ok(byte) => {
+                println!("Received clock change, master: {}", byte);
+                self.clock_master = byte;
+            }
+            _ => {}
+        };
+        self.clock_master
+    }
+
+    fn set_clock_master(&mut self, clock_master: bool) {
+        self.clock_master = clock_master;
+        if let Err(err) = self.output.send(FIFOPackage {
+            t: false,
+            value: (if clock_master { 1 } else { 0 }),
+        }) {
+            eprintln!("Error while sending serial package: {}", err);
+        }
+    }
+}