b1display: Allow set/get of FPS and power mode

JohnAZoidberg · JohnAZoidberg · commit 865119a284c9 · 2023-03-24T01:01:46.000+08:00
Signed-off-by: Daniel Schaefer &lt;dhs@frame.work&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/b1display/README.md b/b1display/README.md
@@ -64,6 +64,10 @@ Options:
           Invert screen on/off [possible values: true, false]
       --screen-saver [<SCREEN_SAVER>]
           Screensaver on/off [possible values: true, false]
+      --fps [<FPS>]
+          Set/get FPS [possible values: quarter, half, one, two, four, eight, sixteen, thirty-two]
+      --power-mode [<POWER_MODE>]
+          Set/get power mode [possible values: low, high]
       --image-bw <IMAGE_BW>
           Display black&white image (300x400px)
       --clear-ram
diff --git a/b1display/src/main.rs b/b1display/src/main.rs
@@ -146,6 +146,18 @@ fn main() -> ! {
         &embedded_hal::spi::MODE_0,
     );
 
+    let mut state = B1DIsplayState {
+        sleeping: SimpleSleepState::Awake,
+        screen_inverted: false,
+        screen_on: true,
+        screensaver: Some(ScreenSaverState::default()),
+        power_mode: PowerMode::Lpm,
+        fps_config: FpsConfig {
+            hpm: HpmFps::ThirtyTwo,
+            lpm: LpmFps::Two,
+        },
+    };
+
     const INVERTED: bool = false;
     const AUTO_PWRDOWN: bool = true;
     const TE_ENABLE: bool = true;
@@ -159,10 +171,7 @@ fn main() -> ! {
         INVERTED,
         AUTO_PWRDOWN,
         TE_ENABLE,
-        FpsConfig {
-            hpm: HpmFps::ThirtyTwo,
-            lpm: LpmFps::One,
-        },
+        state.fps_config,
         WIDTH as u16,
         HEIGHT as u16,
         COL_START,
@@ -211,13 +220,6 @@ fn main() -> ! {
 
     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();
 
@@ -286,16 +288,16 @@ fn main() -> ! {
                         (Some(c @ Command::BootloaderReset), _)
                         | (Some(c @ Command::IsSleeping), _) => {
                             if let Some(response) =
-                                handle_command(&c, &mut state, logo_rect, &mut disp)
+                                handle_command(&c, &mut state, logo_rect, &mut disp, &mut delay)
                             {
                                 let _ = serial.write(&response);
                             };
                         }
                         (Some(command), SimpleSleepState::Awake) => {
                             // While sleeping no command is handled, except waking up
-                            if let Some(response) =
-                                handle_command(&command, &mut state, logo_rect, &mut disp)
-                            {
+                            if let Some(response) = handle_command(
+                                &command, &mut state, logo_rect, &mut disp, &mut delay,
+                            ) {
                                 let _ = serial.write(&response);
                             };
                             // Must write AFTER writing response, otherwise the
@@ -352,7 +354,9 @@ fn handle_sleep<SPI, DC, CS, RST, const COLS: usize, const ROWS: usize>(
             //disp.on_off(true).unwrap();
             disp.sleep_out(delay).unwrap();
             // 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();
+            if state.power_mode == PowerMode::Lpm {
+                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
diff --git a/control.py b/control.py
@@ -41,6 +41,8 @@ class CommandVals(IntEnum):
     FlushFramebuffer = 0x17
     ClearRam = 0x18
     ScreenSaver = 0x19
+    SetFps = 0x1A
+    SetPowerMode = 0x1B
     Version = 0x20
 
 
@@ -120,6 +122,9 @@ class GameControlVal(IntEnum):
 
 RGB_COLORS = ['white', 'black', 'red', 'green',
               'blue', 'cyan', 'yellow', 'purple']
+SCREEN_FPS = ['quarter', 'half', 'one', 'two', 'four', 'eight', 'sixteen', 'thirtytwo']
+HIGH_FPS_MASK = 0b00010000
+LOW_FPS_MASK = 0b00000111
 
 SERIAL_DEV = None
 
@@ -196,6 +201,14 @@ def main():
                         action=argparse.BooleanOptionalAction)
     parser.add_argument("--screen-saver", help="Turn on/off screensaver",
                         action=argparse.BooleanOptionalAction)
+    parser.add_argument("--set-fps", help="Set screen FPS",
+                        choices=SCREEN_FPS)
+    parser.add_argument("--set-power-mode", help="Set screen power mode",
+                        choices=['high', 'low'])
+    parser.add_argument("--get-fps", help="Set screen FPS",
+                        action='store_true')
+    parser.add_argument("--get-power-mode", help="Set screen power mode",
+                        action='store_true')
     parser.add_argument("--b1image", help="On the B1 display, show a PNG or GIF image in black and white only)",
                         type=argparse.FileType('rb'))
 
@@ -282,6 +295,14 @@ def main():
         invert_screen_cmd(args.invert_screen)
     elif args.screen_saver is not None:
         screen_saver_cmd(args.screen_saver)
+    elif args.set_fps is not None:
+        set_fps_cmd(args.set_fps)
+    elif args.set_power_mode is not None:
+        set_power_mode_cmd(args.set_power_mode)
+    elif args.get_fps:
+        get_fps_cmd()
+    elif args.get_power_mode:
+        get_power_mode_cmd()
     elif args.b1image is not None:
         b1image_bl(args.b1image)
     elif args.version:
@@ -1073,6 +1094,92 @@ def screen_saver_cmd(on):
     send_command(CommandVals.ScreenSaver, [on])
 
 
+def set_fps_cmd(mode):
+    res = send_command(CommandVals.SetFps, with_response=True)
+    current_fps = res[0]
+
+    if mode == 'quarter':
+        fps = current_fps & ~LOW_FPS_MASK
+        fps |= 0b000
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('low')
+    elif mode == 'half':
+        fps = current_fps & ~LOW_FPS_MASK
+        fps |= 0b001
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('low')
+    elif mode == 'one':
+        fps = current_fps & ~LOW_FPS_MASK
+        fps |= 0b010
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('low')
+    elif mode == 'two':
+        fps = current_fps & ~LOW_FPS_MASK
+        fps |= 0b011
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('low')
+    elif mode == 'four':
+        fps = current_fps & ~LOW_FPS_MASK
+        fps |= 0b100
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('low')
+    elif mode == 'eight':
+        fps = current_fps & ~LOW_FPS_MASK
+        fps |= 0b101
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('low')
+    elif mode == 'sixteen':
+        fps = current_fps & ~HIGH_FPS_MASK
+        fps |= 0b00000000
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('high')
+    elif mode == 'thirtytwo':
+        fps = current_fps & ~HIGH_FPS_MASK
+        fps |= 0b00010000
+        send_command(CommandVals.SetFps, [fps])
+        set_power_mode_cmd('high')
+
+
+def set_power_mode_cmd(mode):
+    if mode == 'low':
+        send_command(CommandVals.SetPowerMode, [0])
+    elif mode == 'high':
+        send_command(CommandVals.SetPowerMode, [1])
+    else:
+        print("Unsupported power mode")
+        sys.exit(1)
+
+def get_power_mode_cmd():
+    res = send_command(CommandVals.SetPowerMode, with_response=True)
+    current_mode = int(res[0])
+    if current_mode == 0:
+        print(f"Current Power Mode: Low Power")
+    elif current_mode == 1:
+        print(f"Current Power Mode: High Power")
+
+def get_fps_cmd():
+    res = send_command(CommandVals.SetFps, with_response=True)
+    current_fps = res[0]
+    res = send_command(CommandVals.SetPowerMode, with_response=True)
+    current_mode = int(res[0])
+
+    if current_mode == 0:
+        current_fps &= LOW_FPS_MASK
+        if current_fps == 0:
+            fps = 0.25
+        elif current_fps == 1:
+            fps = 0.5
+        else:
+            fps = 2 ** (current_fps - 2)
+    elif current_mode == 1:
+        if current_fps & HIGH_FPS_MASK:
+            fps = 32
+        else:
+            fps = 16
+
+    print(f"Current FPS: {fps}")
+
+
 # 5x6 symbol font. Leaves 2 pixels on each side empty
 # We can leave one row empty below and then the display fits 5 of these digits.
 
diff --git a/fl16-inputmodules/src/control.rs b/fl16-inputmodules/src/control.rs
@@ -8,6 +8,8 @@ use crate::graphics::*;
 #[cfg(feature = "b1display")]
 use core::fmt::{Debug, Write};
 #[cfg(feature = "b1display")]
+use cortex_m::delay::Delay;
+#[cfg(feature = "b1display")]
 use embedded_graphics::Pixel;
 #[cfg(feature = "b1display")]
 use embedded_graphics::{
@@ -22,7 +24,7 @@ use embedded_hal::digital::v2::OutputPin;
 #[cfg(feature = "b1display")]
 use heapless::String;
 #[cfg(feature = "b1display")]
-use st7306_lcd::ST7306;
+use st7306_lcd::{FpsConfig, PowerMode, ST7306};
 
 #[cfg(feature = "ledmatrix")]
 use crate::games::pong;
@@ -59,6 +61,8 @@ pub enum CommandVals {
     FlushFramebuffer = 0x17,
     ClearRam = 0x18,
     ScreenSaver = 0x19,
+    SetFps = 0x1A,
+    SetPowerMode = 0x1B,
     Version = 0x20,
 }
 
@@ -162,6 +166,10 @@ pub enum Command {
     ClearRam,
     ScreenSaver(bool),
     GetScreenSaver,
+    SetFps(u8),
+    GetFps,
+    SetPowerMode(u8),
+    GetPowerMode,
     _Unknown,
 }
 
@@ -200,6 +208,8 @@ pub struct B1DIsplayState {
     pub screen_inverted: bool,
     pub screen_on: bool,
     pub screensaver: Option<ScreenSaverState>,
+    pub power_mode: PowerMode,
+    pub fps_config: FpsConfig,
 }
 
 pub fn parse_command(count: usize, buf: &[u8]) -> Option<Command> {
@@ -388,6 +398,16 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
             } else {
                 Command::GetScreenSaver
             }),
+            Some(CommandVals::SetFps) => Some(if let Some(fps) = arg {
+                Command::SetFps(fps)
+            } else {
+                Command::GetFps
+            }),
+            Some(CommandVals::SetPowerMode) => Some(if let Some(mode) = arg {
+                Command::SetPowerMode(mode)
+            } else {
+                Command::GetPowerMode
+            }),
             _ => None,
         }
     } else {
@@ -530,6 +550,7 @@ pub fn handle_command<SPI, DC, CS, RST, const COLS: usize, const ROWS: usize>(
     state: &mut B1DIsplayState,
     logo_rect: Rectangle,
     disp: &mut ST7306<SPI, DC, CS, RST, COLS, ROWS>,
+    delay: &mut Delay,
 ) -> Option<[u8; 32]>
 where
     SPI: spi::Write<u8>,
@@ -641,6 +662,41 @@ where
             response[0] = state.screensaver.is_some() as u8;
             Some(response)
         }
+        Command::SetFps(fps) => {
+            if let Some(fps_config) = FpsConfig::from_u8(*fps) {
+                state.fps_config = fps_config;
+                disp.set_fps(state.fps_config).unwrap();
+                // TODO: Need to reinit the display
+            }
+            None
+        }
+        Command::GetFps => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = state.fps_config.as_u8();
+            Some(response)
+        }
+        Command::SetPowerMode(mode) => {
+            match mode {
+                0 => {
+                    state.power_mode = PowerMode::Lpm;
+                    disp.switch_mode(delay, state.power_mode).unwrap();
+                }
+                1 => {
+                    state.power_mode = PowerMode::Hpm;
+                    disp.switch_mode(delay, state.power_mode).unwrap();
+                }
+                _ => {}
+            }
+            None
+        }
+        Command::GetPowerMode => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = match state.power_mode {
+                PowerMode::Lpm => 0,
+                PowerMode::Hpm => 1,
+            };
+            Some(response)
+        }
         _ => handle_generic_command(command),
     }
 }
diff --git a/inputmodule-control/src/b1display.rs b/inputmodule-control/src/b1display.rs
@@ -7,6 +7,24 @@ pub enum B1Pattern {
     //Checkerboard,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, clap::ValueEnum)]
+pub enum Fps {
+    Quarter,
+    Half,
+    One,
+    Two,
+    Four,
+    Eight,
+    Sixteen,
+    ThirtyTwo,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, clap::ValueEnum)]
+pub enum PowerMode {
+    Low,
+    High,
+}
+
 /// B1 Display
 #[derive(Parser, Debug)]
 #[command(arg_required_else_help = true)]
@@ -45,6 +63,15 @@ pub struct B1DisplaySubcommand {
     #[arg(long)]
     pub screen_saver: Option<Option<bool>>,
 
+    /// Set/get FPS
+    #[arg(long)]
+    #[clap(value_enum)]
+    pub fps: Option<Option<Fps>>,
+
+    /// Set/get power mode
+    #[arg(long)]
+    pub power_mode: Option<Option<PowerMode>>,
+
     /// Display black&white image (300x400px)
     #[arg(long)]
     pub image_bw: Option<String>,
diff --git a/inputmodule-control/src/inputmodule.rs b/inputmodule-control/src/inputmodule.rs
