From f247e557e858b8ad25ca7046ac9ab3459c360889 Mon Sep 17 00:00:00 2001 From: bunnie Date: Tue, 19 Jan 2021 18:58:57 +0800 Subject: [PATCH] now to the point of testing the general message flow in hosted mode --- services/gam/src/canvas.rs | 12 +--------- services/gam/src/lib.rs | 5 +++- services/gam/src/main.rs | 11 ++++++--- services/gam/src/status.rs | 23 +++++++++++------- services/graphics-server/src/api.rs | 6 ++--- services/graphics-server/src/api/text.rs | 30 ++++++++++++++++++++++-- services/graphics-server/src/lib.rs | 4 ++-- services/graphics-server/src/main.rs | 3 ++- services/graphics-server/src/op.rs | 22 ++++++++++++++++- xous-rs/src/string.rs | 4 ++++ xtask/src/main.rs | 3 ++- 11 files changed, 89 insertions(+), 34 deletions(-) diff --git a/services/gam/src/canvas.rs b/services/gam/src/canvas.rs index cf29023e9..9718c9b00 100644 --- a/services/gam/src/canvas.rs +++ b/services/gam/src/canvas.rs @@ -146,7 +146,7 @@ pub fn recompute_canvases(mut canvases: FnvIndexMap, screen: R // so jush pushing it into a max binary heap does the trick. let mut sorted_clipregions: BinaryHeap = BinaryHeap::new(); for (_, &c) in canvases.iter() { - sorted_clipregions.push(c); + sorted_clipregions.push(c).unwrap(); // always succeeds because incoming type is the same size } // now, descend through trust levels and compute intersections, putting the updated drawable states into higher_clipregions @@ -181,13 +181,3 @@ pub fn recompute_canvases(mut canvases: FnvIndexMap, screen: R map } - -// Crate-level draw_textview() call for "local" services that can't use the lib.rs API -pub fn draw_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::Error> { - let mut sendable_tv = Sendable::new(tv).expect("can't create sendable textview"); - sendable_tv.set_op(TextOp::Render); - sendable_tv.lend_mut(gam_cid, sendable_tv.get_op().into()).expect("draw_textview operation failure"); - - sendable_tv.set_op(TextOp::Nop); - Ok(()) -} diff --git a/services/gam/src/lib.rs b/services/gam/src/lib.rs index 5e8f16110..898ffd4d8 100644 --- a/services/gam/src/lib.rs +++ b/services/gam/src/lib.rs @@ -7,7 +7,10 @@ use xous::ipc::*; use core::fmt::Write; use graphics_server::api::{TextOp, TextView}; -pub fn draw_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::Error> { +/// this "posts" a textview -- it's not a "draw" as the update is neither guaranteed nor instantaneous +/// the GAM first has to check that the textview is allowed to be updated, and then it will decide when +/// the actual screen update is allowed +pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::Error> { let mut sendable_tv = Sendable::new(tv).expect("can't create sendable textview"); sendable_tv.set_op(TextOp::Render); sendable_tv.lend_mut(gam_cid, sendable_tv.get_op().into()).expect("draw_textview operation failure"); diff --git a/services/gam/src/main.rs b/services/gam/src/main.rs index 6ab5217a8..b5e32ef64 100644 --- a/services/gam/src/main.rs +++ b/services/gam/src/main.rs @@ -137,7 +137,9 @@ fn tv_draw(gfx_conn: xous::CID, trng_conn: xous::CID, canvases: &mut FnvIndexMap fn xmain() -> ! { log_server::init_wait().unwrap(); + let gam_sid = xous_names::register_name(xous::names::SERVER_NAME_GAM).expect("GAM: can't register server"); info!("GAM: starting up..."); + let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap(); let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap(); @@ -159,8 +161,7 @@ fn xmain() -> ! { // make a thread to manage the status bar xous::create_thread_simple(status_thread, chatlayout.status).expect("GAM: couldn't create status thread"); - let gam_sid = xous_names::register_name(xous::names::SERVER_NAME_GAM).expect("GAM: can't register server"); - + let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); info!("GAM: entering main loop"); loop { let maybe_env = xous::try_receive_message(gam_sid).unwrap(); @@ -204,6 +205,10 @@ fn xmain() -> ! { _ => xous::yield_slice(), } - graphics_server::flush(gfx_conn).expect("GAM: couldn't flush buffer to screen"); + if let Ok(elapsed_time) = ticktimer_server::elapsed_ms(ticktimer_conn) { + if elapsed_time - last_time > 33 { // rate limit updates to 30fps + graphics_server::flush(gfx_conn).expect("GAM: couldn't flush buffer to screen"); + } + } } } diff --git a/services/gam/src/status.rs b/services/gam/src/status.rs index 5c267b4d3..90e72b648 100644 --- a/services/gam/src/status.rs +++ b/services/gam/src/status.rs @@ -17,17 +17,20 @@ pub fn status_thread(status_gid: Gid) { let gfx_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GFX).expect("GAM|status: can't connect to COM"); let gam_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GAM).expect("GAM|status: can't connect to GAM"); + info!("GAM|status: getting screen size"); let screensize = graphics_server::screen_size(gfx_conn).expect("GAM|status: Couldn't get screen size"); + info!("GAM|status: getting height hints"); let small_height: i16 = graphics_server::glyph_height_hint(gfx_conn, blitstr::GlyphStyle::Small).expect("GAM|status: couldn't get glyph height") as i16; - let mut uptime_tv = TextView::new(status_gid, 128, 0, + info!("GAM|status: building textview objects"); + let mut uptime_tv = TextView::new(status_gid, 4096, 0, TextBounds::BoundingBox(Rectangle::new(Point::new(0,0), Point::new(screensize.x / 2, small_height)))); uptime_tv.untrusted = false; uptime_tv.style = blitstr::GlyphStyle::Small; uptime_tv.draw_border = false; uptime_tv.x_margin = 0; uptime_tv.y_margin = 0; - let mut battstats_tv = TextView::new(status_gid, 128, 0, + let mut battstats_tv = TextView::new(status_gid, 4096, 0, TextBounds::BoundingBox(Rectangle::new(Point::new(screensize.x / 2, 0), Point::new(screensize.x, small_height)))); battstats_tv.style = blitstr::GlyphStyle::Small; battstats_tv.draw_border = false; @@ -37,6 +40,7 @@ pub fn status_thread(status_gid: Gid) { let mut stats: BattStats = BattStats::default(); let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); let mut stats_phase: usize = 0; + info!("GAM|status: starting main loop"); loop { let maybe_env = xous::try_receive_message(status_sid).unwrap(); match maybe_env { @@ -46,14 +50,14 @@ pub fn status_thread(status_gid: Gid) { match opcode { com::api::Opcode::BattStatsEvent(s) => { stats = s.clone(); - battstats_tv.text.clear(); + battstats_tv.clear_str(); if stats_phase > 4 { - write!(&mut battstats_tv.text, "{}mV {}mA", stats.voltage, stats.current).expect("GAM|status: can't write string"); + write!(&mut battstats_tv, "{}mV {}mA", stats.voltage, stats.current).expect("GAM|status: can't write string"); } else { - write!(&mut battstats_tv.text, "{}mAh {}%", stats.remaining_capacity, stats.soc).expect("GAM|status: can't write string"); + write!(&mut battstats_tv, "{}mAh {}%", stats.remaining_capacity, stats.soc).expect("GAM|status: can't write string"); } stats_phase = (stats_phase + 1) % 8; - crate::canvas::draw_textview(gam_conn, &mut battstats_tv).expect("GAM|status: can't draw battery stats"); + graphics_server::draw_textview(gfx_conn, &mut battstats_tv).expect("GAM|status: can't draw battery stats"); }, _ => error!("GAM|status received COM event opcode that wasn't expected"), } @@ -66,11 +70,12 @@ pub fn status_thread(status_gid: Gid) { if let Ok(elapsed_time) = ticktimer_server::elapsed_ms(ticktimer_conn) { if elapsed_time - last_time > 500 { + // info!("GAM|status: periodic tasks: updating uptime, requesting battstats"); last_time = elapsed_time; com::get_batt_stats_nb(com_conn).expect("Can't get battery stats from COM"); - uptime_tv.text.clear(); - write!(&mut uptime_tv.text, "Up {:02}:{:2}:{:2}", (elapsed_time / 3_600_000), (elapsed_time / 60_000) % 60, (elapsed_time / 1000) % 60).expect("GAM|status: can't write string"); - crate::canvas::draw_textview(gam_conn, &mut uptime_tv).expect("GAM|status: can't draw uptime"); + uptime_tv.clear_str(); + write!(&mut uptime_tv, "Up {:02}:{:2}:{:2}", (elapsed_time / 3_600_000), (elapsed_time / 60_000) % 60, (elapsed_time / 1000) % 60).expect("GAM|status: can't write string"); + graphics_server::draw_textview(gfx_conn, &mut uptime_tv).expect("GAM|status: can't draw uptime"); } } else { error!("error requesting ticktimer!") diff --git a/services/graphics-server/src/api.rs b/services/graphics-server/src/api.rs index d6953b73c..930a1c3be 100644 --- a/services/graphics-server/src/api.rs +++ b/services/graphics-server/src/api.rs @@ -96,7 +96,7 @@ pub enum Opcode<'a> { QueryGlyphProps(GlyphStyle), /// draws a textview - TextView(&'a TextView<'a>), + TextView(&'a mut TextView<'a>), } impl<'a> core::convert::TryFrom<&'a Message> for Opcode<'a> { @@ -133,13 +133,13 @@ impl<'a> core::convert::TryFrom<&'a Message> for Opcode<'a> { m.arg2 as _, m.arg3 as _, ))), - 14 => Ok(Opcode::QueryGlyphProps(GlyphStyle::from(m.arg1))), _ => Err("unrecognized opcode"), }, Message::BlockingScalar(m) => match m.id { 8 => Ok(Opcode::ScreenSize), 10 => Ok(Opcode::QueryGlyphStyle), 13 => Ok(Opcode::GetCursor), + 14 => Ok(Opcode::QueryGlyphProps(GlyphStyle::from(m.arg1))), _ => Err("unrecognized opcode"), }, Message::Borrow(m) => match m.id { @@ -278,7 +278,7 @@ impl<'a> Into for Opcode<'a> { arg3: 0, arg4: 0, }), - Opcode::QueryGlyphProps(glyph) => Message::Scalar(ScalarMessage { + Opcode::QueryGlyphProps(glyph) => Message::BlockingScalar(ScalarMessage { id: 14, arg1: glyph as usize, arg2: 0, diff --git a/services/graphics-server/src/api/text.rs b/services/graphics-server/src/api/text.rs index 0d26c4d19..dc762345f 100644 --- a/services/graphics-server/src/api/text.rs +++ b/services/graphics-server/src/api/text.rs @@ -48,6 +48,8 @@ impl From for TextOp { #[repr(C)] pub struct TextView<'a> { + // this is the operation as specified for the GAM. Note this is different from the "op" when sent to graphics-server + // only the GAM should be sending TextViews to the graphics-server, and a different coding scheme is used for that link. operation: TextOp, pub untrusted: bool, // render content with random stipples to indicate the strings within are untrusted @@ -59,10 +61,10 @@ pub struct TextView<'a> { // offsets for text drawing -- exactly one of the following options should be specified pub bounds_hint: TextBounds, - pub bounds_computed: Option, // is Some(Rectangle) if bounds have been computed and text has not been modified + bounds_computed: Option, // is Some(Rectangle) if bounds have been computed and text has not been modified pub style: GlyphStyle, - pub text: xous::String<'a>, + text: xous::String<'a>, pub alignment: TextAlignment, pub cursor: Cursor, @@ -105,6 +107,16 @@ impl<'a> TextView<'a> { pub fn set_op(&mut self, op: TextOp) { self.operation = op; } pub fn get_op(&self) -> TextOp { self.operation } pub fn get_canvas_gid(&self) -> Gid { self.canvas } + pub fn get_bounds_computed(&self) -> Option { self.bounds_computed } + pub fn compute_bounds(&mut self) -> Result<(), xous::Error> { + match self.bounds_hint { + TextBounds::BoundingBox(r) => self.bounds_computed = Some(r), + _=> todo!("other dynamic bounds computations not yet implemented"), + } + Ok(()) + } + pub fn clear_str(&mut self) { self.text.clear() } + pub fn to_str(&self) -> &str { self.text.to_str() } } impl<'a> core::fmt::Debug for TextView<'a> { @@ -113,3 +125,17 @@ impl<'a> core::fmt::Debug for TextView<'a> { write!(f, "{}", self.text) } } + + +impl<'a> core::fmt::Display for TextView<'a> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{}", self.text) + } +} + +impl<'a> core::fmt::Write for TextView<'a> { + fn write_str(&mut self, s: &str) -> core::result::Result<(), core::fmt::Error> { + self.bounds_computed = None; + self.text.write_str(s) + } +} \ No newline at end of file diff --git a/services/graphics-server/src/lib.rs b/services/graphics-server/src/lib.rs index c364f75cc..921be9df2 100644 --- a/services/graphics-server/src/lib.rs +++ b/services/graphics-server/src/lib.rs @@ -97,8 +97,8 @@ pub fn glyph_height_hint(cid: CID, glyph: GlyphStyle) -> Result Result<(), xous::Error> { +pub fn draw_textview(cid: CID, tv: &mut TextView) -> Result<(), xous::Error> { let mut sendable_tv = Sendable::new(tv) .expect("can't create sendable TextView structure"); - sendable_tv.lend(cid, 0x100).map(|_| ()) + sendable_tv.lend_mut(cid, 0x100).map(|_| ()) } \ No newline at end of file diff --git a/services/graphics-server/src/main.rs b/services/graphics-server/src/main.rs index 8d800fd73..734723c0e 100644 --- a/services/graphics-server/src/main.rs +++ b/services/graphics-server/src/main.rs @@ -132,7 +132,8 @@ fn xmain() -> ! { .expect("GFX: could not return QueryGlyphProps request"); } Opcode::TextView(tv) => { - + info!("GFX: got draw of {}", tv); + op::textview(display.native_buffer(), tv); } } } else { diff --git a/services/graphics-server/src/op.rs b/services/graphics-server/src/op.rs index 65faf68c2..efce199d1 100644 --- a/services/graphics-server/src/op.rs +++ b/services/graphics-server/src/op.rs @@ -1,4 +1,5 @@ -use crate::api::{Circle, DrawStyle, Line, Pixel, PixelColor, Point, Rectangle}; +use crate::api::{Circle, DrawStyle, Line, Pixel, PixelColor, Point, Rectangle, TextView}; +use log::{error, info}; /// LCD Frame buffer bounds pub const LCD_WORDS_PER_LINE: usize = 11; @@ -230,3 +231,22 @@ pub fn rectangle(fb: &mut LcdFB, rect: Rectangle) { put_pixel(fb, pixel.0.x, pixel.0.y, pixel.1); } } + + +pub fn textview(fb: &mut LcdFB, tv: &mut TextView) { + tv.compute_bounds().expect("GFX: couldn't compute bounds of textview"); + + let mut c = tv.cursor.clone(); + // at this point, bounds_computed *must* be Some() + info!("GFX: painting tv with cursor {:?}, clip {:?}, text {}, style {:?}", c, tv.get_bounds_computed().unwrap(), tv, tv.style); + blitstr::paint_str( + fb, + tv.get_bounds_computed().unwrap().into(), + &mut c, + tv.style, + tv.to_str(), + false, + blitstr::xor_char + ); + tv.cursor = c; +} \ No newline at end of file diff --git a/xous-rs/src/string.rs b/xous-rs/src/string.rs index ababbb082..bba8e4fb5 100644 --- a/xous-rs/src/string.rs +++ b/xous-rs/src/string.rs @@ -94,6 +94,10 @@ impl<'a> String<'a> { )) }; } + + pub fn to_str(&self) -> &str { + self.s + } } impl<'a> core::fmt::Display for String<'a> { diff --git a/xtask/src/main.rs b/xtask/src/main.rs index da77d182d..653ae2caa 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -183,7 +183,8 @@ fn renode_image(debug: bool) -> Result<(), DynError> { fn run(debug: bool) -> Result<(), DynError> { let stream = if debug { "debug" } else { "release" }; let init = [ - "shell", + //"shell", + "gam", "log-server", "graphics-server", "ticktimer-server",