Merge pull request #45 from firefly-zero/cheat-device

Device support for `cheat`

Author: orsinium

src/args.rs

@@ -248,6 +248,7 @@ pub struct EmulatorArgs {
 
 #[derive(Debug, Parser)]
 pub struct MonitorArgs {
+    /// Path to serial port to connect to a running device.
     #[arg(long, default_value = None)]
     pub port: Option<String>,
 
@@ -257,9 +258,11 @@ pub struct MonitorArgs {
 
 #[derive(Debug, Parser)]
 pub struct LogsArgs {
+    /// Path to serial port to connect to a running device.
     #[arg(long)]
     pub port: String,
 
+    /// The serial port Baud rate.
     #[arg(long, default_value_t = 115_200)]
     pub baud_rate: u32,
 }
@@ -291,6 +294,13 @@ pub struct CheatArgs {
     #[arg()]
     pub value: String,
 
+    /// Path to serial port to connect to a running device.
+    #[arg(long, default_value = None)]
+    pub port: Option<String>,
+
+    #[arg(long, default_value_t = 115_200)]
+    pub baud_rate: u32,
+
     /// Path to the project root.
     #[arg(default_value = ".")]
     pub root: PathBuf,

src/commands/cheat.rs

@@ -1,39 +1,86 @@
 use crate::args::CheatArgs;
 use crate::config::Config;
 use crate::net::connect;
+use crate::serial::SerialStream;
 use anyhow::{bail, Context, Result};
 use firefly_types::{serial, Encode};
 use std::io::{Read, Write};
 use std::path::Path;
 use std::time::Duration;
 
 pub fn cmd_cheat(args: &CheatArgs) -> Result<()> {
+    if let Some(port) = &args.port {
+        cheat_device(args, port)
+    } else {
+        cheat_emulator(args)
+    }
+}
+
+/// Run cheat on desktop emulator.
+pub fn cheat_emulator(args: &CheatArgs) -> Result<()> {
     println!("⏳️  connecting...");
     let mut stream = connect()?;
+    stream.set_read_timeout(Some(Duration::from_secs(1)))?;
 
     {
-        let cmd = parse_command(&args.command, &args.root)?;
-        let val = parse_value(&args.value)?;
-        let req = serial::Request::Cheat(cmd, val);
-        let buf = req.encode_vec().context("encode request")?;
-        println!("⌛  sending request...");
-        stream.write_all(&buf[..]).context("send request")?;
+        let buf = serialize_request(args)?;
+        println!("⌛ sending request...");
+        stream.write_all(&buf).context("send request")?;
         stream.flush().context("flush request")?;
     }
 
-    stream.set_read_timeout(Some(Duration::from_secs(1)))?;
     for _ in 0..5 {
         let mut buf = vec![0; 64];
         stream.read(&mut buf).context("read response")?;
         let resp = serial::Response::decode(&buf).context("decode response")?;
         if let serial::Response::Cheat(result) = resp {
-            println!("✅  response: {result}");
+            println!("✅ response: {result}");
             return Ok(());
         }
     }
     bail!("timed out waiting for response")
 }
 
+/// Run cheat on the connected device.
+pub fn cheat_device(args: &CheatArgs, port: &str) -> Result<()> {
+    println!("⏳️ connecting...");
+    let port = serialport::new(port, args.baud_rate)
+        .timeout(Duration::from_secs(5))
+        .open()
+        .context("open the serial port")?;
+    let mut stream = SerialStream::new(port);
+
+    {
+        let cmd = parse_command(&args.command, &args.root)?;
+        let val = parse_value(&args.value)?;
+        let req = serial::Request::Cheat(cmd, val);
+        println!("⌛ sending request...");
+        stream.send(&req)?;
+    }
+
+    println!("⌛ waiting for response...");
+    for _ in 0..5 {
+        match stream.next() {
+            Ok(serial::Response::Cheat(result)) => {
+                println!("✅  response: {result}");
+                return Ok(());
+            }
+            Ok(serial::Response::Log(log)) => println!("🪵 {log}"),
+            Ok(_) => (),
+            Err(err) => println!("❌ ERROR(cli): {err}"),
+        }
+    }
+    bail!("timed out waiting for response")
+}
+
+fn serialize_request(args: &CheatArgs) -> Result<Vec<u8>> {
+    let cmd = parse_command(&args.command, &args.root)?;
+    let val = parse_value(&args.value)?;
+    let req = serial::Request::Cheat(cmd, val);
+    let buf = req.encode_vec().context("encode request")?;
+    Ok(buf)
+}
+
 /// Parse a cheat command as either an integer or a cheat from firefly.toml.
 fn parse_command(raw: &str, root: &Path) -> Result<i32> {
     if let Ok(n) = raw.parse::<i32>() {

src/commands/logs.rs

@@ -1,60 +1,20 @@
-use crate::args::LogsArgs;
+use crate::{args::LogsArgs, serial::SerialStream};
 use anyhow::{Context, Result};
-use firefly_types::{serial::Response, Encode};
+use firefly_types::serial::Response;
 use std::time::Duration;
 
 pub fn cmd_logs(args: &LogsArgs) -> Result<()> {
-    let mut port = serialport::new(&args.port, args.baud_rate)
-        .timeout(Duration::from_millis(10))
+    let port = serialport::new(&args.port, args.baud_rate)
+        .timeout(Duration::from_secs(3600))
         .open()
         .context("open the serial port")?;
-    let mut buf = Vec::new();
+    let mut stream = SerialStream::new(port);
     println!("listening...");
     loop {
-        let mut chunk = vec![0; 64];
-        let n = match port.read(chunk.as_mut_slice()) {
-            Ok(n) => n,
-            Err(err) => {
-                if err.kind() == std::io::ErrorKind::TimedOut {
-                    continue;
-                }
-                return Err(err).context("read from serial port");
-            }
-        };
-
-        buf.extend_from_slice(&chunk[..n]);
-        loop {
-            let (frame, rest) = advance(&buf);
-            buf = Vec::from(rest);
-            if frame.is_empty() {
-                break;
-            }
-            match Response::decode(&frame) {
-                Ok(Response::Log(log)) => println!("{log}"),
-                Ok(_) => (),
-                Err(err) => println!("invalid message: {err}"),
-            }
-        }
-    }
-}
-
-// Given the binary stream so far, read the first COBS frame and return the rest of bytes.
-pub(super) fn advance(chunk: &[u8]) -> (Vec<u8>, &[u8]) {
-    let max_len = chunk.len();
-    let mut out_buf = vec![0; max_len];
-    let mut dec = cobs::CobsDecoder::new(&mut out_buf);
-    match dec.push(chunk) {
-        Ok(Some((n_out, n_in))) => {
-            let msg = Vec::from(&out_buf[..n_out]);
-            (msg, &chunk[n_in..])
+        match stream.next()? {
+            Response::Log(log) => println!("{log}"),
+            Response::Cheat(val) => println!("cheat response: {val}"),
+            _ => (),
         }
-        Ok(None) => (Vec::new(), chunk),
-        Err(err) => match err {
-            cobs::DecodeError::EmptyFrame => (Vec::new(), &[]),
-            cobs::DecodeError::InvalidFrame { decoded_bytes } => {
-                (Vec::new(), &chunk[decoded_bytes..])
-            }
-            cobs::DecodeError::TargetBufTooSmall => unreachable!(),
-        },
     }
 }

src/commands/monitor.rs

@@ -1,6 +1,6 @@
-use super::logs::advance;
 use crate::args::MonitorArgs;
 use crate::net::connect;
+use crate::serial::{is_timeout, SerialStream};
 use anyhow::{Context, Result};
 use crossterm::{cursor, event, execute, style, terminal};
 use firefly_types::{serial, Encode};
@@ -15,8 +15,6 @@ const RBORD: u16 = 21;
 const KB: u32 = 1024;
 const MB: u32 = 1024 * KB;
 
-type Port = Box<dyn serialport::SerialPort>;
-
 #[derive(Default)]
 struct Stats {
     update: Option<serial::Fuel>,
@@ -54,35 +52,18 @@ pub fn cmd_monitor(_vfs: &Path, args: &MonitorArgs) -> Result<()> {
 }
 
 fn monitor_device(port: &str, args: &MonitorArgs) -> Result<()> {
-    let mut port = connect_device(port, args)?;
+    let mut stream = connect_device(port, args)?;
     let mut stats = Stats::default();
-    request_device_stats(&mut port, &mut stats)?;
-    let mut buf = Vec::new();
+    request_device_stats(&mut stream, &mut stats)?;
     loop {
         if should_exit() {
             return Ok(());
         }
-        buf = read_device(&mut port, buf, &mut stats)?;
+        read_device(&mut stream, &mut stats)?;
         render_stats(&stats).context("render stats")?;
     }
 }
 
-/// Connect to running emulator using serial USB port (JTag-over-USB).
-fn connect_device(port: &str, args: &MonitorArgs) -> Result<Port> {
-    let port = serialport::new(port, args.baud_rate)
-        .timeout(Duration::from_millis(10))
-        .open()
-        .context("open the serial port")?;
-
-    execute!(
-        io::stdout(),
-        terminal::Clear(terminal::ClearType::All),
-        cursor::MoveTo(0, 0),
-        style::Print("waiting for stats..."),
-    )?;
-    Ok(port)
-}
-
 fn monitor_emulator() -> Result<()> {
     let mut stream = connect_emulator()?;
     let mut stats = Stats::default();
@@ -103,39 +84,29 @@ fn read_emulator(mut stream: TcpStream, stats: &mut Stats) -> Result<TcpStream>
         let stream = connect().context("reconnecting")?;
         return Ok(stream);
     }
-    parse_stats(stats, &buf[..size])?;
+    let resp = serial::Response::decode(&buf[..size]).context("decode response")?;
+    parse_stats(stats, resp);
     Ok(stream)
 }
 
 /// Receive and parse one stats message from device.
-fn read_device(port: &mut Port, mut buf: Vec<u8>, stats: &mut Stats) -> Result<Vec<u8>> {
-    let mut chunk = vec![0; 64];
-    let n = match port.read(chunk.as_mut_slice()) {
-        Ok(n) => n,
+fn read_device(stream: &mut SerialStream, stats: &mut Stats) -> Result<()> {
+    match stream.next() {
+        Ok(resp) => {
+            parse_stats(stats, resp);
+            stats.last_msg = Some(Instant::now());
+        }
         Err(err) => {
-            if err.kind() == std::io::ErrorKind::TimedOut {
-                request_device_stats(port, stats)?;
-                return Ok(buf);
+            if !is_timeout(&err) {
+                return Err(err);
             }
-            return Err(err).context("read from serial port");
         }
-    };
-
-    stats.last_msg = Some(Instant::now());
-    buf.extend_from_slice(&chunk[..n]);
-    loop {
-        let (frame, rest) = advance(&buf);
-        buf = Vec::from(rest);
-        if frame.is_empty() {
-            break;
-        }
-        parse_stats(stats, &frame)?;
     }
-    Ok(buf)
+    Ok(())
 }
 
 /// Send a message into the running device requesting to enable stats collection.
-fn request_device_stats(port: &mut Port, stats: &mut Stats) -> Result<()> {
+fn request_device_stats(stream: &mut SerialStream, stats: &mut Stats) -> Result<()> {
     let now = Instant::now();
     let should_update = match stats.last_msg {
         Some(last_msg) => {
@@ -148,16 +119,12 @@ fn request_device_stats(port: &mut Port, stats: &mut Stats) -> Result<()> {
     if should_update {
         stats.last_msg = Some(now);
         let req = serial::Request::Stats(true);
-        let buf = req.encode_vec().context("encode request")?;
-        port.write_all(&buf[..]).context("send request")?;
-        port.flush().context("flush request")?;
+        stream.send(&req)?;
     }
     Ok(())
 }
 
-/// Parse raw stats message using postcard. Does NOT handle COBS frames.
-fn parse_stats(stats: &mut Stats, buf: &[u8]) -> Result<()> {
-    let resp = serial::Response::decode(buf).context("decode response")?;
+fn parse_stats(stats: &mut Stats, resp: serial::Response) {
     match resp {
         serial::Response::Cheat(_) => {}
         serial::Response::Log(log) => {
@@ -180,7 +147,22 @@ fn parse_stats(stats: &mut Stats, buf: &[u8]) -> Result<()> {
         }
         serial::Response::Memory(mem) => stats.mem = Some(mem),
     }
-    Ok(())
+}
+
+/// Connect to running emulator using serial USB port (JTag-over-USB).
+fn connect_device(port: &str, args: &MonitorArgs) -> Result<SerialStream> {
+    let port = serialport::new(port, args.baud_rate)
+        .timeout(Duration::from_millis(10))
+        .open()
+        .context("open the serial port")?;
+
+    execute!(
+        io::stdout(),
+        terminal::Clear(terminal::ClearType::All),
+        cursor::MoveTo(0, 0),
+        style::Print("waiting for stats..."),
+    )?;
+    Ok(SerialStream::new(port))
 }
 
 /// Connect to a running emulator and enable stats.

src/main.rs

@@ -23,6 +23,7 @@ mod images;
 mod langs;
 mod net;
 mod repl_helper;
+mod serial;
 mod vfs;
 mod wasm;