ledmatrix: Allow setting animation frequency

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

Author: JohnAZoidberg

inputmodule-control/src/inputmodule.rs

@@ -213,6 +213,10 @@ pub fn serial_commands(args: &crate::ClapCli) {
                     start_game_cmd(serialdev, game, ledmatrix_args.game_param);
                 }
 
+                if let Some(fps) = ledmatrix_args.animation_fps {
+                    animation_fps_cmd(serialdev, fps);
+                }
+
                 if ledmatrix_args.stop_game {
                     simple_cmd(
                         serialdev,

inputmodule-control/src/ledmatrix.rs

@@ -117,6 +117,10 @@ pub struct LedMatrixSubcommand {
     #[clap(value_enum)]
     pub stop_game: bool,
 
+    /// Set/get animation FPS
+    #[arg(long)]
+    pub animation_fps: Option<Option<u16>>,
+
     /// Crash the firmware (TESTING ONLY!)
     #[arg(long)]
     pub panic: bool,

ledmatrix/README.md

@@ -64,6 +64,8 @@ Options:
           Paramater for starting the game. Required for some games [possible values: current-matrix, pattern1, blinker, toad, beacon, glider]
       --stop-game
           Stop the currently running game
+      --animation-fps [<ANIMATION_FPS>]
+          Set/get animation FPS
       --panic
           Crash the firmware (TESTING ONLY!)
   -v, --version

ledmatrix/src/main.rs

@@ -189,13 +189,14 @@ fn main() -> ! {
         &clocks.peripheral_clock,
     );
 
-    let mut state = State {
+    let mut state = LedmatrixState {
         grid: percentage(0),
         col_buffer: Grid::default(),
         animate: false,
         brightness: 120,
         sleeping: SleepState::Awake,
         game: None,
+        animation_period: 31_250, // 32 FPS
     };
 
     let mut matrix = LotusLedMatrix::configure(i2c);
@@ -228,7 +229,7 @@ fn main() -> ! {
         //);
 
         // Handle period display updates. Don't do it too often
-        if timer.get_counter().ticks() > prev_timer + 20_000 {
+        if timer.get_counter().ticks() > prev_timer + state.animation_period {
             // On startup slowly turn the screen on - it's a pretty effect :)
             match startup_percentage {
                 Some(p) if p <= 100 => {
@@ -357,7 +358,7 @@ fn get_random_byte(rosc: &RingOscillator<Enabled>) -> u8 {
 
 fn handle_sleep(
     go_sleeping: bool,
-    state: &mut State,
+    state: &mut LedmatrixState,
     matrix: &mut Foo,
     delay: &mut Delay,
     led_enable: &mut gpio::Pin<Gpio29, gpio::Output<gpio::PushPull>>,

lotus-inputmodules/src/control.rs

@@ -338,6 +338,14 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
                 _ => None,
             },
             Some(CommandVals::GameStatus) => Some(Command::GameStatus),
+            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 {
@@ -455,7 +463,7 @@ pub fn handle_generic_command(command: &Command) -> Option<[u8; 32]> {
 #[cfg(feature = "ledmatrix")]
 pub fn handle_command(
     command: &Command,
-    state: &mut State,
+    state: &mut LedmatrixState,
     matrix: &mut Foo,
     random: u8,
 ) -> Option<[u8; 32]> {
@@ -552,6 +560,17 @@ pub fn handle_command(
             None
         }
         Command::GameStatus => None,
+        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),
     }
 }

lotus-inputmodules/src/games/game_of_life.rs

@@ -1,5 +1,5 @@
 use crate::control::{GameControlArg, GameOfLifeStartParam};
-use crate::matrix::{GameState, Grid, State, HEIGHT, WIDTH};
+use crate::matrix::{GameState, Grid, LedmatrixState, HEIGHT, WIDTH};
 
 #[derive(Clone, Copy, num_derive::FromPrimitive)]
 pub enum Cell {
@@ -12,19 +12,19 @@ pub struct GameOfLifeState {
     cells: [[Cell; WIDTH]; HEIGHT],
 }
 
-pub fn start_game(state: &mut State, _random: u8, param: GameOfLifeStartParam) {
+pub fn start_game(state: &mut LedmatrixState, _random: u8, param: GameOfLifeStartParam) {
     let gol = GameOfLifeState::new(param, &state.grid);
     state.grid = gol.draw_matrix();
     state.game = Some(GameState::GameOfLife(gol));
 }
-pub fn handle_control(state: &mut State, arg: &GameControlArg) {
+pub fn handle_control(state: &mut LedmatrixState, arg: &GameControlArg) {
     if let Some(GameState::GameOfLife(ref mut _gol_state)) = state.game {
         if let GameControlArg::Exit = arg {
             state.game = None
         }
     }
 }
-pub fn game_step(state: &mut State, _random: u8) {
+pub fn game_step(state: &mut LedmatrixState, _random: u8) {
     if let Some(GameState::GameOfLife(ref mut gol_state)) = state.game {
         gol_state.tick();
         state.grid = gol_state.draw_matrix();

lotus-inputmodules/src/games/pong.rs

@@ -1,5 +1,5 @@
 use crate::control::GameControlArg;
-use crate::matrix::{GameState, Grid, State, HEIGHT, WIDTH};
+use crate::matrix::{GameState, Grid, LedmatrixState, HEIGHT, WIDTH};
 
 const PADDLE_WIDTH: usize = 5;
 
@@ -28,7 +28,7 @@ pub struct PongState {
     pub speed: u64,
 }
 
-pub fn start_game(state: &mut State, _random: u8) {
+pub fn start_game(state: &mut LedmatrixState, _random: u8) {
     state.game = Some(GameState::Pong(PongState {
         _score: Score {
             _upper: 0,
@@ -42,7 +42,7 @@ pub fn start_game(state: &mut State, _random: u8) {
         speed: 0,
     }))
 }
-pub fn handle_control(state: &mut State, arg: &GameControlArg) {
+pub fn handle_control(state: &mut LedmatrixState, arg: &GameControlArg) {
     if let Some(GameState::Pong(ref mut pong_state)) = state.game {
         match arg {
             GameControlArg::Left => {
@@ -96,7 +96,7 @@ fn hit_paddle(ball: Position, paddles: (usize, usize)) -> Option<usize> {
     }
 }
 
-pub fn game_step(state: &mut State, _random: u8) {
+pub fn game_step(state: &mut LedmatrixState, _random: u8) {
     if let Some(GameState::Pong(ref mut pong_state)) = state.game {
         pong_state.ball.pos = {
             let (vx, vy) = pong_state.ball.direction;

lotus-inputmodules/src/games/snake.rs

@@ -1,5 +1,5 @@
 use crate::control::GameControlArg;
-use crate::matrix::{GameState, Grid, State, HEIGHT, LEDS, WIDTH};
+use crate::matrix::{GameState, Grid, LedmatrixState, HEIGHT, LEDS, WIDTH};
 
 use heapless::Vec;
 
@@ -33,7 +33,7 @@ fn place_food(random: u8) -> Position {
     (x as i8, y as i8)
 }
 
-pub fn start_game(state: &mut State, random: u8) {
+pub fn start_game(state: &mut LedmatrixState, random: u8) {
     state.game = Some(GameState::Snake(SnakeState {
         head: (4, 0),
         direction: HeadDirection::Down,
@@ -42,7 +42,7 @@ pub fn start_game(state: &mut State, random: u8) {
         food: place_food(random),
     }));
 }
-pub fn handle_control(state: &mut State, arg: &GameControlArg) {
+pub fn handle_control(state: &mut LedmatrixState, arg: &GameControlArg) {
     if let Some(GameState::Snake(ref mut snake_state)) = state.game {
         match arg {
             GameControlArg::Up => snake_state.direction = HeadDirection::Up,
@@ -55,7 +55,7 @@ pub fn handle_control(state: &mut State, arg: &GameControlArg) {
     }
 }
 
-pub fn game_step(state: &mut State, random: u8) -> (HeadDirection, bool, usize, Position) {
+pub fn game_step(state: &mut LedmatrixState, random: u8) -> (HeadDirection, bool, usize, Position) {
     if let Some(GameState::Snake(ref mut snake_state)) = state.game {
         if snake_state.game_over {
             return (

lotus-inputmodules/src/matrix.rs

@@ -14,13 +14,14 @@ impl Default for Grid {
     }
 }
 
-pub struct State {
+pub struct LedmatrixState {
     pub grid: Grid,
     pub col_buffer: Grid,
     pub animate: bool,
     pub brightness: u8,
     pub sleeping: SleepState,
     pub game: Option<GameState>,
+    pub animation_period: u64,
 }
 
 #[allow(clippy::large_enum_variant)]