hook menus up to sequencer

Cargo.lock

···
  "itoa",
  "log",
  "midi-convert",
+ "num_enum",
  "panic-probe",
  "pio",
  "pio-proc",

Cargo.toml

···
 midi-convert = "0.2.0"
 usbd-midi = "0.5.0"
 itoa = "1.0.17"
+num_enum = { version = "0.7.4", default-features = false }
 
 [profile.release]
 debug = true

src/main.rs

···
 #![no_std]
 #![no_main]
 
-use core::sync::atomic::AtomicU32;
+use core::sync::atomic::{AtomicBool, AtomicU8, AtomicU32};
 
 use embassy_executor::Spawner;
 use embassy_rp::{
···
 mod key_leds;
 mod menus;
 mod rotary_encoder;
+mod sequencer_timer;
 mod usb;
 
 bind_interrupts!(struct Irqs {
···
 const ROWS: usize = 4;
 type KeyGrid<T> = [[T; COLS]; ROWS];
 
-static SPEED_MS: AtomicU32 = AtomicU32::new(120);
+static PLAY: AtomicBool = AtomicBool::new(false);
+static BPM: AtomicU32 = AtomicU32::new(120);
+static TIMING: AtomicU8 = AtomicU8::new(0);
+static SWING: AtomicU32 = AtomicU32::new(0);
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {

src/menus/mod.rs

···
 mod render;
 mod sequencer;
+use core::sync::atomic::{AtomicBool, AtomicU8, AtomicU32, Ordering};
+
 pub use render::*;
 pub use sequencer::SequencerMenu;
 
···
 
 pub struct NumericMenuItem<'a> {
     title: &'a str,
-    value: u32,
+    value: &'a AtomicU32,
     buffer: itoa::Buffer,
 }
 
 impl<'a> NumericMenuItem<'a> {
-    pub fn new(title: &'a str, value: u32) -> Self {
+    pub fn new(title: &'a str, value: &'a AtomicU32) -> Self {
         let buffer = itoa::Buffer::new();
+
         Self {
             title,
             value,
             buffer,
         }
     }
-
-    pub fn inner(&self) -> &u32 {
-        &self.value
-    }
 }
 
 impl<'a> MenuItem for NumericMenuItem<'a> {
     fn as_str(&mut self) -> (&str, &str) {
-        (self.title, self.buffer.format(self.value))
+        (
+            self.title,
+            self.buffer.format(self.value.load(Ordering::Relaxed)),
+        )
     }
 
     fn on_change(&mut self, step: i32) {
-        let mut intermediate = self.value as i32;
+        let mut intermediate = self.value.load(Ordering::Relaxed) as i32;
         intermediate += step;
         if intermediate < 0 {
             intermediate = 0;
         }
 
-        self.value = intermediate as u32;
+        self.value.store(intermediate as u32, Ordering::Relaxed);
     }
 }
 
 pub struct BooleanMenuItem<'a> {
     title: &'a str,
-    value: bool,
+    value: &'a AtomicBool,
     on_str: &'a str,
     off_str: &'a str,
 }
 
 impl<'a> BooleanMenuItem<'a> {
-    pub fn new(title: &'a str, on_str: &'a str, off_str: &'a str) -> Self {
+    pub fn new(title: &'a str, on_str: &'a str, off_str: &'a str, value: &'a AtomicBool) -> Self {
         Self {
             title,
-            value: false,
+            value,
             on_str,
             off_str,
         }
     }
-
-    pub fn inner(&self) -> &bool {
-        &self.value
-    }
 }
 
 impl MenuItem for BooleanMenuItem<'static> {
     fn as_str(&mut self) -> (&str, &str) {
-        let value = if self.value {
+        let value = if self.value.load(Ordering::Relaxed) {
             self.on_str
         } else {
             self.off_str
···
     }
 
     fn on_change(&mut self, _step: i32) {
-        self.value = !self.value;
+        self.value
+            .store(!self.value.load(Ordering::Relaxed), Ordering::Relaxed);
     }
 }
 
···
     title: &'a str,
     options: [T; SIZE],
     index: usize,
+    value: &'a AtomicU8,
 }
 
 impl<'a, const SIZE: usize, T> EnumMenuItem<'a, SIZE, T>
 where
     T: Stringable,
 {
-    pub fn new(title: &'a str, options: [T; SIZE]) -> Self {
+    pub fn new(title: &'a str, options: [T; SIZE], value: &'a AtomicU8) -> Self {
+        // TODO: set index to currently selected!
+
         Self {
             title,
             options,
             index: 0,
+            value,
         }
     }
-
-    pub fn inner(&self) -> &T {
-        &self.options[self.index]
-    }
 }
 
 impl<'a, const SIZE: usize, T> MenuItem for EnumMenuItem<'a, SIZE, T>
 where
-    T: Stringable + Copy,
+    T: Stringable + Copy + Into<u8>,
 {
     fn as_str(&mut self) -> (&str, &str) {
         (self.title, self.options[self.index].as_str())
···
     fn on_change(&mut self, step: i32) {
         let next = (self.index as i32 + step).rem_euclid(SIZE as i32);
         self.index = next as usize;
+        self.value
+            .store(self.options[self.index].into(), Ordering::Relaxed);
     }
 }

src/menus/sequencer.rs

···
 use crate::{
     display::MonoDisplay,
-    menus::{Menu, MenuItem, MenuItemRender, MenuItemState, render_menu_heading, render_menu_item},
+    menus::{
+        Menu, MenuItem, MenuItemRender, MenuItemState, Stringable, render_menu_heading,
+        render_menu_item,
+    },
+    sequencer_timer::TimingOption,
 };
+
+impl Stringable for TimingOption {
+    fn as_str(&self) -> &str {
+        match self {
+            TimingOption::Quarter => "1/4",
+            TimingOption::QuarterTriplet => "1/4 triplet",
+            TimingOption::Eighth => "1/8",
+            TimingOption::EighthTriplet => "1/8 triplet",
+            TimingOption::Sixteenth => "1/16",
+            TimingOption::SixteenthTriplet => "1/16 triplet",
+        }
+    }
+}
 
 pub struct SequencerMenu<'a, const SIZE: usize> {
     index: usize,

src/sequencer_timer.rs

···
+use embassy_time::Timer;
+use num_enum::{FromPrimitive, IntoPrimitive};
+
+use crate::{COLS, ROWS};
+
+#[derive(Clone, Copy, IntoPrimitive, FromPrimitive)]
+#[repr(u8)]
+pub enum TimingOption {
+    #[default]
+    Quarter,
+    QuarterTriplet,
+    Eighth,
+    EighthTriplet,
+    Sixteenth,
+    SixteenthTriplet,
+}
+
+const NUM_STEPS: usize = ROWS * COLS;
+
+pub struct SequencerConfig {
+    pub bpm: u32,
+    pub timing: TimingOption,
+    pub swing: u32,
+}
+
+pub struct SequencerTimer {
+    config: SequencerConfig,
+    speed_ms: u32,
+}
+
+impl SequencerTimer {
+    pub fn new() -> Self {
+        let config = SequencerConfig {
+            bpm: 120,
+            timing: TimingOption::Quarter,
+            swing: 0,
+        };
+
+        let speed_ms = config_to_ms(&config);
+
+        Self { config, speed_ms }
+    }
+
+    pub fn set(&mut self, config: SequencerConfig) {
+        self.config = config;
+        self.speed_ms = config_to_ms(&self.config);
+    }
+
+    pub async fn next_step(&mut self) {
+        Timer::after_millis(self.speed_ms as u64).await;
+    }
+}
+
+fn config_to_ms(config: &SequencerConfig) -> u32 {
+    // TODO: swing
+    // TODO: does this need to be µS to preserve timing?
+    match config.timing {
+        TimingOption::Quarter => 60_000 / config.bpm,
+        TimingOption::QuarterTriplet => 40_000 / config.bpm,
+        TimingOption::Eighth => 30_000 / config.bpm,
+        TimingOption::EighthTriplet => 20_000 / config.bpm,
+        TimingOption::Sixteenth => 15_000 / config.bpm,
+        TimingOption::SixteenthTriplet => 10_000 / config.bpm,
+    }
+}

src/tasks/controls.rs

···
 use smart_leds::RGB;
 
 use crate::{
-    COLS, KeyGrid, ROWS, SPEED_MS,
+    COLS, KeyGrid, ROWS,
     key_leds::Coord,
     tasks::{
         display::{DISPLAY_CHANNEL, DisplayUpdate},
···
     let current = RGB { r: 32, g: 0, b: 0 };
 
     let mut step: Coord = (0, 0);
-    let mut bpm: i32 = 120;
 
     loop {
         match CONTROLS_CHANNEL.receive().await {

src/tasks/display.rs

···
-use crate::menus::{
-    BooleanMenuItem, EnumMenuItem, Menu, NumericMenuItem, SequencerMenu, Stringable,
+use core::sync::atomic::Ordering;
+
+use crate::{
+    BPM, PLAY, SWING, TIMING,
+    menus::{BooleanMenuItem, EnumMenuItem, Menu, NumericMenuItem, SequencerMenu},
+    sequencer_timer::TimingOption,
 };
 use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, channel::Channel};
 
···
     }
 }
 
-#[derive(Clone, Copy)]
-pub enum TimingOption {
-    Quarter,
-    Eighth,
-    Sixteenth,
-}
-
-impl Stringable for TimingOption {
-    fn as_str(&self) -> &str {
-        match self {
-            TimingOption::Quarter => "1/4",
-            TimingOption::Eighth => "1/8",
-            TimingOption::Sixteenth => "1/16",
-        }
-    }
-}
-
 #[embassy_executor::task]
 pub async fn drive_display(mut display: Display) {
     display.init();
-
-    let mut play_menu = BooleanMenuItem::new("STATUS", "PLAYING", "PAUSED");
-    let mut bpm_menu = NumericMenuItem::new("BPM", 120);
+    TIMING.store(TimingOption::Quarter.into(), Ordering::Relaxed);
+    let mut play_menu = BooleanMenuItem::new("STATUS", "PLAYING", "PAUSED", &PLAY);
+    let mut bpm_menu = NumericMenuItem::new("BPM", &BPM);
     let mut timing_menu = EnumMenuItem::new(
         "TIMING",
         [
             TimingOption::Quarter,
+            TimingOption::QuarterTriplet,
             TimingOption::Eighth,
+            TimingOption::EighthTriplet,
             TimingOption::Sixteenth,
+            TimingOption::SixteenthTriplet,
         ],
+        &TIMING,
     );
-    let mut swing_menu = NumericMenuItem::new("SWING", 0);
+    let mut swing_menu = NumericMenuItem::new("SWING", &SWING);
 
     let sequencer = SequencerMenu::new([
         &mut play_menu,
···
     ]);
 
     let mut menus = Menus::new(sequencer);
+    menus.sequencer.render(&mut display.display);
+    display.flush();
 
     loop {
         match DISPLAY_CHANNEL.receive().await {

src/tasks/sequencer.rs

···
 use core::sync::atomic::Ordering;
 
-use embassy_time::Timer;
-
 use crate::{
-    COLS, SPEED_MS,
+    BPM, COLS, PLAY, SWING, TIMING,
+    sequencer_timer::{SequencerConfig, SequencerTimer},
     tasks::{CONTROLS_CHANNEL, controls::ControlEvent},
 };
 
···
     let mut step: u8 = 0;
     let cols = COLS as u8;
 
+    let mut timer = SequencerTimer::new();
     loop {
-        let coord = (step % cols, step / cols);
-        CONTROLS_CHANNEL
-            .send(ControlEvent::SequencerStep { coord })
-            .await;
+        let play = PLAY.load(Ordering::Relaxed);
+        if play {
+            let coord = (step % cols, step / cols);
+            CONTROLS_CHANNEL
+                .send(ControlEvent::SequencerStep { coord })
+                .await;
+
+            step = (step + 1).rem_euclid(12);
 
-        step += 1;
-        if step == 12 {
-            step = 0;
+            timer.set(SequencerConfig {
+                bpm: BPM.load(Ordering::Relaxed),
+                timing: TIMING.load(Ordering::Relaxed).into(),
+                swing: SWING.load(Ordering::Relaxed),
+            });
         }
 
-        Timer::after_millis(SPEED_MS.load(Ordering::Relaxed) as u64).await;
+        timer.next_step().await;
     }
 }