Implement Snake in firmware

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

Author: JohnAZoidberg

control.py

@@ -80,6 +80,8 @@ def main():
         "--random-eq", help="Random Equalizer", action="store_true")
     parser.add_argument("--wpm", help="WPM Demo", action="store_true")
     parser.add_argument("--snake", help="Snake", action="store_true")
+    parser.add_argument("--snake-embedded",
+                        help="Snake on the module", action="store_true")
     parser.add_argument(
         "--all-brightnesses", help="Show every pixel in a different brightness", action="store_true")
     parser.add_argument("-v", "--version",
@@ -141,6 +143,8 @@ def main():
         wpm_demo()
     elif args.snake:
         snake()
+    elif args.snake_embedded:
+        snake_embedded()
     elif args.eq is not None:
         eq(args.eq)
     elif args.random_eq:
@@ -391,7 +395,7 @@ def opposite_direction(direction):
     return direction
 
 
-def keyscan():
+def snake_keyscan():
     from getkey import getkey, keys
     global direction
     global body
@@ -406,6 +410,28 @@ def keyscan():
             direction = key
 
 
+def snake_embedded_keyscan():
+    from getkey import getkey, keys
+
+    while True:
+        key_arg = None
+        key = getkey()
+        if key == keys.UP:
+            key_arg = 0
+        elif key == keys.DOWN:
+            key_arg = 1
+        elif key == keys.LEFT:
+            key_arg = 2
+        elif key == keys.RIGHT:
+            key_arg = 3
+        elif key == 'q':
+            # Quit
+            key_arg = 4
+        if key_arg is not None:
+            command = FWK_MAGIC + [0x11, key_arg]
+            send_command(command)
+
+
 def game_over():
     global body
     while True:
@@ -418,6 +444,14 @@ def game_over():
         time.sleep(0.75)
 
 
+def snake_embedded():
+    # Start game
+    command = FWK_MAGIC + [0x10, 0x00]
+    send_command(command)
+
+    snake_embedded_keyscan()
+
+
 def snake():
     from getkey import keys
     global direction
@@ -432,7 +466,7 @@ def snake():
     # Setting
     WRAP = False
 
-    thread = threading.Thread(target=keyscan, args=(), daemon=True)
+    thread = threading.Thread(target=snake_keyscan, args=(), daemon=True)
     thread.start()
 
     prev = datetime.now()
@@ -664,7 +698,7 @@ def send_command(command, with_response=False):
 
         if with_response:
             res = s.read(RESPONSE_SIZE)
-            #print(f"Received: {res}")
+            # print(f"Received: {res}")
             return res
 
 
@@ -721,8 +755,8 @@ def gui():
         [sg.Button("Send '2 5 degC thunder'", k='-SEND-TEXT-')],
 
         # TODO
-        #[sg.Text("Play Snake")],
-        #[sg.Button("Start Game", k='-PLAY-SNAKE-')],
+        # [sg.Text("Play Snake")],
+        # [sg.Button("Start Game", k='-PLAY-SNAKE-')],
 
         [sg.Text("Equalizer")],
         [

src/bin/ledmatrix.rs

@@ -8,7 +8,10 @@ use cortex_m::delay::Delay;
 use defmt_rtt as _;
 use embedded_hal::digital::v2::{InputPin, OutputPin};
 
-use rp2040_hal::gpio::bank0::Gpio29;
+use rp2040_hal::{
+    gpio::bank0::Gpio29,
+    rosc::{Enabled, RingOscillator},
+};
 //#[cfg(debug_assertions)]
 //use panic_probe as _;
 use rp2040_panic_usb_boot as _;
@@ -97,6 +100,7 @@ use core::fmt::Write;
 use heapless::String;
 
 use lotus_input::control::*;
+use lotus_input::games::snake;
 use lotus_input::lotus::LotusLedMatrix;
 use lotus_input::matrix::*;
 use lotus_input::patterns::*;
@@ -127,6 +131,9 @@ fn main() -> ! {
     )
     .ok()
     .unwrap();
+    //rp2040_pac::rosc::RANDOMBIT::read(&self)
+    let rosc = rp2040_hal::rosc::RingOscillator::new(pac.ROSC);
+    let rosc = rosc.initialize();
 
     let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().to_Hz());
 
@@ -188,6 +195,7 @@ fn main() -> ! {
         animate: false,
         brightness: 120,
         sleeping: SleepState::Awake,
+        game: None,
     };
 
     let mut matrix = LotusLedMatrix::configure(i2c);
@@ -205,6 +213,7 @@ fn main() -> ! {
 
     let timer = Timer::new(pac.TIMER, &mut pac.RESETS);
     let mut prev_timer = timer.get_counter().ticks();
+    let mut game_timer = timer.get_counter().ticks();
 
     loop {
         // TODO: Current hardware revision does not have the sleep pin wired up :(
@@ -250,6 +259,7 @@ fn main() -> ! {
                     // Do nothing
                 }
                 Ok(count) => {
+                    let random = get_random_byte(&rosc);
                     match (parse_command(count, &buf), &state.sleeping) {
                         (Some(Command::Sleep(go_sleeping)), _) => {
                             handle_sleep(
@@ -262,14 +272,25 @@ fn main() -> ! {
                         }
                         (Some(c @ Command::BootloaderReset), _)
                         | (Some(c @ Command::IsSleeping), _) => {
-                            if let Some(response) = handle_command(&c, &mut state, &mut matrix) {
+                            if let Some(response) =
+                                handle_command(&c, &mut state, &mut matrix, random)
+                            {
                                 let _ = serial.write(&response);
                             };
                         }
                         (Some(command), SleepState::Awake) => {
+                            let mut text: String<64> = String::new();
+                            write!(
+                                &mut text,
+                                "Handling command {}:{}:{}:{}\r\n",
+                                buf[0], buf[1], buf[2], buf[3]
+                            )
+                            .unwrap();
+                            let _ = serial.write(text.as_bytes());
+
                             // While sleeping no command is handled, except waking up
                             if let Some(response) =
-                                handle_command(&command, &mut state, &mut matrix)
+                                handle_command(&command, &mut state, &mut matrix, random)
                             {
                                 let _ = serial.write(&response);
                             };
@@ -280,7 +301,37 @@ fn main() -> ! {
                 }
             }
         }
+
+        // Handle game state
+        if timer.get_counter().ticks() > game_timer + 500_000 {
+            let _ = serial.write(b"Game step\r\n");
+            if let Some(GameState::Snake(_)) = state.game {
+                let random = get_random_byte(&rosc);
+                let (direction, game_over, points, (x, y)) = snake::game_step(&mut state, random);
+
+                if game_over {
+                } else {
+                    let mut text: String<64> = String::new();
+                    write!(
+                        &mut text,
+                        "Dir: {:?} Status: {}, Points: {}, Head: ({},{})\r\n",
+                        direction, game_over, points, x, y
+                    )
+                    .unwrap();
+                    let _ = serial.write(text.as_bytes());
+                }
+            }
+            game_timer = timer.get_counter().ticks();
+        }
+    }
+}
+
+fn get_random_byte(rosc: &RingOscillator<Enabled>) -> u8 {
+    let mut byte = 0;
+    for i in 0..8 {
+        byte += (rosc.get_random_bit() as u8) << i;
     }
+    byte
 }
 
 fn handle_sleep(

src/control.rs

@@ -13,6 +13,8 @@ use embedded_graphics::{
 #[cfg(feature = "b1display")]
 use heapless::String;
 
+#[cfg(feature = "ledmatrix")]
+use crate::games::snake;
 #[cfg(feature = "ledmatrix")]
 use crate::matrix::*;
 #[cfg(feature = "ledmatrix")]
@@ -30,6 +32,9 @@ pub enum _CommandVals {
     _StageGreyCol = 0x07,
     _DrawGreyColBuffer = 0x08,
     SetText = 0x09,
+    StartGame = 0x10,
+    GameControl = 0x11,
+    GameStatus = 0x12,
     Version = 0x20,
 }
 
@@ -44,6 +49,19 @@ pub enum PatternVals {
     DisplayLotus2,
 }
 
+pub enum Game {
+    Snake,
+}
+
+#[derive(Clone)]
+pub enum GameControlArg {
+    Up,
+    Down,
+    Left,
+    Right,
+    Exit,
+}
+
 // TODO: Reduce size for modules that don't require other commands
 pub enum Command {
     /// Get current brightness scaling
@@ -72,6 +90,9 @@ pub enum Command {
     DrawGreyColBuffer,
     #[cfg(feature = "b1display")]
     SetText(String<64>),
+    StartGame(Game),
+    GameControl(GameControlArg),
+    GameStatus,
     Version,
     _Unknown,
 }
@@ -159,6 +180,19 @@ pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
                 }
             }
             0x08 => Some(Command::DrawGreyColBuffer),
+            0x10 => match arg {
+                Some(0) => Some(Command::StartGame(Game::Snake)),
+                _ => None,
+            },
+            0x11 => match arg {
+                Some(0) => Some(Command::GameControl(GameControlArg::Up)),
+                Some(1) => Some(Command::GameControl(GameControlArg::Down)),
+                Some(2) => Some(Command::GameControl(GameControlArg::Left)),
+                Some(3) => Some(Command::GameControl(GameControlArg::Right)),
+                Some(4) => Some(Command::GameControl(GameControlArg::Exit)),
+                _ => None,
+            },
+            0x12 => Some(Command::GameStatus),
             _ => None,
         }
     } else {
@@ -218,14 +252,19 @@ pub fn handle_generic_command(command: &Command) -> Option<[u8; 32]> {
             response[0] = bcd_device[0];
             response[1] = bcd_device[1];
             response[2] = is_pre_release() as u8;
-            return Some(response);
+            Some(response)
         }
         _ => None,
     }
 }
 
 #[cfg(feature = "ledmatrix")]
-pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) -> Option<[u8; 32]> {
+pub fn handle_command(
+    command: &Command,
+    state: &mut State,
+    matrix: &mut Foo,
+    random: u8,
+) -> Option<[u8; 32]> {
     match command {
         Command::GetBrightness => {
             let mut response: [u8; 32] = [0; 32];
@@ -238,10 +277,12 @@ pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) ->
             matrix
                 .set_scaling(state.brightness)
                 .expect("failed to set scaling");
+            None
         }
         Command::Percentage(p) => {
             //let p = if count >= 5 { buf[4] } else { 100 };
             state.grid = percentage(*p as u16);
+            None
         }
         Command::Pattern(pattern) => {
             //let _ = serial.write("Pattern".as_bytes());
@@ -261,22 +302,31 @@ pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) ->
                 PatternVals::DisplayLotus2 => state.grid = display_lotus2(),
                 _ => {}
             }
+            None
+        }
+        Command::SetAnimate(a) => {
+            state.animate = *a;
+            None
         }
-        Command::SetAnimate(a) => state.animate = *a,
         Command::GetAnimate => {
             let mut response: [u8; 32] = [0; 32];
             response[0] = state.animate as u8;
             return Some(response);
         }
-        Command::Draw(vals) => state.grid = draw(vals),
+        Command::Draw(vals) => {
+            state.grid = draw(vals);
+            None
+        }
         Command::StageGreyCol(col, vals) => {
             draw_grey_col(&mut state.col_buffer, *col, vals);
+            None
         }
         Command::DrawGreyColBuffer => {
             // Copy the staging buffer to the real grid and display it
             state.grid = state.col_buffer.clone();
             // Zero the old staging buffer, just for good measure.
             state.col_buffer = percentage(0);
+            None
         }
         // TODO: Move to handle_generic_command
         Command::IsSleeping => {
@@ -287,10 +337,23 @@ pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) ->
             };
             return Some(response);
         }
+        Command::StartGame(game) => {
+            match game {
+                Game::Snake => snake::start_game(state, random),
+            }
+            None
+        }
+        Command::GameControl(arg) => {
+            match state.game {
+                Some(GameState::Snake(_)) => snake::handle_control(state, arg),
+                _ => {}
+            }
+            None
+        }
+        Command::GameStatus => None,
         // TODO: Make it return something
         _ => return handle_generic_command(command),
     }
-    None
 }
 
 #[cfg(feature = "b1display")]

src/lib.rs

@@ -1,5 +1,7 @@
 #![no_std]
 
+#[cfg(feature = "ledmatrix")]
+pub mod games;
 #[cfg(feature = "ledmatrix")]
 pub mod lotus;
 #[cfg(feature = "ledmatrix")]