b1display: Add scrensaver

Appears on power-on and also when resuming from sleep.
Any drawing will disable it.

Signed-off-by: Daniel Schaefer <[email protected]>

Author: JohnAZoidberg

Cargo.lock

@@ -43,8 +43,9 @@ use usb_device::{class_prelude::*, prelude::*};
 use usbd_serial::{SerialPort, USB_CLASS_CDC};
 
 // Used to demonstrate writing formatted strings
-use core::fmt::{Debug, Write};
-use heapless::String;
+use core::fmt::Debug;
+//use core::fmt::Write;
+//use heapless::String;
 
 use lotus_inputmodules::control::*;
 use lotus_inputmodules::graphics::*;
@@ -66,6 +67,12 @@ type B1ST7306 = ST7306<
     200,
 >;
 
+const DEBUG: bool = false;
+const SCRNS_DELTA: i32 = 10;
+const WIDTH: i32 = 300;
+const HEIGHT: i32 = 400;
+const SIZE: Size = Size::new(WIDTH as u32, HEIGHT as u32);
+
 #[entry]
 fn main() -> ! {
     let mut pac = pac::Peripherals::take().unwrap();
@@ -128,7 +135,6 @@ fn main() -> ! {
     let spi = bsp::hal::Spi::<_, _, 8>::new(pac.SPI0);
     // Display control pins
     let dc = pins.dc.into_push_pull_output();
-    //let mut lcd_led = pins.backlight.into_push_pull_output();
     let mut cs = pins.cs.into_push_pull_output();
     cs.set_low().unwrap();
     let rst = pins.rstb.into_push_pull_output();
@@ -157,68 +163,109 @@ fn main() -> ! {
             hpm: HpmFps::ThirtyTwo,
             lpm: LpmFps::One,
         },
-        300,
-        400,
+        WIDTH as u16,
+        HEIGHT as u16,
         COL_START,
         ROW_START,
     );
     disp.init(&mut delay).unwrap();
 
+    // Clear display, might have garbage in display memory
     // TODO: Seems broken
     //disp.clear(Rgb565::WHITE).unwrap();
-    Rectangle::new(Point::new(0, 0), Size::new(300, 400))
+    Rectangle::new(Point::new(0, 0), SIZE)
         .into_styled(PrimitiveStyle::with_fill(Rgb565::WHITE))
         .draw(&mut disp)
         .unwrap();
 
-    let logo_rect = draw_logo(&mut disp).unwrap();
-    Rectangle::new(Point::new(10, 10), Size::new(10, 10))
-        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-        .draw(&mut disp)
-        .unwrap();
-    Rectangle::new(Point::new(20, 20), Size::new(10, 10))
-        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-        .draw(&mut disp)
-        .unwrap();
-    Rectangle::new(Point::new(30, 30), Size::new(10, 10))
-        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-        .draw(&mut disp)
+    let logo_rect = draw_logo(&mut disp, Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y)).unwrap();
+    if DEBUG {
+        Rectangle::new(Point::new(10, 10), Size::new(10, 10))
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(&mut disp)
+            .unwrap();
+        Rectangle::new(Point::new(20, 20), Size::new(10, 10))
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(&mut disp)
+            .unwrap();
+        Rectangle::new(Point::new(30, 30), Size::new(10, 10))
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(&mut disp)
+            .unwrap();
+        Rectangle::new(Point::new(40, 40), Size::new(10, 10))
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(&mut disp)
+            .unwrap();
+        Rectangle::new(Point::new(50, 50), Size::new(10, 10))
+            .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+            .draw(&mut disp)
+            .unwrap();
+        draw_text(
+            &mut disp,
+            "Framework",
+            Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y + logo_rect.size.height as i32),
+        )
         .unwrap();
-    Rectangle::new(Point::new(40, 40), Size::new(10, 10))
-        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-        .draw(&mut disp)
-        .unwrap();
-    Rectangle::new(Point::new(50, 50), Size::new(10, 10))
-        .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-        .draw(&mut disp)
-        .unwrap();
-    draw_text(
-        &mut disp,
-        "Framework",
-        Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y + logo_rect.size.height as i32),
-    )
-    .unwrap();
+    }
+    disp.flush().unwrap();
 
     let sleep = pins.sleep.into_pull_down_input();
 
     let mut state = B1DIsplayState {
         sleeping: SimpleSleepState::Awake,
         screen_inverted: false,
         screen_on: true,
+        screensaver: Some(ScreenSaverState::default()),
     };
 
     let timer = Timer::new(pac.TIMER, &mut pac.RESETS);
     let mut prev_timer = timer.get_counter().ticks();
 
+    let mut logo_pos = Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y);
+
     loop {
         // Go to sleep if the host is sleeping
         let host_sleeping = sleep.is_low().unwrap();
         handle_sleep(host_sleeping, &mut state, &mut delay, &mut disp);
 
         // Handle period display updates. Don't do it too often
-        if timer.get_counter().ticks() > prev_timer + 20_000 {
-            // TODO: Update display
+        if timer.get_counter().ticks() > prev_timer + 500_000 {
             prev_timer = timer.get_counter().ticks();
+
+            if let Some(ref mut screensaver) = state.screensaver {
+                logo_pos = {
+                    let (x, y) = (logo_pos.x, logo_pos.y);
+                    let w = logo_rect.size.width as i32;
+                    let h = logo_rect.size.height as i32;
+
+                    // Bounce off the walls
+                    if x <= 0 || x + w >= WIDTH {
+                        screensaver.rightwards *= -1;
+                    }
+                    if y <= 0 || y + h >= HEIGHT {
+                        screensaver.downwards *= -1;
+                    }
+
+                    Point::new(
+                        x + screensaver.rightwards * SCRNS_DELTA,
+                        y + screensaver.downwards * SCRNS_DELTA,
+                    )
+                };
+                // Draw a border around the new logo, to clear previously drawn adjacent logos
+                let style = PrimitiveStyleBuilder::new()
+                    .stroke_color(Rgb565::WHITE)
+                    .stroke_width(2 * SCRNS_DELTA as u32)
+                    .build();
+                Rectangle::new(
+                    logo_pos - Point::new(SCRNS_DELTA, SCRNS_DELTA),
+                    logo_rect.size + Size::new(2 * SCRNS_DELTA as u32, 2 * SCRNS_DELTA as u32),
+                )
+                .into_styled(style)
+                .draw(&mut disp)
+                .unwrap();
+                draw_logo(&mut disp, logo_pos).unwrap();
+                disp.flush().unwrap();
+            }
         }
 
         // Check for new data
@@ -253,14 +300,14 @@ fn main() -> ! {
                             };
                             // Must write AFTER writing response, otherwise the
                             // client interprets this debug message as the response
-                            let mut text: String<64> = String::new();
-                            write!(
-                                &mut text,
-                                "Handled command {}:{}:{}:{}\r\n",
-                                buf[0], buf[1], buf[2], buf[3]
-                            )
-                            .unwrap();
-                            let _ = serial.write(text.as_bytes());
+                            //let mut text: String<64> = String::new();
+                            //write!(
+                            //    &mut text,
+                            //    "Handled command {}:{}:{}:{}\r\n",
+                            //    buf[0], buf[1], buf[2], buf[3]
+                            //)
+                            //.unwrap();
+                            //let _ = serial.write(text.as_bytes());
                         }
                         _ => {}
                     }
@@ -307,6 +354,10 @@ fn handle_sleep<SPI, DC, CS, RST, const COLS: usize, const ROWS: usize>(
             // Sleep-in has to go into HPM first, so we'll be in HPM after wake-up as well
             disp.switch_mode(delay, PowerMode::Lpm).unwrap();
 
+            // Turn screensaver on when resuming from sleep
+            // TODO Subject to change, but currently I want to avoid burn-in by default
+            state.screensaver = Some(ScreenSaverState::default());
+
             // TODO: Power display controller back on
         }
     }

b1display/src/main.rs

@@ -41,6 +41,10 @@ pub struct B1DisplaySubcommand {
     #[arg(long)]
     pub invert_screen: Option<Option<bool>>,
 
+    /// Screensaver on/off
+    #[arg(long)]
+    pub screen_saver: Option<Option<bool>>,
+
     /// Display black&white image (300x400px)
     #[arg(long)]
     pub image_bw: Option<String>,

inputmodule-control/src/b1display.rs

@@ -39,6 +39,7 @@ enum Command {
     SetPixelColumn = 0x16,
     FlushFramebuffer = 0x17,
     ClearRam = 0x18,
+    ScreenSaver = 0x19,
     Version = 0x20,
 }
 
@@ -260,6 +261,9 @@ pub fn serial_commands(args: &crate::ClapCli) {
                 if let Some(invert_screen) = b1display_args.invert_screen {
                     invert_screen_cmd(serialdev, invert_screen);
                 }
+                if let Some(screensaver_on) = b1display_args.screen_saver {
+                    screensaver_cmd(serialdev, screensaver_on);
+                }
                 if let Some(image_path) = &b1display_args.image_bw {
                     b1display_bw_image_cmd(serialdev, image_path);
                 }
@@ -739,6 +743,26 @@ fn invert_screen_cmd(serialdev: &str, arg: Option<bool>) {
     }
 }
 
+fn screensaver_cmd(serialdev: &str, arg: Option<bool>) {
+    let mut port = serialport::new(serialdev, 115_200)
+        .timeout(SERIAL_TIMEOUT)
+        .open()
+        .expect("Failed to open port");
+
+    if let Some(display_on) = arg {
+        simple_cmd_port(&mut port, Command::ScreenSaver, &[display_on as u8]);
+    } else {
+        simple_cmd_port(&mut port, Command::ScreenSaver, &[]);
+
+        let mut response: Vec<u8> = vec![0; 32];
+        port.read_exact(response.as_mut_slice())
+            .expect("Found no data!");
+
+        let on = response[0] == 1;
+        println!("Currently on: {on}");
+    }
+}
+
 fn set_color_cmd(serialdev: &str, color: Color) {
     let args = match color {
         Color::White => &[0xFF, 0xFF, 0xFF],

inputmodule-control/src/inputmodule.rs

@@ -58,6 +58,7 @@ pub enum CommandVals {
     SetPixelColumn = 0x16,
     FlushFramebuffer = 0x17,
     ClearRam = 0x18,
+    ScreenSaver = 0x19,
     Version = 0x20,
 }
 
@@ -159,6 +160,8 @@ pub enum Command {
     SetPixelColumn(usize, [u8; 50]),
     FlushFramebuffer,
     ClearRam,
+    ScreenSaver(bool),
+    GetScreenSaver,
     _Unknown,
 }
 
@@ -176,11 +179,27 @@ pub struct C1MinimalState {
     pub brightness: u8,
 }
 
+#[derive(Copy, Clone)]
+pub struct ScreenSaverState {
+    pub rightwards: i32,
+    pub downwards: i32,
+}
+
+impl Default for ScreenSaverState {
+    fn default() -> Self {
+        Self {
+            rightwards: 1,
+            downwards: 1,
+        }
+    }
+}
+
 #[cfg(feature = "b1display")]
 pub struct B1DIsplayState {
     pub sleeping: SimpleSleepState,
     pub screen_inverted: bool,
     pub screen_on: bool,
+    pub screensaver: Option<ScreenSaverState>,
 }
 
 pub fn parse_command(count: usize, buf: &[u8]) -> Option<Command> {
@@ -364,6 +383,11 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
             }
             Some(CommandVals::FlushFramebuffer) => Some(Command::FlushFramebuffer),
             Some(CommandVals::ClearRam) => Some(Command::ClearRam),
+            Some(CommandVals::ScreenSaver) => Some(if let Some(on) = arg {
+                Command::ScreenSaver(on == 1)
+            } else {
+                Command::GetScreenSaver
+            }),
             _ => None,
         }
     } else {
@@ -526,6 +550,9 @@ where
         }
         Command::Panic => panic!("Ahhh"),
         Command::SetText(text) => {
+            // Turn screensaver off, when drawing something
+            state.screensaver = None;
+
             clear_text(
                 disp,
                 Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y + logo_rect.size.height as i32),
@@ -539,6 +566,7 @@ where
                 Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y + logo_rect.size.height as i32),
             )
             .unwrap();
+            disp.flush().unwrap();
             None
         }
         Command::DisplayOn(on) => {
@@ -562,6 +590,9 @@ where
             Some(response)
         }
         Command::SetPixelColumn(column, pixel_bytes) => {
+            // Turn screensaver off, when drawing something
+            state.screensaver = None;
+
             let mut pixels: [bool; 400] = [false; 400];
             for (i, byte) in pixel_bytes.iter().enumerate() {
                 pixels[8 * i] = byte & 0b00000001 != 0;
@@ -590,9 +621,26 @@ where
             None
         }
         Command::ClearRam => {
+            // Turn screensaver off, when drawing something
+            state.screensaver = None;
+
             disp.clear_ram().unwrap();
             None
         }
+        Command::ScreenSaver(on) => {
+            state.screensaver = match (*on, state.screensaver) {
+                (true, Some(x)) => Some(x),
+                (true, None) => Some(ScreenSaverState::default()),
+                (false, Some(_)) => None,
+                (false, None) => None,
+            };
+            None
+        }
+        Command::GetScreenSaver => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = state.screensaver.is_some() as u8;
+            Some(response)
+        }
         _ => handle_generic_command(command),
     }
 }

lotus-inputmodules/src/control.rs

@@ -42,12 +42,12 @@ where
     Ok(())
 }
 
-pub fn draw_logo<D>(target: &mut D) -> Result<Rectangle, D::Error>
+pub fn draw_logo<D>(target: &mut D, offset: Point) -> Result<Rectangle, D::Error>
 where
     D: DrawTarget<Color = Rgb565>,
 {
     let bmp: Bmp<Rgb565> = Bmp::from_slice(include_bytes!("../assets/logo.bmp")).unwrap();
-    let image = Image::new(&bmp, Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y));
+    let image = Image::new(&bmp, offset);
     image.draw(target)?;
 
     Ok(image.bounding_box())