diff --git a/examples/log/Cargo.toml b/examples/log/Cargo.toml index f7bfaa802..d96b4207f 100644 --- a/examples/log/Cargo.toml +++ b/examples/log/Cargo.toml @@ -7,4 +7,5 @@ description = "Log output program" [dependencies] xous = { path = "../../xous-rs" } - +#bracket-terminal = "0.8.1" +pancurses = "*" diff --git a/examples/log/src/main.rs b/examples/log/src/main.rs index db74e2197..cb9be7f31 100644 --- a/examples/log/src/main.rs +++ b/examples/log/src/main.rs @@ -8,16 +8,168 @@ mod debug; mod log_string; mod start; -use log_string::LogString; use core::fmt::Write; +use log_string::LogString; + +#[cfg(bracket_terminal)] +mod implementation { + use bracket_terminal::prelude::*; + use core::fmt::{Error, Write}; + use std::sync::mpsc::{channel, Sender}; + use std::thread::{spawn, JoinHandle}; + + struct State {} + + impl GameState for State { + fn tick(&mut self, ctx: &mut BTerm) { + ctx.print(1, 1, "Hello Bracket World"); + } + } + + enum ControlMessage { + Text(String), + Exit, + } + + pub struct Output { + stream: Sender, + context: Option, + gs: Option, + } + + pub fn init() -> Output { + let (tx, rx) = channel(); + + let context = BTermBuilder::simple80x50() + .with_title("Hello Minimal Bracket World") + .build() + .unwrap(); + let gs: State = State {}; + Output { + stream: tx, + context: Some(context), + gs: Some(gs), + } + } + + impl Output { + pub fn run(&mut self) { + main_loop(self.context.take().unwrap(), self.gs.take().unwrap()); + } + } + + impl Drop for Output { + fn drop(&mut self) { + self.stream.send(ControlMessage::Exit).unwrap(); + // self.finish.take().unwrap().join().unwrap(); + } + } + + impl Write for Output { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.stream + .send(ControlMessage::Text(s.to_owned())) + .unwrap(); + Ok(()) + } + } +} #[cfg(not(baremetal))] -mod native_nostd { - pub fn init() {} +mod implementation { + use core::fmt::{Error, Write}; + use pancurses::{endwin, initscr, Window}; + use std::sync::mpsc::{channel, Sender, Receiver}; + + enum ControlMessage { + Text(String), + Exit, + } + + pub struct Output { + window: Option, + tx: Sender, + rx: Receiver, + } + + pub fn init() -> Output { + let (tx, rx) = channel(); + let window = initscr(); + window.nodelay(true); + + Output { + tx, + rx, + window: Some(window), + } + } + + impl Output { + pub fn run(&mut self) { + loop { + match self.rx.recv_timeout(std::time::Duration::from_millis(50)) { + Ok(msg) => { + match msg { + ControlMessage::Exit => break, + ControlMessage::Text(s) => { + self.window.as_ref().unwrap().printw(s); + self.window.as_ref().unwrap().refresh(); + } + } + } + Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { + // Calling `getch` refreshes the screen + self.window.as_ref().unwrap().getch(); + } + Err(e) => panic!("Error: {}", e), + } + } + } + + pub fn get_writer(&self) -> OutputWriter { + OutputWriter { tx: self.tx.clone() } + } + } + + impl Drop for Output { + fn drop(&mut self) { + self.tx.send(ControlMessage::Exit).unwrap(); + endwin(); + } + } + + impl Write for Output { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.tx + .send(ControlMessage::Text(s.to_owned())) + .unwrap(); + Ok(()) + } + } + + pub struct OutputWriter { + tx: Sender, + } + + impl Write for OutputWriter { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + // It would be nice if this worked with &str + self.tx + .send(ControlMessage::Text(s.to_owned())) + .unwrap(); + Ok(()) + } + } } #[cfg(baremetal)] -mod native_nostd { +mod implementation { + pub struct Output { + addr: *mut u32, + } + use core::panic::PanicInfo; #[panic_handler] @@ -37,7 +189,7 @@ mod native_nostd { println!(); } - pub fn init() { + pub fn init() -> Output { let uart = xous::syscall::map_memory( xous::MemoryAddress::new(0xf000_4000), None, @@ -57,44 +209,72 @@ mod native_nostd { } } -#[cfg_attr(baremetal, no_mangle)] -fn main() { - if cfg!(baremetal) { - native_nostd::init(); - } +fn reader_thread(output: &mut implementation::OutputWriter) { + writeln!(output, "Xous Logging Server starting up...").unwrap(); + std::thread::sleep(std::time::Duration::from_secs(1)); - println!("Starting server..."); - let server_addr = - xous::syscall::create_server(xous::make_name!("📜")).expect("couldn't create server"); - println!("Server listening on address {:?}", server_addr); + writeln!(output, "Starting log server...").unwrap(); + let server_addr = xous::create_server(b"xous-logs-output").unwrap(); + writeln!(output, "Server listening on address {:?}", server_addr).unwrap(); let mut counter: usize = 0; loop { if counter.trailing_zeros() >= 12 { - println!("Counter tick: {}", counter); + writeln!(output, "Counter tick: {}", counter).unwrap(); } counter += 1; - println!("Waiting for an event..."); + writeln!(output, "Waiting for an event...").unwrap(); let mut envelope = xous::syscall::receive_message(server_addr).expect("couldn't get address"); - println!("Got message envelope: {:?}", envelope); + writeln!(output, "Got message envelope: {:?}", envelope).unwrap(); match &mut envelope.message { xous::Message::Scalar(msg) => { - println!("Scalar message from {}: {:?}", envelope.sender, msg) + writeln!( + output, + "Scalar message from {}: {:?}", + envelope.sender, msg + ) + .unwrap(); } xous::Message::Move(msg) => { let log_entry = LogString::from_message(msg); - println!("Moved log message from {}: {}", envelope.sender, log_entry); + writeln!( + output, + "Moved log message from {}: {}", + envelope.sender, log_entry + ) + .unwrap(); } xous::Message::Borrow(msg) => { let log_entry = LogString::from_message(msg); - println!("Immutably borrowed log message from {}: {}", envelope.sender, log_entry); + writeln!( + output, + "Immutably borrowed log message from {}: {}", + envelope.sender, log_entry + ) + .unwrap(); } xous::Message::MutableBorrow(msg) => { let mut log_entry = LogString::from_message(msg); - println!("Immutably borrowed log message from {}: {}", envelope.sender, log_entry); + writeln!( + output, + "Immutably borrowed log message from {}: {}", + envelope.sender, log_entry + ) + .unwrap(); writeln!(log_entry, " << HELLO FROM THE SERVER").unwrap(); } } } } + +#[cfg_attr(baremetal, no_mangle)] +fn main() -> Result<(), xous::Error> { + let mut output = implementation::init(); + let mut writer = output.get_writer(); + + xous::create_thread(move || reader_thread(&mut writer)).unwrap(); + + output.run(); + Ok(()) +}