Wire up button events to state task

firmware/Cargo.toml

@@ -30,3 +30,4 @@ heapless = { version = "0.9.2" }
 static_cell = { version = "2.1.1" }
 serde = { version = "1.0.228", default-features = false }
 embassy-sync = { version = "0.7.2" }
+async-channel = { version = "2.5.0" }

firmware/firmware/src/main.rs

@@ -10,6 +10,7 @@
 extern crate alloc;
 mod midi;
 mod storage;
+mod time;
 
 include!(concat!(env!("OUT_DIR"), "/version.rs"));
 
@@ -26,11 +27,14 @@ use esp_backtrace as _;
 
 use crate::storage::FakeStorageManager;
 
+use crate::time::EmbassyTimeSource;
 use core::cell::RefCell;
 use display_interface_spi::SPIInterface;
 use embassy_embedded_hal::shared_bus::blocking::spi::SpiDevice;
 use embassy_executor::Spawner;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::blocking_mutex::{Mutex, raw::NoopRawMutex};
+use embassy_sync::channel::{Channel, Sender};
 use embassy_time::Delay;
 use embedded_graphics::draw_target::DrawTarget;
 use embedded_graphics::pixelcolor::Rgb565;
@@ -42,6 +46,7 @@ use esp_hal::time::Rate;
 use esp_hal::timer::timg::TimerGroup;
 use esp_hal::uart::{Config as UartConfig, DataBits, Parity, StopBits, Uart, UartRx, UartTx};
 use esp_hal::{Async, Blocking};
+use foundation::application::channels::{ButtonEvent, ButtonEventReceiver};
 use foundation::application::state::{Application, ApplicationBuilder, Displays};
 use log::info;
 use midi::{UartMidiReader, UartMidiWriter};
@@ -64,8 +69,11 @@ type FirmwareApplication = Application<
     UartMidiReader<'static, 'static>,
     UartMidiWriter<'static, 'static>,
     FakeStorageManager,
+    EmbassyTimeSource,
 >;
 
+type ButtonEventChannel = Channel<CriticalSectionRawMutex, ButtonEvent, 64>;
+
 static RX: StaticCell<UartRx<Async>> = StaticCell::new();
 static TX: StaticCell<UartTx<Async>> = StaticCell::new();
 static DISPLAY_1: StaticCell<FirmwareDisplay> = StaticCell::new();
@@ -76,7 +84,12 @@ static DISPLAYS: StaticCell<Displays<FirmwareDisplay>> = StaticCell::new();
 static UART_MIDI_READER: StaticCell<UartMidiReader> = StaticCell::new();
 static UART_MIDI_WRITER: StaticCell<UartMidiWriter> = StaticCell::new();
 static STORAGE_MANAGER: StaticCell<FakeStorageManager> = StaticCell::new();
+static BUTTON_EVENT_CHANNEL: StaticCell<ButtonEventChannel> = StaticCell::new();
+static BUTTON_EVENT_SENDER: StaticCell<Sender<CriticalSectionRawMutex, ButtonEvent, 64>> =
+    StaticCell::new();
+static BUTTON_EVENT_RECEIVER: StaticCell<ButtonEventReceiver> = StaticCell::new();
 static SPI_BUS: StaticCell<Mutex<NoopRawMutex, RefCell<Spi<Blocking>>>> = StaticCell::new();
+static TIME_SOURCE: StaticCell<EmbassyTimeSource> = StaticCell::new();
 static APP: StaticCell<FirmwareApplication> = StaticCell::new();
 
 #[embassy_executor::task]
@@ -217,12 +230,20 @@ async fn main(spawner: Spawner) -> ! {
     let midi_reader = UART_MIDI_READER.init(UartMidiReader::new(rx));
     let midi_writer = UART_MIDI_WRITER.init(UartMidiWriter::new(tx));
     let storage_manager = STORAGE_MANAGER.init(FakeStorageManager::default());
+    let button_event_channel =
+        BUTTON_EVENT_CHANNEL.init(Channel::<CriticalSectionRawMutex, ButtonEvent, 64>::new());
+    // TODO: Use this in tasks later
+    let _button_event_sender = BUTTON_EVENT_SENDER.init(button_event_channel.sender());
+    let button_event_receiver = BUTTON_EVENT_RECEIVER.init(button_event_channel.receiver());
+    let time_source = TIME_SOURCE.init(EmbassyTimeSource::default());
 
     let app = APP.init(
         ApplicationBuilder::new()
             .with_midi_reader(midi_reader)
             .with_midi_writer(midi_writer)
             .with_storage_manager(storage_manager)
+            .with_button_event_receiver(button_event_receiver)
+            .with_time_source(time_source)
             .build(),
     );
 

firmware/firmware/src/time.rs

@@ -0,0 +1,10 @@
+use foundation::application::time::TimeSource;
+
+#[derive(Default)]
+pub struct EmbassyTimeSource;
+
+impl TimeSource for EmbassyTimeSource {
+    fn now(&self) -> u64 {
+        embassy_time::Instant::now().as_millis()
+    }
+}

firmware/foundation/Cargo.toml

@@ -14,9 +14,10 @@ prost = { version = "0.14.3", default-features = false, features = ["derive"] }
 heapless = { workspace = true, features = ["serde"] }
 serde = { workspace = true, features = ["derive"] }
 log = { workspace = true }
+hashbrown = { version = "0.17.0", features = ["alloc"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 embassy-sync = { workspace = true, features = ["log"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-async-channel = { version = "2.5.0" }
+async-channel = { workspace = true }

firmware/foundation/src/application/channels.rs

@@ -52,8 +52,15 @@ impl<T, const N: usize> AppChannel<T, N> {
 
 pub type MidiOutChannel = AppChannel<MidiPacket, 128>;
 
+pub enum DisplayIdentifier {
+    Display1,
+    Display2,
+    Display3,
+    Display4,
+}
+
 pub struct DisplayStateUpdateMessage {
-    pub(crate) display_index: i8,
+    pub(crate) display_identifier: DisplayIdentifier,
     pub(crate) top_row_text: DisplayText,
     pub(crate) top_row_color: Colour,
     pub(crate) bottom_row_text: DisplayText,
@@ -62,12 +69,35 @@ pub struct DisplayStateUpdateMessage {
 
 pub type DisplayStateUpdateChannel = AppChannel<DisplayStateUpdateMessage, 16>;
 
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum ButtonIdentifier {
+    Button1,
+    Button2,
+    Button3,
+    Button4,
+    Button5,
+    Button6,
+    Button7,
+    Button8,
+}
+
+#[derive(Debug, Copy, Clone)]
 pub enum ButtonEvent {
-    Pressed { button_index: i8 },
-    Released { button_index: i8 },
+    Pressed { button_identifier: ButtonIdentifier },
+    Released { button_identifier: ButtonIdentifier },
 }
 
-pub type ButtonEventChannel = AppChannel<ButtonEvent, 16>;
+#[cfg(target_arch = "wasm32")]
+type Receiver<'a, T, const N: usize> = async_channel::Receiver<T>;
+#[cfg(not(target_arch = "wasm32"))]
+type Receiver<'a, T, const N: usize> = embassy_sync::channel::Receiver<
+    'a,
+    embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex,
+    T,
+    N,
+>;
+
+pub type ButtonEventReceiver<'a> = Receiver<'a, ButtonEvent, 64>;
 
 // TODO: Add channel for state updates
 pub enum StorageStateEvent {

firmware/foundation/src/application/mod.rs

@@ -1,2 +1,3 @@
 pub mod channels;
 pub mod state;
+pub mod time;