working-display-settings

Cargo.lock

@@ -27,12 +27,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
-[[package]]
-name = "arrform"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7cf566ecc5c9d82b973e81d30babf6583c9b497f86295c952d538c3254ef4e6"
-
 [[package]]
 name = "ascii-canvas"
 version = "3.0.0"
@@ -765,27 +759,6 @@ dependencies = [
  "embedded-io",
 ]
 
-[[package]]
-name = "embedded-layout"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a90553247f2b05c59ac7894ea13d830636c2b1203fa03bff400eddbd1fa9f52"
-dependencies = [
- "embedded-graphics",
- "embedded-layout-macros",
-]
-
-[[package]]
-name = "embedded-layout-macros"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f6e621fe4c7e05b695274b722dc0a60bacd1c8696b58191baa0154713d52400"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "embedded-sdmmc"
 version = "0.8.0"
@@ -1033,9 +1006,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
 name = "indexmap"
-version = "2.10.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -1363,8 +1336,6 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 name = "picocalc-os-rs"
 version = "0.1.0"
 dependencies = [
- "arrform",
- "bitflags 2.9.1",
  "bt-hci",
  "cortex-m",
  "cortex-m-rt",
@@ -1380,12 +1351,9 @@ dependencies = [
  "embassy-time",
  "embedded-graphics",
  "embedded-hal 0.2.7",
- "embedded-hal 1.0.0",
  "embedded-hal-async",
  "embedded-hal-bus",
- "embedded-layout",
  "embedded-sdmmc",
- "heapless",
  "panic-probe",
  "portable-atomic",
  "st7365p-lcd",
@@ -1761,10 +1729,10 @@ dependencies = [
 [[package]]
 name = "st7365p-lcd"
 version = "0.10.0"
+source = "git+https://github.com/legitcamper/st7365p-lcd-rs#d751e8d30f1a3f964ffe05e4bb16f82112fbefce"
 dependencies = [
  "embedded-graphics-core",
  "embedded-hal 1.0.0",
- "embedded-hal-async",
  "nb 1.1.0",
 ]
 

Cargo.toml

@@ -60,22 +60,18 @@ cyw43-pio = { version = "0.3.0", optional = true }
 
 embedded-hal-bus = { version = "0.3.0", features = ["async"] }
 embedded-hal = "0.2.7"
-embedded-hal-1 = { version = "1.0.0", package = "embedded-hal" }
 embedded-hal-async = "1.0.0"
 cortex-m = { version = "0.7.7" }
 cortex-m-rt = "0.7.5"
 panic-probe = "0.3"
 portable-atomic = { version = "1.11", features = ["critical-section"] }
-static_cell = "2.1.1"
-bitflags = "2.9.1"
-heapless = "0.8.0"
-arrform = "0.1.1"
 
 defmt = { version = "0.3", optional = true }
 defmt-rtt = "0.4.2"
 
 embedded-graphics = { version = "0.8.1" }
-embedded-layout = "0.4.2"
 embedded-sdmmc = { git = "https://github.com/Be-ing/embedded-sdmmc-rs", branch = "bisync", default-features = false }
-# st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", branch = "async" }
-st7365p-lcd = { path = "../ST7365P-lcd-rs" }
+st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs" }
+# st7365p-lcd = { path = "../ST7365P-lcd-rs" }
+
+static_cell = "2.1.1"

memory.x

@@ -4,7 +4,7 @@ MEMORY {
      *
      * 2 MiB is a safe default here, although a Pico 2 has 4 MiB.
      */
-    FLASH : ORIGIN = 0x10000000, LENGTH = 4096K
+    FLASH : ORIGIN = 0x10000000, LENGTH = 2048K
     /*
      * RAM consists of 8 banks, SRAM0-SRAM7, with a striped mapping.
      * This is usually good for performance, as it distributes load on

src/display.rs

@@ -1,180 +1,46 @@
-use arrform::{ArrForm, arrform};
-use core::fmt::Debug;
-use defmt::info;
 use embassy_rp::{
     gpio::{Level, Output},
     peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
-    spi::{Async, Spi},
+    spi::{Blocking, Spi},
 };
 use embassy_time::{Delay, Timer};
 use embedded_graphics::{
     Drawable,
-    draw_target::DrawTarget,
-    mono_font::{
-        MonoTextStyle,
-        ascii::{FONT_6X10, FONT_9X15, FONT_10X20},
-    },
-    pixelcolor::Rgb565,
-    prelude::{Point, RgbColor, Size},
-    primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
-    text::Text,
+    pixelcolor::{BinaryColor, Rgb555, Rgb565},
+    prelude::{Point, Primitive, RgbColor, Size},
+    primitives::{PrimitiveStyle, Rectangle, Triangle},
 };
-use embedded_hal_1::digital::OutputPin;
-use embedded_hal_async::spi::SpiDevice;
-use embedded_hal_bus::spi::{ExclusiveDevice, NoDelay};
-use embedded_layout::{
-    align::{horizontal, vertical},
-    layout::linear::LinearLayout,
-    object_chain::Chain,
-    prelude::*,
-};
-use heapless::{String, Vec};
-use st7365p_lcd::{FrameBuffer, Orientation, ST7365P};
+use embedded_hal_bus::spi::ExclusiveDevice;
+use st7365p_lcd::{Orientation, ST7365P};
 
-pub const SCREEN_WIDTH: usize = 320;
-pub const SCREEN_HEIGHT: usize = 320;
+#[embassy_executor::task]
+pub async fn display_task(
+    spi: Spi<'static, SPI1, Blocking>,
+    cs: PIN_13,
+    data: PIN_14,
+    reset: PIN_15,
+) {
+    let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
+    let mut display = ST7365P::new(
+        spi_device,
+        Output::new(data, Level::Low),
+        Some(Output::new(reset, Level::High)),
+        false,
+        true,
+        320,
+        320,
+    );
+    display.init(&mut Delay).unwrap();
+    display.set_orientation(&Orientation::Landscape).unwrap();
 
-pub const STATUS_BAR_WIDTH: usize = 320;
-pub const STATUS_BAR_HEIGHT: usize = 40;
+    let thin_stroke = PrimitiveStyle::with_stroke(Rgb565::RED, 20);
 
-pub type FRAMEBUFFER = FrameBuffer<
-    SCREEN_WIDTH,
-    SCREEN_HEIGHT,
-    ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
-    Output<'static>,
-    Output<'static>,
->;
+    Rectangle::new(Point::new(10, 10), Size::new(100, 100))
+        .into_styled(thin_stroke)
+        .draw(&mut display)
+        .unwrap();
 
-pub struct UI<const MAX_SELECTIONS: usize, const MAX_STR_LEN: usize> {
-    pub status_bar: StatusBar,
-    pub selections_list: SelectionList<MAX_SELECTIONS, MAX_STR_LEN>,
-}
-
-impl<const MAX_SELECTIONS: usize, const MAX_STR_LEN: usize> UI<MAX_SELECTIONS, MAX_STR_LEN> {
-    pub fn new() -> Self {
-        Self {
-            status_bar: StatusBar {
-                battery: 100,
-                backlight: 100,
-                volume: 100,
-            },
-            selections_list: SelectionList::new(Vec::new()),
-        }
-    }
-
-    pub fn draw<D: DrawTarget<Color = Rgb565>>(&mut self, target: &mut D)
-    where
-        <D as DrawTarget>::Error: Debug,
-    {
-        self.draw_status_bar(target);
-        self.draw_selection(target);
-    }
-
-    fn draw_selection<D: DrawTarget<Color = Rgb565>>(&mut self, target: &mut D) {
-        let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
-
-        let selection = Rectangle::new(
-            Point::new(0, STATUS_BAR_HEIGHT as i32 + 1),
-            Size::new(
-                SCREEN_WIDTH as u32,
-                (SCREEN_HEIGHT - STATUS_BAR_HEIGHT) as u32 - 1,
-            ),
-        );
-
-        let _ = if self.selections_list.selections.is_empty() {
-            LinearLayout::horizontal(Chain::new(Text::new(
-                "No Programs found on SD Card\nEnsure programs end with '.rhai',\nand are located in the root directory",
-                Point::zero(),
-                text_style,
-            )))
-            .arrange()
-            .align_to(&selection, horizontal::Center, vertical::Center).draw(target)
-        } else {
-            LinearLayout::horizontal(
-                Chain::new(Text::new(
-                    arrform!(20, "Bat: {}", self.status_bar.battery).as_str(),
-                    Point::zero(),
-                    text_style,
-                ))
-                .append(Text::new(" ", Point::zero(), text_style))
-                .append(Text::new(
-                    arrform!(20, "Lght: {}", self.status_bar.backlight).as_str(),
-                    Point::zero(),
-                    text_style,
-                ))
-                .append(Text::new(" ", Point::zero(), text_style))
-                .append(Text::new(
-                    arrform!(20, "Vol: {}", self.status_bar.volume).as_str(),
-                    Point::zero(),
-                    text_style,
-                )),
-            )
-            .arrange()
-            .align_to(&selection, horizontal::Left, vertical::Center)
-            .draw(target)
-        };
-    }
-
-    fn draw_status_bar<D: DrawTarget<Color = Rgb565>>(&mut self, target: &mut D) {
-        let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
-
-        let status_bar = Rectangle::new(
-            Point::new(0, 0),
-            Size::new(STATUS_BAR_WIDTH as u32, STATUS_BAR_HEIGHT as u32),
-        );
-        let _ = LinearLayout::horizontal(
-            Chain::new(Text::new(
-                arrform!(20, "Bat: {}", self.status_bar.battery).as_str(),
-                Point::zero(),
-                text_style,
-            ))
-            .append(Text::new(
-                arrform!(20, "Lght: {}", self.status_bar.backlight).as_str(),
-                Point::zero(),
-                text_style,
-            ))
-            .append(Text::new(
-                arrform!(20, "Vol: {}", self.status_bar.volume).as_str(),
-                Point::zero(),
-                text_style,
-            )),
-        )
-        .arrange()
-        .align_to(&status_bar, horizontal::Center, vertical::Center)
-        .draw(target);
-    }
-}
-
-pub struct StatusBar {
-    pub battery: u8,
-    pub backlight: u8,
-    pub volume: u8,
-}
-
-pub struct SelectionList<const MAX_SELECTION: usize, const MAX_STR_LEN: usize> {
-    current_selection: u16,
-    selections: Vec<String<MAX_STR_LEN>, MAX_SELECTION>,
-}
-
-impl<const MAX_SELECTION: usize, const MAX_STR_LEN: usize>
-    SelectionList<MAX_SELECTION, MAX_STR_LEN>
-{
-    pub fn new(selections: Vec<String<MAX_STR_LEN>, MAX_SELECTION>) -> Self {
-        Self {
-            selections,
-            current_selection: 0,
-        }
-    }
-
-    pub fn down(&mut self) {
-        if self.current_selection + 1 < self.selections.len() as u16 {
-            self.current_selection += 1
-        }
-    }
-
-    pub fn up(&mut self) {
-        if self.current_selection > self.selections.len() as u16 {
-            self.current_selection -= 1
-        }
+    loop {
+        Timer::after_millis(500).await;
     }
 }

src/main.rs

@@ -4,20 +4,10 @@
 
 #[cfg(feature = "defmt")]
 use defmt::*;
-use embedded_graphics::{
-    pixelcolor::Rgb565,
-    prelude::{Point, RgbColor, Size},
-    primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
-};
 use {defmt_rtt as _, panic_probe as _};
 
-use crate::display::{FRAMEBUFFER, SCREEN_HEIGHT, SCREEN_WIDTH, UI};
-use crate::peripherals::{
-    conf_peripherals,
-    keyboard::{KeyEvent, read_keyboard_fifo},
-};
 use embassy_executor::Spawner;
-use embassy_rp::peripherals::{I2C1, PIN_13, PIN_14, PIN_15, SPI1};
+use embassy_rp::peripherals::I2C1;
 use embassy_rp::spi::Spi;
 use embassy_rp::{
     bind_interrupts,
@@ -28,84 +18,45 @@ use embassy_rp::{
 };
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::channel::Channel;
-use embassy_time::{Delay, Timer};
-use embedded_hal_1::spi::SpiDevice;
+use embassy_time::Timer;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use embedded_sdmmc::asynchronous::{File, SdCard, ShortFileName, VolumeIdx, VolumeManager};
-use st7365p_lcd::{FrameBuffer, ST7365P};
 use static_cell::StaticCell;
 
-mod display;
 mod peripherals;
+use peripherals::{keyboard::KeyEvent, peripherals_task};
+mod display;
+use display::display_task;
 
-embassy_rp::bind_interrupts!(
-    struct Irqs {
-        I2C1_IRQ => i2c::InterruptHandler<I2C1>;
-    }
-);
+embassy_rp::bind_interrupts!(struct Irqs {
+    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+});
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
 
-    let mut i2c1_config = i2c::Config::default();
-    i2c1_config.frequency = 100_000;
-    let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, i2c1_config);
-    conf_peripherals(i2c1).await;
-
-    let mut spi1_config = spi::Config::default();
-    spi1_config.frequency = 16_000_000;
-    let spi1 = Spi::new(
-        p.SPI1,
-        p.PIN_10,
-        p.PIN_11,
-        p.PIN_12,
-        p.DMA_CH0,
-        p.DMA_CH1,
-        spi1_config,
-    );
+    static KEYBOARD_EVENTS: StaticCell<Channel<NoopRawMutex, KeyEvent, 10>> = StaticCell::new();
+    let keyboard_events = KEYBOARD_EVENTS.init(Channel::new());
 
+    // configure keyboard event handler
+    let config = i2c::Config::default();
+    let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
     spawner
-        .spawn(main_task(spi1, p.PIN_13, p.PIN_14, p.PIN_15))
-        .unwrap();
-}
-
-#[embassy_executor::task]
-async fn main_task(
-    spi1: Spi<'static, SPI1, spi::Async>,
-    spi1_cs: PIN_13,
-    spi1_data: PIN_14,
-    spi1_reset: PIN_15,
-) {
-    let spi_device = ExclusiveDevice::new(spi1, Output::new(spi1_cs, Level::Low), Delay).unwrap();
-    let display = ST7365P::new(
-        spi_device,
-        Output::new(spi1_data, Level::Low),
-        Some(Output::new(spi1_reset, Level::High)),
-        false,
-        true,
-        SCREEN_WIDTH as u32,
-        SCREEN_HEIGHT as u32,
-    );
-    let mut framebuffer: FRAMEBUFFER = FrameBuffer::new(display);
-    framebuffer.init(&mut Delay).await.unwrap();
-    framebuffer
-        .display
-        .set_custom_orientation(0x60)
-        .await
+        .spawn(peripherals_task(i2c1, keyboard_events.sender()))
         .unwrap();
 
-    // let mut ui: UI<50, 25> = UI::new();
-
-    // read_keyboard_fifo().await;
-    Rectangle::new(Point::new(0, 0), Size::new(319, 319))
-        .draw_styled(&PrimitiveStyle::with_fill(Rgb565::RED), &mut framebuffer)
+    // configure display handler
+    let mut config = spi::Config::default();
+    config.frequency = 16_000_000;
+    let spi1 = spi::Spi::new_blocking(p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, config);
+    spawner
+        .spawn(display_task(spi1, p.PIN_13, p.PIN_14, p.PIN_15))
         .unwrap();
-    // ui.draw(&mut framebuffer);
-    framebuffer.draw().await.unwrap();
 
+    let receiver = keyboard_events.receiver();
     loop {
-        info!("Done");
-        Timer::after_millis(500).await;
+        let key = receiver.receive().await;
+        info!("got key: {}", key.key as u8);
     }
 }

src/peripherals/battery.rs

@@ -0,0 +1,20 @@
+use embassy_rp::{
+    i2c::{Async, I2c},
+    peripherals::I2C1,
+};
+use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex, watch::Watch};
+
+const REG_ID_BAT: u8 = 0x0b;
+
+pub static BATTERY_PCT: Watch<CriticalSectionRawMutex, u8, 1> = Watch::new();
+
+pub async fn read_battery(i2c: &mut I2c<'static, I2C1, Async>) {
+    let mut buf = [0_u8; 2];
+    i2c.write_read_async(super::MCU_ADDR, [REG_ID_BAT], &mut buf)
+        .await
+        .unwrap();
+
+    if buf[0] == REG_ID_BAT {
+        BATTERY_PCT.sender().send(buf[0]);
+    }
+}

src/peripherals/keyboard.rs

@@ -1,4 +1,3 @@
-use defmt::{info, warn};
 use embassy_rp::{
     i2c::{Async, I2c},
     peripherals::I2C1,
@@ -8,8 +7,6 @@ use embassy_sync::{
     channel::Sender,
 };
 
-use crate::peripherals::PERIPHERAL_BUS;
-
 const REG_ID_KEY: u8 = 0x04;
 const REG_ID_FIF: u8 = 0x09;
 
@@ -17,10 +14,10 @@ const KEY_CAPSLOCK: u8 = 1 << 5;
 const KEY_NUMLOCK: u8 = 1 << 6;
 const KEY_COUNT_MASK: u8 = 0x1F; // 0x1F == 31
 
-pub async fn read_keyboard_fifo() -> Option<KeyEvent> {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
+pub async fn read_keyboard_fifo(
+    i2c: &mut I2c<'static, I2C1, Async>,
+    channel: &mut Sender<'static, NoopRawMutex, KeyEvent, 10>,
+) {
     let mut key_status = [0_u8; 1];
 
     if i2c
@@ -28,8 +25,9 @@ pub async fn read_keyboard_fifo() -> Option<KeyEvent> {
         .await
         .is_ok()
     {
-        let _caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
-        let _num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
+        // TODO: use caps & num lock
+        let caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
+        let num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
         let fifo_count = key_status[0] & KEY_COUNT_MASK;
 
         if fifo_count >= 1 {
@@ -40,98 +38,78 @@ pub async fn read_keyboard_fifo() -> Option<KeyEvent> {
                 .await
                 .is_ok()
             {
-                return Some(KeyEvent {
-                    state: KeyState::from(event[0]),
-                    key: KeyCode::from(event[1]),
-                    mods: Modifiers::NONE,
-                });
+                if let Ok(state) = KeyState::try_from(event[0]) {
+                    if let Ok(key) = KeyCode::try_from(event[1]) {
+                        let _ = channel.try_send(KeyEvent { key, state });
+                    }
+                }
             }
         }
     }
-    None
 }
 
-const REG_ID_DEB: u8 = 0x06;
-const REG_ID_FRQ: u8 = 0x07;
-
-pub async fn configure_keyboard(debounce: u8, poll_freq: u8) {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let _ = i2c
-        .write_read_async(super::MCU_ADDR, [REG_ID_DEB], &mut [debounce])
-        .await;
-
-    let _ = i2c
-        .write_read_async(super::MCU_ADDR, [REG_ID_FRQ], &mut [poll_freq])
-        .await;
-}
-
-bitflags::bitflags! {
-    #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)]
-    pub struct Modifiers: u8 {
-        const NONE = 0;
-        const CTRL = 1;
-        const ALT = 2;
-        const LSHIFT = 4;
-        const RSHIFT = 8;
-        const SYM = 16;
-    }
-}
-
-#[derive(Debug)]
 pub struct KeyEvent {
     pub key: KeyCode,
     pub state: KeyState,
-    pub mods: Modifiers,
 }
 
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum KeyState {
     Idle = 0,
-    Pressed = 1,
-    Hold = 2,
-    Released = 3,
+    Pressed,
+    Hold,
+    Released,
 }
 
-impl From<u8> for KeyState {
-    fn from(value: u8) -> Self {
+impl TryFrom<u8> for KeyState {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
-            1 => KeyState::Pressed,
-            2 => KeyState::Hold,
-            3 => KeyState::Released,
-            0 | _ => KeyState::Idle,
+            0 => Ok(KeyState::Idle),
+            1 => Ok(KeyState::Pressed),
+            2 => Ok(KeyState::Hold),
+            3 => Ok(KeyState::Released),
+            _ => Err(()),
         }
     }
 }
 
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
 pub enum KeyCode {
+    // Joystick
     JoyUp = 0x01,
     JoyDown = 0x02,
     JoyLeft = 0x03,
     JoyRight = 0x04,
     JoyCenter = 0x05,
+
+    // Buttons
     BtnLeft1 = 0x06,
     BtnRight1 = 0x07,
     BtnLeft2 = 0x11,
     BtnRight2 = 0x12,
+
+    // Basic Keys
     Backspace = 0x08,
     Tab = 0x09,
     Enter = 0x0A,
+
+    // Modifiers
     ModAlt = 0xA1,
     ModShiftLeft = 0xA2,
     ModShiftRight = 0xA3,
     ModSym = 0xA4,
     ModCtrl = 0xA5,
+
+    // Navigation
     Esc = 0xB1,
     Left = 0xB4,
     Up = 0xB5,
     Down = 0xB6,
     Right = 0xB7,
+
+    // Specials
     Break = 0xD0,
     Insert = 0xD1,
     Home = 0xD2,
@@ -139,7 +117,11 @@ pub enum KeyCode {
     End = 0xD5,
     PageUp = 0xD6,
     PageDown = 0xD7,
+
+    // Locks
     CapsLock = 0xC1,
+
+    // Function keys
     F1 = 0x81,
     F2 = 0x82,
     F3 = 0x83,
@@ -150,57 +132,55 @@ pub enum KeyCode {
     F8 = 0x88,
     F9 = 0x89,
     F10 = 0x90,
-    Char(char),
-    Unknown(u8),
 }
 
-impl From<u8> for KeyCode {
-    fn from(value: u8) -> Self {
+impl TryFrom<u8> for KeyCode {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        use KeyCode::*;
         match value {
-            0x01 => Self::JoyUp,
-            0x02 => Self::JoyDown,
-            0x03 => Self::JoyLeft,
-            0x04 => Self::JoyRight,
-            0x05 => Self::JoyCenter,
-            0x06 => Self::BtnLeft1,
-            0x07 => Self::BtnRight1,
-            0x08 => Self::Backspace,
-            0x09 => Self::Tab,
-            0x0A => Self::Enter,
-            0x11 => Self::BtnLeft2,
-            0x12 => Self::BtnRight2,
-            0xA1 => Self::ModAlt,
-            0xA2 => Self::ModShiftLeft,
-            0xA3 => Self::ModShiftRight,
-            0xA4 => Self::ModSym,
-            0xA5 => Self::ModCtrl,
-            0xB1 => Self::Esc,
-            0xB4 => Self::Left,
-            0xB5 => Self::Up,
-            0xB6 => Self::Down,
-            0xB7 => Self::Right,
-            0xC1 => Self::CapsLock,
-            0xD0 => Self::Break,
-            0xD1 => Self::Insert,
-            0xD2 => Self::Home,
-            0xD4 => Self::Del,
-            0xD5 => Self::End,
-            0xD6 => Self::PageUp,
-            0xD7 => Self::PageDown,
-            0x81 => Self::F1,
-            0x82 => Self::F2,
-            0x83 => Self::F3,
-            0x84 => Self::F4,
-            0x85 => Self::F5,
-            0x86 => Self::F6,
-            0x87 => Self::F7,
-            0x88 => Self::F8,
-            0x89 => Self::F9,
-            0x90 => Self::F10,
-            _ => match char::from_u32(value as u32) {
-                Some(c) => Self::Char(c),
-                None => Self::Unknown(value),
-            },
+            0x01 => Ok(JoyUp),
+            0x02 => Ok(JoyDown),
+            0x03 => Ok(JoyLeft),
+            0x04 => Ok(JoyRight),
+            0x05 => Ok(JoyCenter),
+            0x06 => Ok(BtnLeft1),
+            0x07 => Ok(BtnRight1),
+            0x08 => Ok(Backspace),
+            0x09 => Ok(Tab),
+            0x0A => Ok(Enter),
+            0x11 => Ok(BtnLeft2),
+            0x12 => Ok(BtnRight2),
+            0xA1 => Ok(ModAlt),
+            0xA2 => Ok(ModShiftLeft),
+            0xA3 => Ok(ModShiftRight),
+            0xA4 => Ok(ModSym),
+            0xA5 => Ok(ModCtrl),
+            0xB1 => Ok(Esc),
+            0xB4 => Ok(Left),
+            0xB5 => Ok(Up),
+            0xB6 => Ok(Down),
+            0xB7 => Ok(Right),
+            0xC1 => Ok(CapsLock),
+            0xD0 => Ok(Break),
+            0xD1 => Ok(Insert),
+            0xD2 => Ok(Home),
+            0xD4 => Ok(Del),
+            0xD5 => Ok(End),
+            0xD6 => Ok(PageUp),
+            0xD7 => Ok(PageDown),
+            0x81 => Ok(F1),
+            0x82 => Ok(F2),
+            0x83 => Ok(F3),
+            0x84 => Ok(F4),
+            0x85 => Ok(F5),
+            0x86 => Ok(F6),
+            0x87 => Ok(F7),
+            0x88 => Ok(F8),
+            0x89 => Ok(F9),
+            0x90 => Ok(F10),
+            _ => Err(()),
         }
     }
 }

src/peripherals/mod.rs

@@ -1,97 +1,72 @@
 //! handles all the peripherals exposed by mcu through i2c (keyboard & battery registers)
 //!
 
+use embassy_futures::join::join;
 use embassy_rp::{
     i2c::{Async, I2c},
     peripherals::I2C1,
 };
-use embassy_sync::{
-    blocking_mutex::raw::NoopRawMutex, channel::Sender, lazy_lock::LazyLock, mutex::Mutex,
-};
+use embassy_sync::{blocking_mutex::raw::NoopRawMutex, channel::Sender, mutex::Mutex};
 use embassy_time::{Duration, Timer};
 
+#[cfg(feature = "defmt")]
+use defmt::info;
+
 pub mod keyboard;
 use keyboard::{KeyCode, KeyEvent, KeyState};
+mod battery;
+pub use battery::BATTERY_PCT;
+use battery::read_battery;
 
-use crate::peripherals::keyboard::{configure_keyboard, read_keyboard_fifo};
+use crate::peripherals::keyboard::read_keyboard_fifo;
 
 const MCU_ADDR: u8 = 0x1F;
 
-type I2CBUS = I2c<'static, I2C1, Async>;
-pub static PERIPHERAL_BUS: LazyLock<Mutex<NoopRawMutex, Option<I2CBUS>>> =
-    LazyLock::new(|| Mutex::new(None));
-
 const REG_ID_VER: u8 = 0x01;
-const REG_ID_RST: u8 = 0x08;
+const REG_ID_CFG: u8 = 0x02;
 const REG_ID_INT: u8 = 0x03;
+const REG_ID_KEY: u8 = 0x04;
+const REG_ID_BKL: u8 = 0x05;
+const REG_ID_DEB: u8 = 0x06;
+const REG_ID_FRQ: u8 = 0x07;
+const REG_ID_RST: u8 = 0x08;
+const REG_ID_FIF: u8 = 0x09;
+const REG_ID_BK2: u8 = 0x0A;
+const REG_ID_C64_MTX: u8 = 0x0c;
+const REG_ID_C64_JS: u8 = 0x0d;
 
-pub async fn conf_peripherals(i2c: I2CBUS) {
+#[embassy_executor::task]
+pub async fn peripherals_task(
+    mut i2c: I2c<'static, I2C1, Async>,
+    mut keyboard_channel: Sender<'static, NoopRawMutex, KeyEvent, 10>,
+) {
     Timer::after(embassy_time::Duration::from_millis(100)).await;
 
-    PERIPHERAL_BUS.get().lock().await.replace(i2c);
+    #[cfg(feature = "defmt")]
+    {
+        let mut ver = [0_u8; 1];
+        if let Ok(firm_ver) = i2c.write_read_async(MCU_ADDR, [REG_ID_VER], &mut ver).await {
+            info!("stm32 firmware version: v{}", ver[0]);
+        }
+    }
 
-    configure_keyboard(200, 100).await;
-    set_lcd_backlight(255).await;
-    set_key_backlight(0).await;
-}
-
-/// return major & minor mcu version
-async fn get_version() -> (u8, u8) {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let mut ver = [0_u8; 1];
-    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_VER], &mut ver).await;
-
-    (ver[0] >> 4, ver[0] & 0x0F)
-}
-
-const REG_ID_BKL: u8 = 0x05;
-pub async fn set_lcd_backlight(brightness: u8) {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let _ = i2c
-        .write_read_async(MCU_ADDR, [REG_ID_BKL], &mut [brightness])
-        .await;
-}
-pub async fn get_lcd_backlight() -> u8 {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let mut buf = [0_u8; 2];
-
-    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_BKL], &mut buf).await;
-    buf[1]
-}
-
-const REG_ID_BK2: u8 = 0x0A;
-pub async fn set_key_backlight(brightness: u8) {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let _ = i2c
-        .write_read_async(MCU_ADDR, [REG_ID_BK2], &mut [brightness])
-        .await;
-}
-pub async fn get_key_backlight() -> u8 {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let mut buf = [0_u8; 2];
-
-    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_BK2], &mut buf).await;
-    buf[1]
-}
-
-const REG_ID_BAT: u8 = 0x0b;
-pub async fn get_battery() -> u8 {
-    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    let i2c = i2c.as_mut().unwrap();
-
-    let mut buf = [0_u8; 2];
-
-    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_BAT], &mut buf).await;
-
-    buf[1]
+    let i2c: Mutex<NoopRawMutex, I2c<'static, I2C1, Async>> = Mutex::new(i2c);
+
+    join(
+        async {
+            loop {
+                Timer::after(Duration::from_secs(10)).await;
+                let mut guard = i2c.lock().await;
+                read_battery(&mut guard).await;
+            }
+        },
+        async {
+            loop {
+                Timer::after(Duration::from_millis(50)).await;
+                let mut guard = i2c.lock().await;
+                read_keyboard_fifo(&mut guard, &mut keyboard_channel).await;
+            }
+        },
+    )
+    .await;
 }