split screen logic into seprate crate for testing

pico/Cargo.toml

@@ -0,0 +1,76 @@
+[package]
+name = "picocalc-os-rs"
+version = "0.1.0"
+edition = "2024"
+
+[features]
+default = ["rp235x", "defmt"]
+rp2040 = ["embassy-rp/rp2040"]
+rp235x = ["embassy-rp/rp235xb"]
+trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
+defmt = [
+  "dep:defmt",
+  "panic-probe/print-defmt",
+  "embassy-executor/defmt",
+  "embassy-time/defmt",
+  "embassy-time/defmt-timestamp-uptime",
+  "embassy-rp/defmt",
+  "embassy-sync/defmt",
+  "embedded-graphics/defmt",
+  "embedded-sdmmc/defmt-log",
+  # "bt-hci/defmt",
+  # "cyw43/defmt",
+  # "cyw43-pio/defmt",
+]
+
+[dev-dependencies]
+embedded-graphics-simulator = { version = "0.7.0", default-features = false }
+
+[dependencies]
+embassy-executor = { version = "0.7", features = [
+  "arch-cortex-m",
+  "executor-interrupt",
+  "executor-thread",
+  "nightly",
+] }
+embassy-rp = { version = "0.4.0", features = [
+  "critical-section-impl",
+  "unstable-pac",
+  "time-driver",
+  "binary-info",
+] }
+embassy-futures = "0.1.1"
+embassy-time = "0.4.0"
+embassy-embedded-hal = "0.3.0"
+embassy-sync = { version = "0.7" }
+trouble-host = { version = "0.1", features = [
+  "derive",
+  "scan",
+], optional = true }
+bt-hci = { version = "0.2", default-features = false, optional = true }
+cyw43 = { version = "0.3.0", features = [
+  "firmware-logs",
+  "bluetooth",
+], optional = true }
+cyw43-pio = { version = "0.3.0", optional = true }
+
+embedded-hal-bus = { version = "0.3.0", features = ["async"] }
+embedded-hal = "0.2.7"
+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"] }
+
+defmt = { version = "0.3", optional = true }
+defmt-rtt = "0.4.2"
+
+embedded-graphics = { version = "0.8.1" }
+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" }
+shared = { path = "../shared" }
+
+static_cell = "2.1.1"
+bitflags = "2.9.1"
+talc = "4.4.3"
+spin = "0.10.0"

pico/build.rs

@@ -0,0 +1,35 @@
+//! This build script copies the `memory.x` file from the crate root into
+//! a directory where the linker can always find it at build time.
+//! For many projects this is optional, as the linker always searches the
+//! project root directory -- wherever `Cargo.toml` is. However, if you
+//! are using a workspace or have a more complicated build setup, this
+//! build script becomes required. Additionally, by requesting that
+//! Cargo re-run the build script whenever `memory.x` is changed,
+//! updating `memory.x` ensures a rebuild of the application with the
+//! new memory settings.
+
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put `memory.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // By default, Cargo will re-run a build script whenever
+    // any file in the project changes. By specifying `memory.x`
+    // here, we ensure the build script is only re-run when
+    // `memory.x` is changed.
+    println!("cargo:rerun-if-changed=memory.x");
+
+    println!("cargo:rustc-link-arg-bins=--nmagic");
+    println!("cargo:rustc-link-arg-bins=-Tlink.x");
+    println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
+}

pico/memory.x

@@ -0,0 +1,75 @@
+MEMORY {
+    /*
+     * The RP2350 has either external or internal flash.
+     *
+     * 2 MiB is a safe default here, although a Pico 2 has 4 MiB.
+     */
+    FLASH : ORIGIN = 0x10000000, LENGTH = 4096K
+    /*
+     * RAM consists of 8 banks, SRAM0-SRAM7, with a striped mapping.
+     * This is usually good for performance, as it distributes load on
+     * those banks evenly.
+     */
+    RAM : ORIGIN = 0x20000000, LENGTH = 512K
+    /*
+     * RAM banks 8 and 9 use a direct mapping. They can be used to have
+     * memory areas dedicated for some specific job, improving predictability
+     * of access times.
+     * Example: Separate stacks for core0 and core1.
+     */
+    SRAM4 : ORIGIN = 0x20080000, LENGTH = 4K
+    SRAM5 : ORIGIN = 0x20081000, LENGTH = 4K
+}
+
+SECTIONS {
+    /* ### Boot ROM info
+     *
+     * Goes after .vector_table, to keep it in the first 4K of flash
+     * where the Boot ROM (and picotool) can find it
+     */
+    .start_block : ALIGN(4)
+    {
+        __start_block_addr = .;
+        KEEP(*(.start_block));
+        KEEP(*(.boot_info));
+    } > FLASH
+
+} INSERT AFTER .vector_table;
+
+/* move .text to start /after/ the boot info */
+_stext = ADDR(.start_block) + SIZEOF(.start_block);
+
+SECTIONS {
+    /* ### Picotool 'Binary Info' Entries
+     *
+     * Picotool looks through this block (as we have pointers to it in our
+     * header) to find interesting information.
+     */
+    .bi_entries : ALIGN(4)
+    {
+        /* We put this in the header */
+        __bi_entries_start = .;
+        /* Here are the entries */
+        KEEP(*(.bi_entries));
+        /* Keep this block a nice round size */
+        . = ALIGN(4);
+        /* We put this in the header */
+        __bi_entries_end = .;
+    } > FLASH
+} INSERT AFTER .text;
+
+SECTIONS {
+    /* ### Boot ROM extra info
+     *
+     * Goes after everything in our program, so it can contain a signature.
+     */
+    .end_block : ALIGN(4)
+    {
+        __end_block_addr = .;
+        KEEP(*(.end_block));
+    } > FLASH
+
+} INSERT AFTER .uninit;
+
+PROVIDE(start_to_end = __end_block_addr - __start_block_addr);
+PROVIDE(end_to_start = __start_block_addr - __end_block_addr);

pico/src/display.rs

@@ -0,0 +1,61 @@
+use defmt::info;
+use embassy_rp::{
+    gpio::{Level, Output},
+    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
+    spi::{Async, Spi},
+};
+use embassy_time::{Delay, Timer};
+use embedded_graphics::{
+    Drawable,
+    mono_font::{MonoFont, MonoTextStyle, ascii::FONT_10X20},
+    pixelcolor::Rgb565,
+    prelude::{Point, WebColors},
+    text::{Baseline, Text, TextStyle},
+};
+use embedded_hal_bus::spi::ExclusiveDevice;
+use st7365p_lcd::{FrameBuffer, ST7365P};
+
+use shared::{SCREEN_HEIGHT, SCREEN_WIDTH, TextBuffer};
+
+type SPI = Spi<'static, SPI1, Async>;
+
+type FRAMEBUFFER = FrameBuffer<
+    SCREEN_WIDTH,
+    SCREEN_HEIGHT,
+    ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
+    Output<'static>,
+    Output<'static>,
+>;
+
+#[embassy_executor::task]
+pub async fn display_task(spi: SPI, cs: PIN_13, data: PIN_14, reset: PIN_15) {
+    let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
+    let display = ST7365P::new(
+        spi_device,
+        Output::new(data, Level::Low),
+        Some(Output::new(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_offset(0, 0);
+    framebuffer
+        .display
+        .set_custom_orientation(0x60)
+        .await
+        .unwrap();
+
+    let mut textbuffer = TextBuffer::new();
+    textbuffer.fill('A');
+    textbuffer.draw(&mut framebuffer);
+    info!("finished rendering");
+
+    loop {
+        framebuffer.draw().await.unwrap();
+        Timer::after_millis(500).await;
+    }
+}

pico/src/main.rs

@@ -0,0 +1,60 @@
+#![feature(impl_trait_in_assoc_type)]
+#![feature(ascii_char)]
+#![no_std]
+#![no_main]
+
+#[cfg(feature = "defmt")]
+use defmt::*;
+use {defmt_rtt as _, panic_probe as _};
+
+use embassy_executor::Spawner;
+use embassy_rp::peripherals::I2C1;
+use embassy_rp::spi::Spi;
+use embassy_rp::{
+    bind_interrupts,
+    gpio::{Level, Output},
+    i2c,
+    i2c::I2c,
+    spi,
+};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::channel::Channel;
+use embassy_time::Timer;
+use embedded_hal_bus::spi::ExclusiveDevice;
+use embedded_sdmmc::asynchronous::{File, SdCard, ShortFileName, VolumeIdx, VolumeManager};
+use static_cell::StaticCell;
+
+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_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    static KEYBOARD_EVENTS: StaticCell<Channel<NoopRawMutex, KeyEvent, 10>> = StaticCell::new();
+    let keyboard_events = KEYBOARD_EVENTS.init(Channel::new());
+
+    // // configure keyboard event handler
+    // let mut config = i2c::Config::default();
+    // config.frequency = 100_000;
+    // let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
+    // spawner
+    //     .spawn(peripherals_task(i2c1, keyboard_events.sender()))
+    //     .unwrap();
+
+    // configure display handler
+    let mut config = spi::Config::default();
+    config.frequency = 16_000_000;
+    let spi1 = spi::Spi::new(
+        p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, p.DMA_CH0, p.DMA_CH1, config,
+    );
+    spawner
+        .spawn(display_task(spi1, p.PIN_13, p.PIN_14, p.PIN_15))
+        .unwrap();
+}

pico/src/peripherals/keyboard.rs

@@ -0,0 +1,207 @@
+use defmt::{info, warn};
+use embassy_rp::{
+    i2c::{Async, I2c},
+    peripherals::I2C1,
+};
+use embassy_sync::{
+    blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex},
+    channel::Sender,
+};
+
+use crate::peripherals::PERIPHERAL_BUS;
+
+const REG_ID_KEY: u8 = 0x04;
+const REG_ID_FIF: u8 = 0x09;
+
+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(channel: &mut Sender<'static, NoopRawMutex, KeyEvent, 10>) {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let mut key_status = [0_u8; 1];
+
+    if i2c
+        .write_read_async(super::MCU_ADDR, [REG_ID_KEY], &mut key_status)
+        .await
+        .is_ok()
+    {
+        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 {
+            let mut event = [0_u8; 2];
+
+            if i2c
+                .write_read_async(super::MCU_ADDR, [REG_ID_FIF], &mut event)
+                .await
+                .is_ok()
+            {
+                channel
+                    .try_send(KeyEvent {
+                        state: KeyState::from(event[0]),
+                        key: KeyCode::from(event[1]),
+                        mods: Modifiers::NONE,
+                    })
+                    .expect("Failed to push key");
+            }
+        }
+    }
+}
+
+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,
+}
+
+impl From<u8> for KeyState {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => KeyState::Pressed,
+            2 => KeyState::Hold,
+            3 => KeyState::Released,
+            0 | _ => KeyState::Idle,
+        }
+    }
+}
+
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum KeyCode {
+    JoyUp = 0x01,
+    JoyDown = 0x02,
+    JoyLeft = 0x03,
+    JoyRight = 0x04,
+    JoyCenter = 0x05,
+    BtnLeft1 = 0x06,
+    BtnRight1 = 0x07,
+    BtnLeft2 = 0x11,
+    BtnRight2 = 0x12,
+    Backspace = 0x08,
+    Tab = 0x09,
+    Enter = 0x0A,
+    ModAlt = 0xA1,
+    ModShiftLeft = 0xA2,
+    ModShiftRight = 0xA3,
+    ModSym = 0xA4,
+    ModCtrl = 0xA5,
+    Esc = 0xB1,
+    Left = 0xB4,
+    Up = 0xB5,
+    Down = 0xB6,
+    Right = 0xB7,
+    Break = 0xD0,
+    Insert = 0xD1,
+    Home = 0xD2,
+    Del = 0xD4,
+    End = 0xD5,
+    PageUp = 0xD6,
+    PageDown = 0xD7,
+    CapsLock = 0xC1,
+    F1 = 0x81,
+    F2 = 0x82,
+    F3 = 0x83,
+    F4 = 0x84,
+    F5 = 0x85,
+    F6 = 0x86,
+    F7 = 0x87,
+    F8 = 0x88,
+    F9 = 0x89,
+    F10 = 0x90,
+    Char(char),
+    Unknown(u8),
+}
+
+impl From<u8> for KeyCode {
+    fn from(value: u8) -> Self {
+        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),
+            },
+        }
+    }
+}

pico/src/peripherals/mod.rs

@@ -0,0 +1,106 @@
+//! handles all the peripherals exposed by mcu through i2c (keyboard & battery registers)
+//!
+
+use embassy_rp::{
+    i2c::{Async, I2c},
+    peripherals::I2C1,
+};
+use embassy_sync::{
+    blocking_mutex::raw::NoopRawMutex, channel::Sender, lazy_lock::LazyLock, mutex::Mutex,
+};
+use embassy_time::{Duration, Timer};
+
+pub mod keyboard;
+use keyboard::{KeyCode, KeyEvent, KeyState};
+
+use crate::peripherals::keyboard::{configure_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_INT: u8 = 0x03;
+
+#[embassy_executor::task]
+pub async fn peripherals_task(
+    i2c: I2CBUS,
+    mut keyboard_channel: Sender<'static, NoopRawMutex, KeyEvent, 10>,
+) {
+    Timer::after(embassy_time::Duration::from_millis(100)).await;
+
+    PERIPHERAL_BUS.get().lock().await.replace(i2c);
+
+    configure_keyboard(200, 100).await;
+    set_lcd_backlight(255).await;
+    set_key_backlight(0).await;
+
+    loop {
+        Timer::after(Duration::from_millis(200)).await;
+        read_keyboard_fifo(&mut keyboard_channel).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]
+}