b1display: Allow updating animation frequency

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

Author: JohnAZoidberg

b1display/README.md

@@ -68,6 +68,8 @@ Options:
           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]
+      --animation-fps [<ANIMATION_FPS>]
+          Set/get animation FPS
       --image-bw <IMAGE_BW>
           Display black&white image (300x400px)
       --clear-ram

b1display/src/main.rs

@@ -44,8 +44,8 @@ use usbd_serial::{SerialPort, USB_CLASS_CDC};
 
 // Used to demonstrate writing formatted strings
 use core::fmt::Debug;
-//use core::fmt::Write;
-//use heapless::String;
+use core::fmt::Write;
+use heapless::String;
 
 use fl16_inputmodules::control::*;
 use fl16_inputmodules::graphics::*;
@@ -68,7 +68,7 @@ type B1ST7306 = ST7306<
 >;
 
 const DEBUG: bool = false;
-const SCRNS_DELTA: i32 = 10;
+const SCRNS_DELTA: i32 = 5;
 const WIDTH: i32 = 300;
 const HEIGHT: i32 = 400;
 const SIZE: Size = Size::new(WIDTH as u32, HEIGHT as u32);
@@ -156,6 +156,7 @@ fn main() -> ! {
             hpm: HpmFps::ThirtyTwo,
             lpm: LpmFps::Two,
         },
+        animation_period: 1_000_000, // 1000ms = 1Hz
     };
 
     const INVERTED: bool = false;
@@ -222,6 +223,7 @@ fn main() -> ! {
 
     let timer = Timer::new(pac.TIMER, &mut pac.RESETS);
     let mut prev_timer = timer.get_counter().ticks();
+    let mut ticks = 0;
 
     let mut logo_pos = Point::new(LOGO_OFFSET_X, LOGO_OFFSET_Y);
 
@@ -231,10 +233,32 @@ fn main() -> ! {
         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 + 500_000 {
+        if timer.get_counter().ticks() > prev_timer + state.animation_period {
             prev_timer = timer.get_counter().ticks();
 
             if let Some(ref mut screensaver) = state.screensaver {
+                let seconds = ticks / (1_000_000 / state.animation_period);
+                #[allow(clippy::modulo_one)]
+                let second_decimals = ticks % (1_000_000 / state.animation_period);
+                Rectangle::new(Point::new(0, 0), Size::new(300, 50))
+                    .into_styled(PrimitiveStyle::with_fill(Rgb565::WHITE))
+                    .draw(&mut disp)
+                    .unwrap();
+                let mut text: String<32> = String::new();
+                write!(
+                    &mut text,
+                    "{:>4} Ticks ({:>4}.{} s)",
+                    ticks, seconds, second_decimals
+                )
+                .unwrap();
+                // Uncomment to draw the ticks on the screen
+                //draw_text(
+                //    &mut disp,
+                //    &text,
+                //    Point::new(0, 0),
+                //).unwrap();
+                ticks += 1;
+
                 logo_pos = {
                     let (x, y) = (logo_pos.x, logo_pos.y);
                     let w = logo_rect.size.width as i32;

fl16-inputmodules/src/control.rs

@@ -63,6 +63,7 @@ pub enum CommandVals {
     ScreenSaver = 0x19,
     SetFps = 0x1A,
     SetPowerMode = 0x1B,
+    AnimationPeriod = 0x1C,
     Version = 0x20,
 }
 
@@ -170,6 +171,8 @@ pub enum Command {
     GetFps,
     SetPowerMode(u8),
     GetPowerMode,
+    SetAnimationPeriod(u16),
+    GetAnimationPeriod,
     _Unknown,
 }
 
@@ -210,6 +213,7 @@ pub struct B1DIsplayState {
     pub screensaver: Option<ScreenSaverState>,
     pub power_mode: PowerMode,
     pub fps_config: FpsConfig,
+    pub animation_period: u64,
 }
 
 pub fn parse_command(count: usize, buf: &[u8]) -> Option<Command> {
@@ -408,6 +412,14 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
             } else {
                 Command::GetPowerMode
             }),
+            Some(CommandVals::AnimationPeriod) => {
+                if count == 3 + 2 {
+                    let period = u16::from_le_bytes([buf[3], buf[4]]);
+                    Some(Command::SetAnimationPeriod(period))
+                } else {
+                    Some(Command::GetAnimationPeriod)
+                }
+            }
             _ => None,
         }
     } else {
@@ -697,6 +709,17 @@ where
             };
             Some(response)
         }
+        Command::SetAnimationPeriod(period) => {
+            state.animation_period = (*period as u64) * 1_000;
+            None
+        }
+        Command::GetAnimationPeriod => {
+            // TODO: Doesn't seem to work when the FPS is 16 or higher
+            let mut response: [u8; 32] = [0; 32];
+            let period_ms = state.animation_period / 1_000;
+            response[0..2].copy_from_slice(&(period_ms as u16).to_le_bytes());
+            Some(response)
+        }
         _ => handle_generic_command(command),
     }
 }

inputmodule-control/src/b1display.rs

@@ -72,6 +72,10 @@ pub struct B1DisplaySubcommand {
     #[arg(long)]
     pub power_mode: Option<Option<PowerMode>>,
 
+    /// Set/get animation FPS
+    #[arg(long)]
+    pub animation_fps: Option<Option<u16>>,
+
     /// Display black&white image (300x400px)
     #[arg(long)]
     pub image_bw: Option<String>,

inputmodule-control/src/inputmodule.rs

@@ -42,6 +42,7 @@ enum Command {
     ScreenSaver = 0x19,
     Fps = 0x1A,
     PowerMode = 0x1B,
+    AnimationPeriod = 0x1C,
     Version = 0x20,
 }
 
@@ -272,6 +273,9 @@ pub fn serial_commands(args: &crate::ClapCli) {
                 if let Some(power_mode) = b1display_args.power_mode {
                     power_mode_cmd(serialdev, power_mode);
                 }
+                if let Some(fps) = b1display_args.animation_fps {
+                    animation_fps_cmd(serialdev, fps);
+                }
                 if let Some(image_path) = &b1display_args.image_bw {
                     b1display_bw_image_cmd(serialdev, image_path);
                 }
@@ -860,6 +864,28 @@ fn set_power_mode(port: &mut Box<dyn SerialPort>, mode: PowerMode) {
     }
 }
 
+fn animation_fps_cmd(serialdev: &str, arg: Option<u16>) {
+    let mut port = serialport::new(serialdev, 115_200)
+        .timeout(SERIAL_TIMEOUT)
+        .open()
+        .expect("Failed to open port");
+
+    if let Some(fps) = arg {
+        let period = (1000 / fps).to_le_bytes();
+        simple_cmd_port(&mut port, Command::AnimationPeriod, &[period[0], period[1]]);
+    } else {
+        simple_cmd_port(&mut port, Command::AnimationPeriod, &[]);
+
+        let mut response: Vec<u8> = vec![0; 32];
+        port.read_exact(response.as_mut_slice())
+            .expect("Found no data!");
+
+        println!("Response: {:X?}", response);
+        let period = u16::from_le_bytes([response[0], response[1]]);
+        println!("Animation Frequency: {}ms / {}Hz", period, 1_000 / period);
+    }
+}
+
 fn set_color_cmd(serialdev: &str, color: Color) {
     let args = match color {
         Color::White => &[0xFF, 0xFF, 0xFF],