sylveos

main.rs (4010B)

---

 use clap::Parser;
 use indicatif::ProgressStyle;
 use tokio::io::{self, AsyncReadExt, AsyncWriteExt, ReadHalf, Stdout};
 use tokio_serial::{DataBits, FlowControl, Parity, SerialPortBuilderExt, SerialStream, StopBits};
 use tracing::{info, level_filters::LevelFilter, warn};
 use tracing_indicatif::{
     IndicatifLayer,
     filter::{IndicatifFilter, hide_indicatif_span_fields},
 };
 use tracing_subscriber::{
     EnvFilter, Layer, fmt::format::DefaultFields, layer::SubscriberExt, util::SubscriberInitExt,
 };
 
 use std::{path::PathBuf, process::exit, time::Duration};
 
 mod bootload;
 mod sylveos;
 mod tcp;
 
 #[derive(Parser, Debug)]
 #[command(about)]
 struct Args {
     #[arg(short, long, default_value_t = 921600)]
     baud: u32,
     #[arg(short, long, value_hint = clap::ValueHint::FilePath, default_value = "/dev/ttyUSB0")]
     device: String,
     #[arg(short, long, default_value_t = 10.0)]
     timeout: f64,
     #[arg(short, long, default_value = "0x8000", value_parser = hex_value, value_name = "ADDRESS")]
     arm_base: u32,
     #[arg(long, default_value_t = false)]
     tcp: bool,
     #[arg(long, default_value_t = false)]
     sylveos: bool,
     #[arg(value_hint = clap::ValueHint::DirPath)]
     file: PathBuf,
 }
 
 fn hex_value(s: &str) -> Result<u32, String> {
     let trimmed = if let Some(trimmed) = s.strip_prefix("0x") {
         trimmed
     } else {
         s
     };
 
     u32::from_str_radix(trimmed, 16).map_err(|e| e.to_string())
 }
 
 async fn serial_to_stdout(
     serial: &mut ReadHalf<SerialStream>,
     stdout: &mut Stdout,
 ) -> io::Result<()> {
     loop {
         let byte = serial.read_u8().await?;
 
         if byte == 0 {
             info!("pi exited");
             exit(0);
         }
 
         stdout.write_u8(byte).await?;
         stdout.flush().await?;
     }
 }
 
 async fn default_action(port: SerialStream) -> anyhow::Result<()> {
     let (mut port_read, mut port_write) = io::split(port);
     let mut stdin = io::stdin();
     let mut stdout = io::stdout();
 
     tokio::select!(
         _ = io::copy(&mut stdin, &mut port_write) => {
             warn!("stdin disconnected, exiting");
             exit(0);
         },
         _ = serial_to_stdout(&mut port_read, &mut stdout) => {
             warn!("serial port disconnected, exiting");
             exit(0);
         },
     );
 }
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let indicatif_layer = IndicatifLayer::new()
         .with_span_field_formatter(hide_indicatif_span_fields(DefaultFields::new()))
         .with_progress_style(ProgressStyle::with_template(
             "{span_child_prefix}{span_name}{{{span_fields}}} {wide_msg} {elapsed}",
         )?)
         .with_span_child_prefix_symbol("↳ ")
         .with_span_child_prefix_indent(" ");
 
     tracing_subscriber::registry()
         .with(
             EnvFilter::builder()
                 .with_default_directive(LevelFilter::INFO.into())
                 .from_env_lossy(),
         )
         .with(
             tracing_subscriber::fmt::layer()
                 .with_writer(indicatif_layer.get_stderr_writer())
                 .with_target(false),
         )
         .with(indicatif_layer.with_filter(IndicatifFilter::new(false)))
         .init();
 
     let args = Args::parse();
 
     if !PathBuf::from(&args.device).exists() {
         anyhow::bail!("serial device not found");
     }
 
     if !args.file.exists() {
         anyhow::bail!("binary not found");
     }
 
     let mut port = tokio_serial::new(&args.device, args.baud)
         .data_bits(DataBits::Eight)
         .flow_control(FlowControl::None)
         .parity(Parity::None)
         .stop_bits(StopBits::One)
         .timeout(Duration::from_secs_f64(args.timeout))
         .open_native_async()?;
 
     bootload::boot(&mut port, &args.file, args.arm_base).await?;
 
     if args.tcp {
         let (port_read, port_write) = io::split(port);
         tcp::serve(port_read, port_write).await?;
     } else if args.sylveos {
         sylveos::start(port).await?;
     } else {
         default_action(port).await?;
     }
 
     Ok(())
 }