remove swing, add step count

src/menus/sequencer.rs

···
     pub play: bool,
     pub bpm: u32,
     pub timing: TimingOption,
-    pub swing: u32,
+    pub steps: u32,
 }
 
 impl Default for SequencerMenuValue {
···
             play: false,
             bpm: 120,
             timing: TimingOption::Eighth,
-            swing: 0,
+            steps: 12,
         }
     }
 }
···
     pub play_menu: BooleanMenuItem<'a, SequencerMenuValue>,
     pub bpm_menu: NumericMenuItem<'a, SequencerMenuValue>,
     pub timing_menu: EnumMenuItem<'a, SequencerMenuValue, 6, TimingOption>,
-    pub swing_menu: NumericMenuItem<'a, SequencerMenuValue>,
+    pub steps_menu: NumericMenuItem<'a, SequencerMenuValue>,
 }
 
 impl<'a> SequencerMenuItems<'a> {
···
                 menu_value.timing = value;
             },
         );
-        let swing_menu = NumericMenuItem::<SequencerMenuValue>::new(
-            "SWING",
-            defaults.swing,
+        let steps_menu = NumericMenuItem::<SequencerMenuValue>::new(
+            "STEPS",
+            defaults.steps,
             &|menu_value, value| {
-                menu_value.swing = value;
+                menu_value.steps = value;
             },
         );
 
···
             play_menu,
             bpm_menu,
             timing_menu,
-            swing_menu,
+            steps_menu,
         }
     }
 }

src/sequencer_timer.rs

···
 use embassy_time::Timer;
 
-use crate::{COLS, ROWS};
-
 #[derive(Clone, Copy, Default, PartialEq)]
 pub enum TimingOption {
     #[default]
···
     SixteenthTriplet,
 }
 
-const NUM_STEPS: usize = ROWS * COLS;
-
 pub struct SequencerConfig {
     pub bpm: u32,
     pub timing: TimingOption,
-    pub swing: u32,
 }
 
 pub struct SequencerTimer {
···
         let config = SequencerConfig {
             bpm: 120,
             timing: TimingOption::Quarter,
-            swing: 0,
         };
 
         let speed_ms = config_to_ms(&config);

src/tasks/controls.rs

···
     let off = RGB { r: 0, g: 0, b: 0 };
     let current = RGB { r: 32, g: 0, b: 0 };
 
+    let mut num_steps = 12;
     let mut num_keys_pressed = 0;
     let mut selected_step: Option<Coord> = None;
     let mut step_index: usize = 0;
···
                     off
                 };
 
-                step_index = (step_index + 1).rem_euclid(NUM_KEYS);
-                let mut next_step = ((step_index % COLS) as u8, (step_index / COLS) as u8);
-                if num_keys_pressed > 0 {
-                    while !step_state[next_step.1 as usize][next_step.0 as usize].pressed {
+                let next_step = if num_keys_pressed > 0 {
+                    step_index = (step_index + 1).rem_euclid(NUM_KEYS);
+                    let mut next = coord_from_index(step_index);
+                    while !step_state[next.1 as usize][next.0 as usize].pressed {
                         step_index = (step_index + 1).rem_euclid(NUM_KEYS);
-                        next_step = ((step_index % COLS) as u8, (step_index / COLS) as u8);
+                        next = coord_from_index(step_index)
                     }
-                }
+                    next
+                } else {
+                    step_index = (step_index + 1).rem_euclid(num_steps);
+                    coord_from_index(step_index)
+                };
 
                 update_key_light(step, prev_color).await;
                 update_key_light(next_step, current).await;
                 step = next_step;
             }
             ControlEvent::SequencerMenuChange { value } => unsafe {
+                num_steps = value.steps as usize;
                 SEQUENCER_MENU.lock_mut(|inner| *inner = Some(value));
             },
             ControlEvent::StepMenuChange { value } => {
···
             }
         }
     }
+}
+
+fn coord_from_index(index: usize) -> Coord {
+    ((index % COLS) as u8, (index / COLS) as u8)
 }
 
 async fn set_step_menu(value: Option<StepMenuValue>) {

src/tasks/display.rs

···
             &mut sequencer_items.play_menu,
             &mut sequencer_items.bpm_menu,
             &mut sequencer_items.timing_menu,
-            &mut sequencer_items.swing_menu,
+            &mut sequencer_items.steps_menu,
         ],
         &|value| {
             let _ = CONTROLS_CHANNEL.try_send(ControlEvent::SequencerMenuChange { value: *value });

src/tasks/sequencer.rs

···
                 play: temp_play,
                 bpm,
                 timing,
-                swing,
+                steps: _steps,
             } = value.unwrap();
-            timer.set(SequencerConfig { bpm, timing, swing });
+            timer.set(SequencerConfig { bpm, timing });
             play = temp_play;
         });